Create type aliases for unresolved type symbols #45976

ahejlsberg · 2021-09-20T23:54:17Z

With this PR we create type aliases for unresolved symbols such that quick info and error messages list back the unresolved name instead of just any.

In this example where ItemData is not defined:

function foo(items: ItemData[]) {
    let item = items[0];
}

hovering over item and items now shows ItemData and ItemData[] where previously we'd just show any and any[]. Furthermore, hovering over the unresolved ItemData reference shows type ItemData = /*unresolved*/ any.

Fixes #45893.

DanielRosenwasser

Largely looks good, though I think this needs fourslash and possibly syntax server tests, specifically for

find all references
go to definition (at least the fact that it doesn't work)
quick info

DanielRosenwasser · 2021-09-21T18:51:21Z

src/compiler/checker.ts

@@ -4520,7 +4523,7 @@ namespace ts {
            const noTruncation = compilerOptions.noErrorTruncation || flags & TypeFormatFlags.NoTruncation;
            const typeNode = nodeBuilder.typeToTypeNode(type, enclosingDeclaration, toNodeBuilderFlags(flags) | NodeBuilderFlags.IgnoreErrors | (noTruncation ? NodeBuilderFlags.NoTruncation : 0), writer);
            if (typeNode === undefined) return Debug.fail("should always get typenode");
-            const options = { removeComments: true };
+            const options = { removeComments: type !== unresolvedType };


Would be helpful to leave a comment on this one (pun intended).

Suggested change

const options = { removeComments: type !== unresolvedType };

// The unresolved type gets a synthesized comment on `any`

// to hint to users that it's not a plain `any`.

// Otherwise, we always strip comments out.

const options = { removeComments: type !== unresolvedType };

Sure, I'll add a comment.

DanielRosenwasser · 2021-09-21T18:56:54Z

src/compiler/checker.ts

@@ -8255,6 +8269,10 @@ namespace ts {
            return type && (type.flags & TypeFlags.Any) !== 0;
        }

+        function isErrorType(type: Type) {
+            return type === errorType || !!(type.flags & TypeFlags.Any && type.aliasSymbol);


Why not just this? Seems like it'd be cheaper too.

Suggested change

return type === errorType || !!(type.flags & TypeFlags.Any && type.aliasSymbol);

return type === errorType || type === unresolvedType;

No, that wouldn't work. I'll add a clarifying comment, but basically we want to identify the special TypeFlags.Any types produced by getTypeForTypeAliasReference for an unresolved symbol. The sole purpose of unresolvedType is to act as the declared type for the special type alias symbols we create for unresolved names. The type is never actually returned by anything because getTypeForTypeAliasReference maps it into a special TypeFlags.Any type with an aliasSymbol.

DanielRosenwasser · 2021-09-21T18:59:56Z

tests/baselines/reference/asyncFunctionDeclaration13_es6.types

@@ -4,6 +4,6 @@ async function foo(): Promise<void> {

   // Legal to use 'await' in a type context.
   var v: await;
->v : any
+>v : await


Is there some way to make the type writer a little smarter here so that the team can differentiate between an unresolved and a concrete type?

We certainly have the ability to tell the difference, but what did you have in mind in terms of output? Remember that we're often dealing with composed types, e.g. for var v: Promise<await[]> we can't easily attach a comment to the await identifier in the output.

A parenthesized type might work like (/*unresolved*/ await)

I'm not really sure we want to do that. We're already generate an error at every reference to an unresolved symbol, I don't think we also want the extra noise in the type baselines.

DanielRosenwasser · 2021-09-21T23:04:35Z

I guess this doesn't technically fix #38836 because this only applies to types, right?

ahejlsberg · 2021-09-22T14:00:58Z

Right, this doesn't fix #38836. One complication there would be what scope to introduce the unknown value symbols into. Should they be locals of the innermost enclosing function, or just globals like we do for the type symbols? The latter typically makes sense for types, but less clear for unresolved value symbols.

DanielRosenwasser · 2021-09-22T18:47:29Z

or just globals like we do for the type symbols

I think just a global scope makes enough sense; if you do have a bunch of unresolved variables spread throughout your codebase, it's convenient to find-all-references, and likely to be a global anyhow; if it's mostly local (e.g. a user forgot to locally declare it), it doesn't really matter where you put it. But I'd understand if we wanted to take it one step at a time.

DanielRosenwasser · 2021-09-22T23:41:50Z

Looks like there's a few conflicts that need to be resolved.

# Conflicts: # src/compiler/checker.ts # tests/cases/fourslash/findReferencesJSXTagName.ts # tests/cases/fourslash/tsxFindAllReferences10.ts

ahejlsberg added 3 commits September 20, 2021 14:26

Create type aliases for unresolved type symbols

981cbb3

Accept new baselines

17332e1

Update fourslash tests

3d34ca7

typescript-bot assigned ahejlsberg Sep 20, 2021

typescript-bot added Author: Team For Milestone Bug PRs that fix a bug with a specific milestone labels Sep 20, 2021

ahejlsberg requested review from DanielRosenwasser and andrewbranch September 20, 2021 23:54

DanielRosenwasser requested changes Sep 21, 2021

View reviewed changes

Unresolved import aliases create tagged unresolved symbols

8f828c4

ahejlsberg added 4 commits September 22, 2021 17:49

Add comments

891f961

Merge branch 'main' into fix45893

e949c85

# Conflicts: # src/compiler/checker.ts # tests/cases/fourslash/findReferencesJSXTagName.ts # tests/cases/fourslash/tsxFindAllReferences10.ts

Accept new baselines

5314074

Add fourslash tests

9d01571

andrewbranch approved these changes Sep 23, 2021

View reviewed changes

ahejlsberg merged commit a4f9bf0 into main Sep 23, 2021

ahejlsberg deleted the fix45893 branch September 23, 2021 20:21

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Create type aliases for unresolved type symbols #45976

Create type aliases for unresolved type symbols #45976

ahejlsberg commented Sep 20, 2021

DanielRosenwasser left a comment •

edited

Loading

DanielRosenwasser Sep 21, 2021

ahejlsberg Sep 22, 2021

DanielRosenwasser Sep 21, 2021

ahejlsberg Sep 22, 2021

DanielRosenwasser Sep 21, 2021

ahejlsberg Sep 22, 2021

DanielRosenwasser Sep 22, 2021

ahejlsberg Sep 23, 2021

DanielRosenwasser commented Sep 21, 2021 •

edited

Loading

ahejlsberg commented Sep 22, 2021

DanielRosenwasser commented Sep 22, 2021

DanielRosenwasser commented Sep 22, 2021

-            const options = { removeComments: type !== unresolvedType };
+            // The unresolved type gets a synthesized comment on `any`
+            // to hint to users that it's not a plain `any`.
+            // Otherwise, we always strip comments out.
+            const options = { removeComments: type !== unresolvedType };

	return type === errorType \|\| !!(type.flags & TypeFlags.Any && type.aliasSymbol);
	return type === errorType \|\| type === unresolvedType;

Create type aliases for unresolved type symbols #45976

Create type aliases for unresolved type symbols #45976

Conversation

ahejlsberg commented Sep 20, 2021

DanielRosenwasser left a comment • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

DanielRosenwasser commented Sep 21, 2021 • edited Loading

ahejlsberg commented Sep 22, 2021

DanielRosenwasser commented Sep 22, 2021

DanielRosenwasser commented Sep 22, 2021

DanielRosenwasser left a comment •

edited

Loading

DanielRosenwasser commented Sep 21, 2021 •

edited

Loading