Add globalThis

src/compiler/binder.ts

@@ -2499,8 +2499,13 @@ namespace ts {
                     declareSymbol(symbolTable, containingClass.symbol, node, SymbolFlags.Property, SymbolFlags.None, /*isReplaceableByMethod*/ true);
                     break;
                 case SyntaxKind.SourceFile:
-                    // this.foo assignment in a source file
-                    // Do not bind. It would be nice to support this someday though.
+                    // this.property = assignment in a source file -- declare symbol in exports for a module, in locals for a script
+                    if ((thisContainer as SourceFile).commonJsModuleIndicator) {
+                        declareSymbol(thisContainer.symbol.exports!, thisContainer.symbol, node, SymbolFlags.Property | SymbolFlags.ExportValue, SymbolFlags.None);
+                    }
+                    else {
+                        declareSymbolAndAddToSymbolTable(node, SymbolFlags.FunctionScopedVariable, SymbolFlags.FunctionScopedVariableExcludes);
+                    }
                     break;
 
                 default:

src/compiler/checker.ts

@@ -88,8 +88,16 @@ namespace ts {
         const emitResolver = createResolver();
         const nodeBuilder = createNodeBuilder();
 
+        const globals = createSymbolTable();
         const undefinedSymbol = createSymbol(SymbolFlags.Property, "undefined" as __String);
         undefinedSymbol.declarations = [];
+
+        const globalThisSymbol = createSymbol(SymbolFlags.ValueModule | SymbolFlags.NamespaceModule, "globalThis" as __String, CheckFlags.Readonly);
+        globalThisSymbol.exports = globals;
+        globalThisSymbol.valueDeclaration = createNode(SyntaxKind.Identifier) as Identifier;
+        (globalThisSymbol.valueDeclaration as Identifier).escapedText = "globalThis" as __String;
+        globals.set(globalThisSymbol.escapedName, globalThisSymbol);
+
         const argumentsSymbol = createSymbol(SymbolFlags.Property, "arguments" as __String);
         const requireSymbol = createSymbol(SymbolFlags.Property, "require" as __String);
 
@@ -459,7 +467,6 @@ namespace ts {
 
         const enumNumberIndexInfo = createIndexInfo(stringType, /*isReadonly*/ true);
 
-        const globals = createSymbolTable();
         interface DuplicateInfoForSymbol {
             readonly firstFileLocations: Node[];
             readonly secondFileLocations: Node[];
@@ -9694,7 +9701,7 @@ namespace ts {
         }
 
         function getLiteralTypeFromProperties(type: Type, include: TypeFlags) {
-            return getUnionType(map(getPropertiesOfType(type), t => getLiteralTypeFromProperty(t, include)));
+            return getUnionType(map(getPropertiesOfType(type), p => getLiteralTypeFromProperty(p, include)));
         }
 
         function getNonEnumNumberIndexInfo(type: Type) {
@@ -16948,17 +16955,19 @@ namespace ts {
             }
 
             const type = tryGetThisTypeAt(node, container);
-            if (!type && noImplicitThis) {
-                // With noImplicitThis, functions may not reference 'this' if it has type 'any'
-                const diag = error(
-                    node,
-                    capturedByArrowFunction && container.kind === SyntaxKind.SourceFile ?
-                        Diagnostics.The_containing_arrow_function_captures_the_global_value_of_this_which_implicitly_has_type_any :
-                        Diagnostics.this_implicitly_has_type_any_because_it_does_not_have_a_type_annotation);
-                if (!isSourceFile(container)) {
-                    const outsideThis = tryGetThisTypeAt(container);
-                    if (outsideThis) {
-                        addRelatedInfo(diag, createDiagnosticForNode(container, Diagnostics.An_outer_value_of_this_is_shadowed_by_this_container));
+            const globalThisType = getTypeOfSymbol(globalThisSymbol);
+            if (noImplicitThis) {
+                if (type === globalThisType && capturedByArrowFunction) {
+                    error(node, Diagnostics.The_containing_arrow_function_captures_the_global_value_of_this);
+                }
+                else if (!type) {
+                    // With noImplicitThis, functions may not reference 'this' if it has type 'any'
+                    const diag = error(node, Diagnostics.this_implicitly_has_type_any_because_it_does_not_have_a_type_annotation);
+                    if (!isSourceFile(container)) {
+                        const outsideThis = tryGetThisTypeAt(container);
+                        if (outsideThis && outsideThis !== globalThisType) {
+                            addRelatedInfo(diag, createDiagnosticForNode(container, Diagnostics.An_outer_value_of_this_is_shadowed_by_this_container));
+                        }
                     }
                 }
             }
@@ -17012,6 +17021,16 @@ namespace ts {
                     return getFlowTypeOfReference(node, type);
                 }
             }
+            if (isSourceFile(container)) {
+                // look up in the source file's locals or exports
+                if (container.commonJsModuleIndicator) {
+                    const fileSymbol = getSymbolOfNode(container);
+                    return fileSymbol && getTypeOfSymbol(fileSymbol);
+                }
+                else {
+                    return getTypeOfSymbol(globalThisSymbol);
+                }
+            }
         }
 
         function getClassNameFromPrototypeMethod(container: Node) {
@@ -19309,6 +19328,12 @@ namespace ts {
                     if (isJSLiteralType(leftType)) {
                         return anyType;
                     }
+                    if (leftType.symbol === globalThisSymbol) {
+                        if (noImplicitAny) {
+                            error(right, Diagnostics.Element_implicitly_has_an_any_type_because_type_0_has_no_index_signature, typeToString(leftType));
+                        }
+                        return anyType;
+                    }
                     if (right.escapedText && !checkAndReportErrorForExtendingInterface(node)) {
                         reportNonexistentProperty(right, leftType.flags & TypeFlags.TypeParameter && (leftType as TypeParameter).isThisType ? apparentType : leftType);
                     }

src/compiler/diagnosticMessages.json

@@ -4145,7 +4145,7 @@
         "category": "Error",
         "code": 7040
     },
-    "The containing arrow function captures the global value of 'this' which implicitly has type 'any'.": {
+    "The containing arrow function captures the global value of 'this'.": {
         "category": "Error",
         "code": 7041
     },

src/harness/fourslash.ts

@@ -774,7 +774,7 @@ namespace FourSlash {
             if ("exact" in options) {
                 ts.Debug.assert(!("includes" in options) && !("excludes" in options));
                 if (options.exact === undefined) throw this.raiseError("Expected no completions");
-                this.verifyCompletionsAreExactly(actualCompletions.entries, toArray(options.exact));
+                this.verifyCompletionsAreExactly(actualCompletions.entries, toArray(options.exact), options.marker);
             }
             else {
                 if (options.includes) {
@@ -841,14 +841,14 @@ namespace FourSlash {
             }
         }
 
-        private verifyCompletionsAreExactly(actual: ReadonlyArray<ts.CompletionEntry>, expected: ReadonlyArray<FourSlashInterface.ExpectedCompletionEntry>) {
+        private verifyCompletionsAreExactly(actual: ReadonlyArray<ts.CompletionEntry>, expected: ReadonlyArray<FourSlashInterface.ExpectedCompletionEntry>, marker?: ArrayOrSingle<string | Marker>) {
             // First pass: test that names are right. Then we'll test details.
-            assert.deepEqual(actual.map(a => a.name), expected.map(e => typeof e === "string" ? e : e.name));
+            assert.deepEqual(actual.map(a => a.name), expected.map(e => typeof e === "string" ? e : e.name), marker ? "At marker " + JSON.stringify(marker) : undefined);
 
             ts.zipWith(actual, expected, (completion, expectedCompletion, index) => {
                 const name = typeof expectedCompletion === "string" ? expectedCompletion : expectedCompletion.name;
                 if (completion.name !== name) {
-                    this.raiseError(`Expected completion at index ${index} to be ${name}, got ${completion.name}`);
+                    this.raiseError(`${marker ? JSON.stringify(marker) : "" } Expected completion at index ${index} to be ${name}, got ${completion.name}`);
                 }
                 this.verifyCompletionEntry(completion, expectedCompletion);
             });
@@ -4545,6 +4545,7 @@ namespace FourSlashInterface {
 
         export function globalTypesPlus(plus: ReadonlyArray<ExpectedCompletionEntry>): ReadonlyArray<ExpectedCompletionEntry> {
             return [
+                { name: "globalThis", kind: "module" },
                 ...globalTypeDecls,
                 ...plus,
                 ...typeKeywords,
@@ -4786,6 +4787,7 @@ namespace FourSlashInterface {
         export const globalsInsideFunction = (plus: ReadonlyArray<ExpectedCompletionEntry>): ReadonlyArray<ExpectedCompletionEntry> => [
             { name: "arguments", kind: "local var" },
             ...plus,
+            { name: "globalThis", kind: "module" },
             ...globalsVars,
             { name: "undefined", kind: "var" },
             ...globalKeywordsInsideFunction,
@@ -4921,13 +4923,19 @@ namespace FourSlashInterface {
         })();
 
         export const globals: ReadonlyArray<ExpectedCompletionEntryObject> = [
+            { name: "globalThis", kind: "module" },
             ...globalsVars,
             { name: "undefined", kind: "var" },
             ...globalKeywords
         ];
 
         export function globalsPlus(plus: ReadonlyArray<ExpectedCompletionEntry>): ReadonlyArray<ExpectedCompletionEntry> {
-            return [...globalsVars, ...plus, { name: "undefined", kind: "var" }, ...globalKeywords];
+            return [
+                { name: "globalThis", kind: "module" },
+                ...globalsVars,
+                ...plus,
+                { name: "undefined", kind: "var" },
+                ...globalKeywords];
         }
     }
 

src/services/completions.ts

@@ -1031,7 +1031,7 @@ namespace ts.Completions {
             // Need to insert 'this.' before properties of `this` type, so only do that if `includeInsertTextCompletions`
             if (preferences.includeCompletionsWithInsertText && scopeNode.kind !== SyntaxKind.SourceFile) {
                 const thisType = typeChecker.tryGetThisTypeAt(scopeNode);
-                if (thisType) {
+                if (thisType && thisType.symbol.name !== "globalThis") {
                     for (const symbol of getPropertiesForCompletion(thisType, typeChecker)) {
                         symbolToOriginInfoMap[getSymbolId(symbol)] = { kind: SymbolOriginInfoKind.ThisType };
                         symbols.push(symbol);

src/testRunner/unittests/tsserver/projects.ts

@@ -708,7 +708,7 @@ namespace ts.projectSystem {
             // Check identifiers defined in HTML content are available in .ts file
             const project = configuredProjectAt(projectService, 0);
             let completions = project.getLanguageService().getCompletionsAtPosition(file1.path, 1, emptyOptions);
-            assert(completions && completions.entries[0].name === "hello", `expected entry hello to be in completion list`);
+            assert(completions && completions.entries[1].name === "hello", `expected entry hello to be in completion list`);
 
             // Close HTML file
             projectService.applyChangesInOpenFiles(

tests/baselines/reference/assignmentLHSIsValue.symbols

@@ -27,6 +27,7 @@ function foo() { this = value; }
 >value : Symbol(value, Decl(assignmentLHSIsValue.ts, 1, 3))
 
 this = value;
+>this : Symbol(globalThis)
 >value : Symbol(value, Decl(assignmentLHSIsValue.ts, 1, 3))
 
 // identifiers: module, class, enum, function
@@ -116,6 +117,7 @@ foo() = value;
 
 // parentheses, the containted expression is value
 (this) = value;
+>this : Symbol(globalThis)
 >value : Symbol(value, Decl(assignmentLHSIsValue.ts, 1, 3))
 
 (M) = value;

tests/baselines/reference/assignmentLHSIsValue.types

@@ -33,7 +33,7 @@ function foo() { this = value; }
 
 this = value;
 >this = value : any
->this : any
+>this : typeof globalThis
 >value : any
 
 // identifiers: module, class, enum, function
@@ -159,8 +159,8 @@ foo() = value;
 // parentheses, the containted expression is value
 (this) = value;
 >(this) = value : any
->(this) : any
->this : any
+>(this) : typeof globalThis
+>this : typeof globalThis
 >value : any
 
 (M) = value;

tests/baselines/reference/castExpressionParentheses.symbols

@@ -21,7 +21,11 @@ declare var a;
 (<any>null); 
 // names and dotted names
 (<any>this); 
+>this : Symbol(globalThis)
+
 (<any>this.x); 
+>this : Symbol(globalThis)
+
 (<any>(<any>a).x);
 >a : Symbol(a, Decl(castExpressionParentheses.ts, 0, 11))
 

tests/baselines/reference/castExpressionParentheses.types

@@ -77,13 +77,13 @@ declare var a;
 (<any>this); 
 >(<any>this) : any
 ><any>this : any
->this : any
+>this : typeof globalThis
 
 (<any>this.x); 
 >(<any>this.x) : any
 ><any>this.x : any
 >this.x : any
->this : any
+>this : typeof globalThis
 >x : any
 
 (<any>(<any>a).x);

tests/baselines/reference/collisionThisExpressionAndAliasInGlobal.symbols

@@ -7,6 +7,7 @@ module a {
 }
 var f = () => this;
 >f : Symbol(f, Decl(collisionThisExpressionAndAliasInGlobal.ts, 3, 3))
+>this : Symbol(globalThis)
 
 import _this = a; // Error
 >_this : Symbol(_this, Decl(collisionThisExpressionAndAliasInGlobal.ts, 3, 19))

tests/baselines/reference/collisionThisExpressionAndAliasInGlobal.types

@@ -7,9 +7,9 @@ module a {
 >10 : 10
 }
 var f = () => this;
->f : () => any
->() => this : () => any
->this : any
+>f : () => typeof globalThis
+>() => this : () => typeof globalThis
+>this : typeof globalThis
 
 import _this = a; // Error
 >_this : typeof a

tests/baselines/reference/collisionThisExpressionAndAmbientClassInGlobal.symbols

@@ -4,6 +4,7 @@ declare class _this { // no error - as no code generation
 }
 var f = () => this;
 >f : Symbol(f, Decl(collisionThisExpressionAndAmbientClassInGlobal.ts, 2, 3))
+>this : Symbol(globalThis)
 
 var a = new _this(); // Error
 >a : Symbol(a, Decl(collisionThisExpressionAndAmbientClassInGlobal.ts, 3, 3))

tests/baselines/reference/collisionThisExpressionAndAmbientClassInGlobal.types

@@ -3,9 +3,9 @@ declare class _this { // no error - as no code generation
 >_this : _this
 }
 var f = () => this;
->f : () => any
->() => this : () => any
->this : any
+>f : () => typeof globalThis
+>() => this : () => typeof globalThis
+>this : typeof globalThis
 
 var a = new _this(); // Error
 >a : _this

tests/baselines/reference/collisionThisExpressionAndAmbientVarInGlobal.symbols

@@ -4,6 +4,7 @@ declare var _this: number; // no error as no code gen
 
 var f = () => this;
 >f : Symbol(f, Decl(collisionThisExpressionAndAmbientVarInGlobal.ts, 1, 3))
+>this : Symbol(globalThis)
 
 _this = 10; // Error
 >_this : Symbol(_this, Decl(collisionThisExpressionAndAmbientVarInGlobal.ts, 0, 11))

tests/baselines/reference/collisionThisExpressionAndAmbientVarInGlobal.types

@@ -3,9 +3,9 @@ declare var _this: number; // no error as no code gen
 >_this : number
 
 var f = () => this;
->f : () => any
->() => this : () => any
->this : any
+>f : () => typeof globalThis
+>() => this : () => typeof globalThis
+>this : typeof globalThis
 
 _this = 10; // Error
 >_this = 10 : 10

tests/baselines/reference/collisionThisExpressionAndClassInGlobal.symbols

@@ -4,4 +4,5 @@ class _this {
 }
 var f = () => this;
 >f : Symbol(f, Decl(collisionThisExpressionAndClassInGlobal.ts, 2, 3))
+>this : Symbol(globalThis)
 

tests/baselines/reference/collisionThisExpressionAndClassInGlobal.types

@@ -3,7 +3,7 @@ class _this {
 >_this : _this
 }
 var f = () => this;
->f : () => any
->() => this : () => any
->this : any
+>f : () => typeof globalThis
+>() => this : () => typeof globalThis
+>this : typeof globalThis
 

tests/baselines/reference/collisionThisExpressionAndEnumInGlobal.symbols

@@ -10,4 +10,5 @@ enum _this { // Error
 }
 var f = () => this;
 >f : Symbol(f, Decl(collisionThisExpressionAndEnumInGlobal.ts, 4, 3))
+>this : Symbol(globalThis)
 

tests/baselines/reference/collisionThisExpressionAndEnumInGlobal.types

@@ -9,7 +9,7 @@ enum _this { // Error
 >_thisVal2 : _this._thisVal2
 }
 var f = () => this;
->f : () => any
->() => this : () => any
->this : any
+>f : () => typeof globalThis
+>() => this : () => typeof globalThis
+>this : typeof globalThis
 

tests/baselines/reference/collisionThisExpressionAndFunctionInGlobal.symbols

@@ -6,4 +6,5 @@ function _this() { //Error
 }
 var f = () => this;
 >f : Symbol(f, Decl(collisionThisExpressionAndFunctionInGlobal.ts, 3, 3))
+>this : Symbol(globalThis)
 

tests/baselines/reference/collisionThisExpressionAndFunctionInGlobal.types

@@ -6,7 +6,7 @@ function _this() { //Error
 >10 : 10
 }
 var f = () => this;
->f : () => any
->() => this : () => any
->this : any
+>f : () => typeof globalThis
+>() => this : () => typeof globalThis
+>this : typeof globalThis
 

tests/baselines/reference/collisionThisExpressionAndLocalVarInLambda.symbols

@@ -15,6 +15,7 @@ var x = {
 
         return callback(this);
 >callback : Symbol(callback, Decl(collisionThisExpressionAndLocalVarInLambda.ts, 3, 14))
+>this : Symbol(globalThis)
     }
 }
 alert(x.doStuff(x => alert(x)));

tests/baselines/reference/collisionThisExpressionAndLocalVarInLambda.types

@@ -20,7 +20,7 @@ var x = {
         return callback(this);
 >callback(this) : any
 >callback : any
->this : any
+>this : typeof globalThis
     }
 }
 alert(x.doStuff(x => alert(x)));