mark error type in baselines very not-aggressively (microsoft#26346)

Author: weswigham

src/harness/harness.ts

@@ -1488,7 +1488,7 @@ namespace Harness {
                 !errors || (errors.length === 0) ? null : getErrorBaseline(inputFiles, errors, pretty));
         }
 
-        export function doTypeAndSymbolBaseline(baselinePath: string, program: ts.Program, allFiles: {unitName: string, content: string}[], opts?: Baseline.BaselineOptions, multifile?: boolean, skipTypeBaselines?: boolean, skipSymbolBaselines?: boolean) {
+        export function doTypeAndSymbolBaseline(baselinePath: string, program: ts.Program, allFiles: {unitName: string, content: string}[], opts?: Baseline.BaselineOptions, multifile?: boolean, skipTypeBaselines?: boolean, skipSymbolBaselines?: boolean, hasErrorBaseline?: boolean) {
             // The full walker simulates the types that you would get from doing a full
             // compile.  The pull walker simulates the types you get when you just do
             // a type query for a random node (like how the LS would do it).  Most of the
@@ -1504,7 +1504,7 @@ namespace Harness {
             // These types are equivalent, but depend on what order the compiler observed
             // certain parts of the program.
 
-            const fullWalker = new TypeWriterWalker(program, /*fullTypeCheck*/ true);
+            const fullWalker = new TypeWriterWalker(program, /*fullTypeCheck*/ true, !!hasErrorBaseline);
 
             // Produce baselines.  The first gives the types for all expressions.
             // The second gives symbols for all identifiers.

src/harness/typeWriter.ts

@@ -25,7 +25,7 @@ class TypeWriterWalker {
 
     private checker: ts.TypeChecker;
 
-    constructor(private program: ts.Program, fullTypeCheck: boolean) {
+    constructor(private program: ts.Program, fullTypeCheck: boolean, private hadErrorBaseline: boolean) {
         // Consider getting both the diagnostics checker and the non-diagnostics checker to verify
         // they are consistent.
         this.checker = fullTypeCheck
@@ -69,6 +69,26 @@ class TypeWriterWalker {
         }
     }
 
+    private isImportStatementName(node: ts.Node) {
+        if (ts.isImportSpecifier(node.parent) && (node.parent.name === node || node.parent.propertyName === node)) return true;
+        if (ts.isImportClause(node.parent) && node.parent.name === node) return true;
+        if (ts.isImportEqualsDeclaration(node.parent) && node.parent.name === node) return true;
+        return false;
+    }
+
+    private isExportStatementName(node: ts.Node) {
+        if (ts.isExportAssignment(node.parent) && node.parent.expression === node) return true;
+        if (ts.isExportSpecifier(node.parent) && (node.parent.name === node || node.parent.propertyName === node)) return true;
+        return false;
+    }
+
+    private isIntrinsicJsxTag(node: ts.Node) {
+        const p = node.parent;
+        if (!(ts.isJsxOpeningElement(p) || ts.isJsxClosingElement(p) || ts.isJsxSelfClosingElement(p))) return false;
+        if (p.tagName !== node) return false;
+        return ts.isIntrinsicJsxName(node.getText());
+    }
+
     private writeTypeOrSymbol(node: ts.Node, isSymbolWalk: boolean): TypeWriterResult | undefined {
         const actualPos = ts.skipTrivia(this.currentSourceFile.text, node.pos);
         const lineAndCharacter = this.currentSourceFile.getLineAndCharacterOfPosition(actualPos);
@@ -85,7 +105,31 @@ class TypeWriterWalker {
             // let type = this.checker.getTypeAtLocation(node);
             let type = ts.isExpressionWithTypeArgumentsInClassExtendsClause(node.parent) ? this.checker.getTypeAtLocation(node.parent) : undefined;
             if (!type || type.flags & ts.TypeFlags.Any) type = this.checker.getTypeAtLocation(node);
-            const typeString = this.checker.typeToString(type, node.parent, ts.TypeFormatFlags.NoTruncation | ts.TypeFormatFlags.AllowUniqueESSymbolType);
+            const typeString =
+                // Distinguish `errorType`s from `any`s; but only if the file has no errors.
+                // Additionally,
+                // * the LHS of a qualified name
+                // * a binding pattern name
+                // * labels
+                // * the "global" in "declare global"
+                // * the "target" in "new.target"
+                // * names in import statements
+                // * type-only names in export statements
+                // * and intrinsic jsx tag names
+                // return `error`s via `getTypeAtLocation`
+                // But this is generally expected, so we don't call those out, either
+                (!this.hadErrorBaseline &&
+                    type.flags & ts.TypeFlags.Any &&
+                    !ts.isBindingElement(node.parent) &&
+                    !ts.isPropertyAccessOrQualifiedName(node.parent) &&
+                    !ts.isLabelName(node) &&
+                    !(ts.isModuleDeclaration(node.parent) && ts.isGlobalScopeAugmentation(node.parent)) &&
+                    !ts.isMetaProperty(node.parent) &&
+                    !this.isImportStatementName(node) &&
+                    !this.isExportStatementName(node) &&
+                    !this.isIntrinsicJsxTag(node)) ?
+                (type as ts.IntrinsicType).intrinsicName :
+                this.checker.typeToString(type, node.parent, ts.TypeFormatFlags.NoTruncation | ts.TypeFormatFlags.AllowUniqueESSymbolType);
             return {
                 line: lineAndCharacter.line,
                 syntaxKind: node.kind,

src/testRunner/compilerRunner.ts

@@ -253,7 +253,13 @@ class CompilerTest {
         Harness.Compiler.doTypeAndSymbolBaseline(
             this.justName,
             this.result.program!,
-            this.toBeCompiled.concat(this.otherFiles).filter(file => !!this.result.program!.getSourceFile(file.unitName)));
+            this.toBeCompiled.concat(this.otherFiles).filter(file => !!this.result.program!.getSourceFile(file.unitName)),
+            /*opts*/ undefined,
+            /*multifile*/ undefined,
+            /*skipTypeBaselines*/ undefined,
+            /*skipSymbolBaselines*/ undefined,
+            !!ts.length(this.result.diagnostics)
+        );
     }
 
     private makeUnitName(name: string, root: string) {

tests/baselines/reference/acceptableAlias1.types

@@ -6,7 +6,7 @@ module M {
     }
     export import X = N;
 >X : any
->N : any
+>N : error
 }
 
 import r = M.X;

tests/baselines/reference/aliasInaccessibleModule.types

@@ -6,5 +6,5 @@ module M {
     }
     export import X = N;
 >X : any
->N : any
+>N : error
 }

tests/baselines/reference/checkJsFiles_skipDiagnostics.types

@@ -6,17 +6,17 @@ var x = 0;
 
 /// @ts-ignore
 x();
->x() : any
+>x() : error
 >x : number
 
 /// @ts-ignore
 x();
->x() : any
+>x() : error
 >x : number
 
 /// @ts-ignore
 x(
->x(    2,    3) : any
+>x(    2,    3) : error
 >x : number
 
     2,
@@ -34,13 +34,13 @@ x(
 // @another
 
 x();
->x() : any
+>x() : error
 >x : number
 
 
 
 // @ts-ignore: no call signature
 x();
->x() : any
+>x() : error
 >x : number
 

tests/baselines/reference/declarationEmitNameConflictsWithAlias.types

@@ -2,7 +2,7 @@
 export module C { export interface I { } }
 export import v = C;
 >v : any
->C : any
+>C : error
 
 export module M {
 >M : typeof M

tests/baselines/reference/doubleUnderscoreReactNamespace.types

@@ -11,8 +11,8 @@ declare var __foot: any;
 >__foot : any
 
 const thing = <__foot />;
->thing : any
-><__foot /> : any
+>thing : error
+><__foot /> : error
 >__foot : any
 
 export {}

tests/baselines/reference/duplicateVarAndImport.types

@@ -7,5 +7,5 @@ var a;
 module M { }
 import a = M;
 >a : any
->M : any
+>M : error
 

tests/baselines/reference/es3-jsx-preserve.types

@@ -4,8 +4,8 @@ const React: any = null;
 >null : null
 
 const elem = <div></div>;
->elem : any
-><div></div> : any
+>elem : error
+><div></div> : error
 >div : any
 >div : any