[John Patterson (john-patterson)]

Fixes #28975.

As discussed in the body of the issue, this only makes a new suggestion when a value appears with as a type argument, like .

So, given the setup from #28975:
type Foo<T> = {}; const Something = [];,

This generates the new "error TS2774: 'Something' refers to a value, but is being used as a type argument here. Did you mean 'typeof Something'?" error:

type SomeFoo = Foo<Something>;

but a simple aliasing,

type SomeBar = Something;

generates the old "error TS2749: 'Something' refers to a value, but is being used as a type here." error.

I couldn't figure out a cleaner way to write the isIdentifierATypeArgument function. Currently, I'm checking the failing node's grandparent to see if the current node is in that node's typeArguments. This involves some casting and a findIndex, so if there's a better way to divine that with either meaning or node.kind, that would be preferrable.

[Ryan Cavanaugh (RyanCavanaugh)]

So the original issue outline in the issue showed this:

type Foo<T> = {}

const Something = []

type FooSomething = Foo<Something>
//                      ^
//                      Can not find name "Something"   

The error has since been updated to

//                      ^
//                      "Something" refers to a value, but is being used as a type here

The validity of suggesting to use typeof doesn't seem at all specific to a type argument position. The error message can just universally offer that as a potential idea and the developer can decide whether or not that's what they meant. IMO this should just be an update to the error message text without any conditionalizing based on the position of the identifier.

Wesley Wigham (@weswigham) What were your concrete concerns here? It wasn't clear from Daniel's comments

[Wesley Wigham (weswigham)]

Ryan Cavanaugh (@RyanCavanaugh) just that suggesting typeof X when X refers to a function value isn't likely correct - it's more often you mean the return type of X, especially if X is being used in a class-like way.

[John Patterson (john-patterson)]

Wesley Wigham (@weswigham) I'm still a little unsure of what you mean.

What I'm understanding as your argument is:

class Foo {}
function Bar(): Foo { return {}; }
type Baz = Bar;

it's more likely a user wants Baz to be equivalent to Foo instead of typeof Bar?

[John Patterson (john-patterson)]

As a side-note, it might be useful (on this PR or some other) to add an actual code fix operation for to go along with this error message change. Any objections?

[Wesley Wigham (weswigham)]

John Patterson (@john-patterson) yep, that was my premise. Its probably not too important, it was just a scenario to think about while this was implemented.

[John Patterson (john-patterson)]

Sorry to have orphaned this PR. To be clear, the issue is now just changing this message:

"Something" refers to a value, but is being used as a type here

To be something like:

"Something" refers to a value, but is being used as a type here. Did you mean 'typeof Something'?

I'll try to remember to gut the rest of this PR this weekend.

[Andrew Casey (amcasey)]

Closing in favor of #37359.