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

Author: weswigham

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);
+                }
             }
         }
 

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

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

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

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

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

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

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
     }
 }
 

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 {};

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))
+  }
+}