Preserve type nodes which resolve to errors in declaration emit output (#58475)

Author: weswigham

src/compiler/checker.ts

@@ -8160,7 +8160,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         function serializeTypeForDeclaration(context: NodeBuilderContext, declaration: Declaration | undefined, type: Type, symbol: Symbol) {
             const addUndefined = declaration && (isParameter(declaration) || isJSDocParameterTag(declaration)) && requiresAddingImplicitUndefined(declaration);
             const enclosingDeclaration = context.enclosingDeclaration;
-            if (!isErrorType(type) && enclosingDeclaration) {
+            if (enclosingDeclaration && (!isErrorType(type) || (context.flags & NodeBuilderFlags.AllowUnresolvedNames))) {
                 const declWithExistingAnnotation = declaration && getNonlocalEffectiveTypeAnnotationNode(declaration)
                     ? declaration
                     : getDeclarationWithTypeAnnotation(symbol, getEnclosingDeclarationIgnoringFakeScope(enclosingDeclaration));
@@ -8460,7 +8460,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                     );
                 }
                 if (isNamedDeclaration(node) && node.name.kind === SyntaxKind.ComputedPropertyName && !isLateBindableName(node.name)) {
-                    if (!(context.flags & NodeBuilderFlags.AllowUnresolvedComputedNames && hasDynamicName(node) && isEntityNameExpression(node.name.expression) && checkComputedPropertyName(node.name).flags & TypeFlags.Any)) {
+                    if (!(context.flags & NodeBuilderFlags.AllowUnresolvedNames && hasDynamicName(node) && isEntityNameExpression(node.name.expression) && checkComputedPropertyName(node.name).flags & TypeFlags.Any)) {
                         return undefined;
                     }
                 }

src/compiler/transformers/declarations.ts

@@ -233,7 +233,7 @@ const declarationEmitNodeBuilderFlags = NodeBuilderFlags.MultilineObjectLiterals
     NodeBuilderFlags.UseTypeOfFunction |
     NodeBuilderFlags.UseStructuralFallback |
     NodeBuilderFlags.AllowEmptyTuple |
-    NodeBuilderFlags.AllowUnresolvedComputedNames |
+    NodeBuilderFlags.AllowUnresolvedNames |
     NodeBuilderFlags.GenerateNamesForShadowedTypeParams |
     NodeBuilderFlags.NoTruncation;
 

src/compiler/types.ts

@@ -5432,7 +5432,7 @@ export const enum NodeBuilderFlags {
     // Errors (cont.)
     AllowNodeModulesRelativePaths           = 1 << 26,
     /** @internal */ DoNotIncludeSymbolChain = 1 << 27,    // Skip looking up and printing an accessible symbol chain
-    /** @internal */ AllowUnresolvedComputedNames = 1 << 32,
+    /** @internal */ AllowUnresolvedNames = 1 << 32,
 
     IgnoreErrors = AllowThisInObjectLiteral | AllowQualifiedNameInPlaceOfIdentifier | AllowAnonymousIdentifier | AllowEmptyUnionOrIntersection | AllowEmptyTuple | AllowEmptyIndexInfoType | AllowNodeModulesRelativePaths,
 

tests/baselines/reference/ArrowFunction1.types

@@ -3,9 +3,9 @@
 === ArrowFunction1.ts ===
 var v = (a: ) => {
 >v : (a: any) => void
->  : ^ ^^^^^^^^^^^^^^
+>  : ^ ^^   ^^^^^^^^^
 >(a: ) => {   } : (a: any) => void
->               : ^ ^^^^^^^^^^^^^^
+>               : ^ ^^   ^^^^^^^^^
 >a : any
 >  : ^^^
 

tests/baselines/reference/ClassAndModuleThatMergeWithModuleMemberThatUsesClassTypeParameter.types

@@ -22,7 +22,7 @@ module clodule1 {
 
     function f(x: T) { }
 >f : (x: T) => void
->  : ^ ^^^^^^^^^^^^
+>  : ^ ^^ ^^^^^^^^^
 >x : T
 >  : ^
 }

tests/baselines/reference/arguments.types

@@ -38,16 +38,16 @@ function f() {
 
 interface I {
     method(args: typeof arguments): void;
->method : (args: any) => void
->       : ^    ^^^^^^^^^^    
+>method : (args: typeof arguments) => void
+>       : ^    ^^                ^^^^^    
 >args : any
 >     : ^^^
 >arguments : any
 >          : ^^^
 
     fn: (args: typeof arguments) => void;
->fn : (args: any) => void
->   : ^    ^^^^^^^^^^    
+>fn : (args: typeof arguments) => void
+>   : ^    ^^                ^^^^^    
 >args : any
 >     : ^^^
 >arguments : any
@@ -66,8 +66,8 @@ interface I {
 >          : ^^^
 
     construct: new (args: typeof arguments) => void;
->construct : new (args: any) => void
->          : ^^^^^    ^^^^^^^^^^    
+>construct : new (args: typeof arguments) => void
+>          : ^^^^^    ^^                ^^^^^    
 >args : any
 >     : ^^^
 >arguments : any

tests/baselines/reference/arrayReferenceWithoutTypeArgs.types

@@ -6,8 +6,8 @@ class X {
 >  : ^
 
     public f(a: Array) { }
->f : (a: any) => void
->  : ^ ^^^^^^^^^^^^^^
+>f : (a: Array) => void
+>  : ^ ^^     ^^^^^^^^^
 >a : any
 >  : ^^^
 }

tests/baselines/reference/badExternalModuleReference.types

@@ -7,7 +7,7 @@ import a1 = require("garbage");
 
 export declare var a: {
 >a : { (): a1.connectExport; test1: a1.connectModule; }
->  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^                ^^^
 
     test1: a1.connectModule;
 >test1 : a1.connectModule

tests/baselines/reference/circularBaseTypes.types

@@ -15,8 +15,8 @@ type M3 = M2[keyof M2];  // Error
 >   : ^^^
 
 function f(m: M3) {
->f : (m: any) => any
->  : ^ ^^^^^^^^^^^^^
+>f : (m: M3) => any
+>  : ^ ^^  ^^^^^^^^
 >m : any
 >  : ^^^
 

tests/baselines/reference/errorsInGenericTypeReference.types

@@ -45,9 +45,9 @@ class testClass2<T> {
 }
 var tc2 = new testClass2<{ x: V }>(); // error: could not find symbol V
 >tc2 : testClass2<{ x: V; }>
->    : ^^^^^^^^^^^^^^^^^^^^^
+>    : ^^^^^^^^^^^^^^^^ ^^^^
 >new testClass2<{ x: V }>() : testClass2<{ x: V; }>
->                           : ^^^^^^^^^^^^^^^^^^^^^
+>                           : ^^^^^^^^^^^^^^^^ ^^^^
 >testClass2 : typeof testClass2
 >           : ^^^^^^^^^^^^^^^^^
 >x : V
@@ -73,15 +73,15 @@ class testClass3 {
 
     set a(value: Foo<{ x: V }>) { } // error: could not find symbol V
 >a : Foo<{ x: V; }>
->  : ^^^^^^^^^^^^^^
+>  : ^^^^^^^^^ ^^^^
 >value : Foo<{ x: V; }>
->      : ^^^^^^^^^^^^^^
+>      : ^^^^^^^^^ ^^^^
 >x : V
 >  : ^
 
     property: Foo<{ x: V }>; // error: could not find symbol V
 >property : Foo<{ x: V; }>
->         : ^^^^^^^^^^^^^^
+>         : ^^^^^^^^^ ^^^^
 >x : V
 >  : ^
 }
@@ -100,15 +100,15 @@ function testFunction2(p: Foo<{ x: V }>) { }// error: could not find symbol V
 >testFunction2 : (p: Foo<{ x: V; }>) => void
 >              : ^ ^^              ^^^^^^^^^
 >p : Foo<{ x: V; }>
->  : ^^^^^^^^^^^^^^
+>  : ^^^^^^^^^ ^^^^
 >x : V
 >  : ^
 
 
 // in var type annotation
 var f: Foo<{ x: V }>; // error: could not find symbol V
 >f : Foo<{ x: V; }>
->  : ^^^^^^^^^^^^^^
+>  : ^^^^^^^^^ ^^^^
 >x : V
 >  : ^
 
@@ -130,7 +130,7 @@ class testClass6<T> {
 
     method<M extends { x: V }>(): void { } // error: could not find symbol V
 >method : <M extends { x: V; }>() => void
->       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^    
+>       : ^^^^^^^^^^^^^^^^ ^^^^^^^^^^    
 >x : V
 >  : ^
 }
@@ -149,7 +149,7 @@ class testClass7 extends Foo<{ x: V }> { } // error: could not find symbol V
 >testClass7 : testClass7
 >           : ^^^^^^^^^^
 >Foo : Foo<{ x: V; }>
->    : ^^^^^^^^^^^^^^
+>    : ^^^^^^^^^ ^^^^
 >x : V
 >  : ^
 
@@ -166,7 +166,7 @@ class testClass8 implements IFoo<{ x: V }> { } // error: could not find symbol V
 interface testInterface2 {
     new (a: Foo<{ x: V }>): Foo<{ x: V }>; //2x: error: could not find symbol V
 >a : Foo<{ x: V; }>
->  : ^^^^^^^^^^^^^^
+>  : ^^^^^^^^^ ^^^^
 >x : V
 >  : ^
 >x : V
@@ -182,15 +182,15 @@ interface testInterface2 {
 >method : (a: Foo<{ x: V; }>) => Foo<{ x: V; }>
 >       : ^ ^^              ^^^^^              
 >a : Foo<{ x: V; }>
->  : ^^^^^^^^^^^^^^
+>  : ^^^^^^^^^ ^^^^
 >x : V
 >  : ^
 >x : V
 >  : ^
 
     property: Foo<{ x: V }>; // error: could not find symbol V
 >property : Foo<{ x: V; }>
->         : ^^^^^^^^^^^^^^
+>         : ^^^^^^^^^ ^^^^
 >x : V
 >  : ^
 }