Allow references to globalThis to be made in declaration emit (#35279)

weswigham · web-flow · commit 663a42be94f3 · 2019-11-21T15:21:35.000-08:00
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -3312,8 +3312,8 @@ namespace ts {
                     return [symbol!];
                 }
 
-                // Check if symbol is any of the alias
-                return forEachEntry(symbols, symbolFromSymbolTable => {
+                // Check if symbol is any of the aliases in scope
+                const result = forEachEntry(symbols, symbolFromSymbolTable => {
                     if (symbolFromSymbolTable.flags & SymbolFlags.Alias
                         && symbolFromSymbolTable.escapedName !== InternalSymbolName.ExportEquals
                         && symbolFromSymbolTable.escapedName !== InternalSymbolName.Default
@@ -3326,16 +3326,9 @@ namespace ts {
                     ) {
 
                         const resolvedImportedSymbol = resolveAlias(symbolFromSymbolTable);
-                        if (isAccessible(symbolFromSymbolTable, resolvedImportedSymbol, ignoreQualification)) {
-                            return [symbolFromSymbolTable];
-                        }
-
-                        // Look in the exported members, if we can find accessibleSymbolChain, symbol is accessible using this chain
-                        // but only if the symbolFromSymbolTable can be qualified
-                        const candidateTable = getExportsOfSymbol(resolvedImportedSymbol);
-                        const accessibleSymbolsFromExports = candidateTable && getAccessibleSymbolChainFromSymbolTable(candidateTable, /*ignoreQualification*/ true);
-                        if (accessibleSymbolsFromExports && canQualifySymbol(symbolFromSymbolTable, getQualifiedLeftMeaning(meaning))) {
-                            return [symbolFromSymbolTable].concat(accessibleSymbolsFromExports);
+                        const candidate = getCandidateListForSymbol(symbolFromSymbolTable, resolvedImportedSymbol, ignoreQualification);
+                        if (candidate) {
+                            return candidate;
                         }
                     }
                     if (symbolFromSymbolTable.escapedName === symbol!.escapedName && symbolFromSymbolTable.exportSymbol) {
@@ -3344,6 +3337,23 @@ namespace ts {
                         }
                     }
                 });
+
+                // If there's no result and we're looking at the global symbol table, treat `globalThis` like an alias and try to lookup thru that
+                return result || (symbols === globals ? getCandidateListForSymbol(globalThisSymbol, globalThisSymbol, ignoreQualification) : undefined);
+            }
+
+            function getCandidateListForSymbol(symbolFromSymbolTable: Symbol, resolvedImportedSymbol: Symbol, ignoreQualification: boolean | undefined) {
+                if (isAccessible(symbolFromSymbolTable, resolvedImportedSymbol, ignoreQualification)) {
+                    return [symbolFromSymbolTable];
+                }
+
+                // Look in the exported members, if we can find accessibleSymbolChain, symbol is accessible using this chain
+                // but only if the symbolFromSymbolTable can be qualified
+                const candidateTable = getExportsOfSymbol(resolvedImportedSymbol);
+                const accessibleSymbolsFromExports = candidateTable && getAccessibleSymbolChainFromSymbolTable(candidateTable, /*ignoreQualification*/ true);
+                if (accessibleSymbolsFromExports && canQualifySymbol(symbolFromSymbolTable, getQualifiedLeftMeaning(meaning))) {
+                    return [symbolFromSymbolTable].concat(accessibleSymbolsFromExports);
+                }
             }
         }
 
diff --git a/tests/baselines/reference/ModuleWithExportedAndNonExportedClasses.types b/tests/baselines/reference/ModuleWithExportedAndNonExportedClasses.types
@@ -1,6 +1,6 @@
 === tests/cases/conformance/internalModules/exportDeclarations/ModuleWithExportedAndNonExportedClasses.ts ===
 module A {
->A : typeof A
+>A : typeof globalThis.A
 
     export class A {
 >A : A
diff --git a/tests/baselines/reference/collisionCodeGenModuleWithMemberClassConflict.types b/tests/baselines/reference/collisionCodeGenModuleWithMemberClassConflict.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/collisionCodeGenModuleWithMemberClassConflict.ts ===
 module m1 {
->m1 : typeof m1
+>m1 : typeof globalThis.m1
 
     export class m1 {
 >m1 : m1
@@ -14,7 +14,7 @@ var foo = new m1.m1();
 >m1 : typeof m1.m1
 
 module m2 {
->m2 : typeof m2
+>m2 : typeof globalThis.m2
 
     export class m2 {
 >m2 : m2
diff --git a/tests/baselines/reference/collisionCodeGenModuleWithMemberVariable.types b/tests/baselines/reference/collisionCodeGenModuleWithMemberVariable.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/collisionCodeGenModuleWithMemberVariable.ts ===
 module m1 {
->m1 : typeof m1
+>m1 : typeof globalThis.m1
 
     export var m1 = 10;
 >m1 : number
diff --git a/tests/baselines/reference/collisionCodeGenModuleWithModuleReopening.types b/tests/baselines/reference/collisionCodeGenModuleWithModuleReopening.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/collisionCodeGenModuleWithModuleReopening.ts ===
 module m1 {
->m1 : typeof m1
+>m1 : typeof globalThis.m1
 
     export class m1 {
 >m1 : m1
@@ -14,7 +14,7 @@ var foo = new m1.m1();
 >m1 : typeof m1.m1
 
 module m1 {
->m1 : typeof m1
+>m1 : typeof globalThis.m1
 
     export class c1 {
 >c1 : c1
@@ -37,7 +37,7 @@ var foo2 = new m1.c1();
 >c1 : typeof m1.c1
 
 module m2 {
->m2 : typeof m2
+>m2 : typeof globalThis.m2
 
     export class c1 {
 >c1 : c1
@@ -59,7 +59,7 @@ var foo3 = new m2.c1();
 >c1 : typeof m2.c1
 
 module m2 {
->m2 : typeof m2
+>m2 : typeof globalThis.m2
 
     export class m2 {
 >m2 : m2
diff --git a/tests/baselines/reference/collisionCodeGenModuleWithPrivateMember.types b/tests/baselines/reference/collisionCodeGenModuleWithPrivateMember.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/collisionCodeGenModuleWithPrivateMember.ts ===
 module m1 {
->m1 : typeof m1
+>m1 : typeof globalThis.m1
 
     class m1 {
 >m1 : m1
diff --git a/tests/baselines/reference/collisionCodeGenModuleWithUnicodeNames.types b/tests/baselines/reference/collisionCodeGenModuleWithUnicodeNames.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/collisionCodeGenModuleWithUnicodeNames.ts ===
 module 才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123 {
->才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123 : typeof 才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123
+>才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123 : typeof globalThis.才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123
 
     export class 才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123 {
 >才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123 : 才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123
diff --git a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorTypeAlias.types b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorTypeAlias.types
@@ -34,7 +34,7 @@ module M1 {
 >Window : Window
 
         export var p: W; // No error
->p : string | Window
+>p : string | globalThis.Window
     }
 }
 
diff --git a/tests/baselines/reference/declarationsForFileShadowingGlobalNoError.js b/tests/baselines/reference/declarationsForFileShadowingGlobalNoError.js
@@ -0,0 +1,65 @@
+//// [tests/cases/compiler/declarationsForFileShadowingGlobalNoError.ts] ////
+
+//// [dom.ts]
+export type DOMNode = Node;
+//// [custom.ts]
+export type Node = {};
+//// [index.ts]
+import { Node } from './custom'
+import { DOMNode } from './dom'
+
+type Constructor = new (...args: any[]) => any
+
+export const mixin = (Base: Constructor) => {
+  return class extends Base {
+    get(domNode: DOMNode) {}
+  }
+}
+
+//// [dom.js]
+"use strict";
+exports.__esModule = true;
+//// [custom.js]
+"use strict";
+exports.__esModule = true;
+//// [index.js]
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+exports.__esModule = true;
+exports.mixin = function (Base) {
+    return /** @class */ (function (_super) {
+        __extends(class_1, _super);
+        function class_1() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        class_1.prototype.get = function (domNode) { };
+        return class_1;
+    }(Base));
+};
+
+
+//// [dom.d.ts]
+export declare type DOMNode = Node;
+//// [custom.d.ts]
+export declare type Node = {};
+//// [index.d.ts]
+declare type Constructor = new (...args: any[]) => any;
+export declare const mixin: (Base: Constructor) => {
+    new (...args: any[]): {
+        [x: string]: any;
+        get(domNode: globalThis.Node): void;
+    };
+};
+export {};
diff --git a/tests/baselines/reference/declarationsForFileShadowingGlobalNoError.symbols b/tests/baselines/reference/declarationsForFileShadowingGlobalNoError.symbols
@@ -0,0 +1,34 @@
+=== tests/cases/compiler/dom.ts ===
+export type DOMNode = Node;
+>DOMNode : Symbol(DOMNode, Decl(dom.ts, 0, 0))
+>Node : Symbol(Node, Decl(lib.dom.d.ts, --, --), Decl(lib.dom.d.ts, --, --))
+
+=== tests/cases/compiler/custom.ts ===
+export type Node = {};
+>Node : Symbol(Node, Decl(custom.ts, 0, 0))
+
+=== tests/cases/compiler/index.ts ===
+import { Node } from './custom'
+>Node : Symbol(Node, Decl(index.ts, 0, 8))
+
+import { DOMNode } from './dom'
+>DOMNode : Symbol(DOMNode, Decl(index.ts, 1, 8))
+
+type Constructor = new (...args: any[]) => any
+>Constructor : Symbol(Constructor, Decl(index.ts, 1, 31))
+>args : Symbol(args, Decl(index.ts, 3, 24))
+
+export const mixin = (Base: Constructor) => {
+>mixin : Symbol(mixin, Decl(index.ts, 5, 12))
+>Base : Symbol(Base, Decl(index.ts, 5, 22))
+>Constructor : Symbol(Constructor, Decl(index.ts, 1, 31))
+
+  return class extends Base {
+>Base : Symbol(Base, Decl(index.ts, 5, 22))
+
+    get(domNode: DOMNode) {}
+>get : Symbol((Anonymous class).get, Decl(index.ts, 6, 29))
+>domNode : Symbol(domNode, Decl(index.ts, 7, 8))
+>DOMNode : Symbol(DOMNode, Decl(index.ts, 1, 8))
+  }
+}
diff --git a/tests/baselines/reference/declarationsForFileShadowingGlobalNoError.types b/tests/baselines/reference/declarationsForFileShadowingGlobalNoError.types
@@ -0,0 +1,33 @@
+=== tests/cases/compiler/dom.ts ===
+export type DOMNode = Node;
+>DOMNode : Node
+
+=== tests/cases/compiler/custom.ts ===
+export type Node = {};
+>Node : Node
+
+=== tests/cases/compiler/index.ts ===
+import { Node } from './custom'
+>Node : any
+
+import { DOMNode } from './dom'
+>DOMNode : any
+
+type Constructor = new (...args: any[]) => any
+>Constructor : Constructor
+>args : any[]
+
+export const mixin = (Base: Constructor) => {
+>mixin : (Base: Constructor) => typeof (Anonymous class)
+>(Base: Constructor) => {  return class extends Base {    get(domNode: DOMNode) {}  }} : (Base: Constructor) => typeof (Anonymous class)
+>Base : Constructor
+
+  return class extends Base {
+>class extends Base {    get(domNode: DOMNode) {}  } : typeof (Anonymous class)
+>Base : Constructor
+
+    get(domNode: DOMNode) {}
+>get : (domNode: globalThis.Node) => void
+>domNode : globalThis.Node
+  }
+}
diff --git a/tests/baselines/reference/genericDefaults.types b/tests/baselines/reference/genericDefaults.types
@@ -1770,7 +1770,7 @@ const i06c02 = (<i06<number, string>>x).a;
 >a : [number, string]
 
 interface i07 { a: A; }
->a : A
+>a : globalThis.A
 
 interface i07<A = number> { b: A; }
 >b : A
diff --git a/tests/baselines/reference/importAndVariableDeclarationConflict1.types b/tests/baselines/reference/importAndVariableDeclarationConflict1.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/importAndVariableDeclarationConflict1.ts ===
 module m {
->m : typeof m
+>m : typeof globalThis.m
 
   export var m = '';
 >m : string
diff --git a/tests/baselines/reference/importAndVariableDeclarationConflict2.types b/tests/baselines/reference/importAndVariableDeclarationConflict2.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/importAndVariableDeclarationConflict2.ts ===
 module m {
->m : typeof m
+>m : typeof globalThis.m
 
   export var m = '';
 >m : string
diff --git a/tests/baselines/reference/importAndVariableDeclarationConflict3.types b/tests/baselines/reference/importAndVariableDeclarationConflict3.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/importAndVariableDeclarationConflict3.ts ===
 module m {
->m : typeof m
+>m : typeof globalThis.m
 
   export var m = '';
 >m : string
diff --git a/tests/baselines/reference/importAndVariableDeclarationConflict4.types b/tests/baselines/reference/importAndVariableDeclarationConflict4.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/importAndVariableDeclarationConflict4.ts ===
 module m {
->m : typeof m
+>m : typeof globalThis.m
 
   export var m = '';
 >m : string
diff --git a/tests/baselines/reference/importedModuleAddToGlobal.types b/tests/baselines/reference/importedModuleAddToGlobal.types
@@ -12,7 +12,7 @@ module A {
 }
 
 module B {
->B : typeof B
+>B : typeof globalThis.B
 
     import a = A;
 >a : any
diff --git a/tests/baselines/reference/incompatibleAssignmentOfIdenticallyNamedTypes.types b/tests/baselines/reference/incompatibleAssignmentOfIdenticallyNamedTypes.types
@@ -13,11 +13,11 @@ class Foo<T> {
 >fn : () => void
 
         this.x = a;
->this.x = a : T
+>this.x = a : globalThis.T
 >this.x : T
 >this : this
 >x : T
->a : T
+>a : globalThis.T
     }
 }
 
diff --git a/tests/baselines/reference/mergedModuleDeclarationCodeGen5.types b/tests/baselines/reference/mergedModuleDeclarationCodeGen5.types
@@ -13,7 +13,7 @@ module M.buz.plop {
 module M.buz.plop {
 >M : typeof M
 >buz : typeof buz
->plop : typeof M.buz.plop
+>plop : typeof globalThis.M.buz.plop
 
     function gunk() { }
 >gunk : () => void
diff --git a/tests/baselines/reference/moduleWithStatementsOfEveryKind.types b/tests/baselines/reference/moduleWithStatementsOfEveryKind.types
@@ -1,6 +1,6 @@
 === tests/cases/conformance/internalModules/moduleBody/moduleWithStatementsOfEveryKind.ts ===
 module A {
->A : typeof A
+>A : typeof globalThis.A
 
     class A { s: string }
 >A : A
diff --git a/tests/baselines/reference/nameCollision.types b/tests/baselines/reference/nameCollision.types
diff --git a/tests/baselines/reference/newOperatorConformance.types b/tests/baselines/reference/newOperatorConformance.types
diff --git a/tests/baselines/reference/newOperatorErrorCases.types b/tests/baselines/reference/newOperatorErrorCases.types
diff --git a/tests/baselines/reference/thisInModuleFunction1.types b/tests/baselines/reference/thisInModuleFunction1.types
diff --git a/tests/baselines/reference/tsxEmit3.types b/tests/baselines/reference/tsxEmit3.types
diff --git a/tests/baselines/reference/unusedTypeParametersCheckedByNoUnusedParameters.types b/tests/baselines/reference/unusedTypeParametersCheckedByNoUnusedParameters.types
diff --git a/tests/baselines/reference/unusedTypeParametersNotCheckedByNoUnusedLocals.types b/tests/baselines/reference/unusedTypeParametersNotCheckedByNoUnusedLocals.types
diff --git a/tests/cases/compiler/declarationsForFileShadowingGlobalNoError.ts b/tests/cases/compiler/declarationsForFileShadowingGlobalNoError.ts

Original file line number	Diff line number	Diff line change
`@@ -34,7 +34,7 @@ module M1 {`
`34`	`34`	`>Window : Window`
`35`	`35`
`36`	`36`	`export var p: W; // No error`
`37`		`->p : string \| Window`
	`37`	`+>p : string \| globalThis.Window`
`38`	`38`	`}`
`39`	`39`	`}`
`40`	`40`