Merge branch 'master' into use-assignability-not-subtype-in-substitution-instantiation

weswigham · weswigham · commit a2aefd4caaaf · 2019-04-19T14:33:29.000-07:00
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -1648,7 +1648,7 @@ namespace ts {
                 if (result && isInExternalModule && (meaning & SymbolFlags.Value) === SymbolFlags.Value && !(originalLocation!.flags & NodeFlags.JSDoc)) {
                     const merged = getMergedSymbol(result);
                     if (length(merged.declarations) && every(merged.declarations, d => isNamespaceExportDeclaration(d) || isSourceFile(d) && !!d.symbol.globalExports)) {
-                        error(errorLocation!, Diagnostics._0_refers_to_a_UMD_global_but_the_current_file_is_a_module_Consider_adding_an_import_instead, unescapeLeadingUnderscores(name)); // TODO: GH#18217
+                        errorOrSuggestion(!compilerOptions.allowUmdGlobalAccess, errorLocation!, Diagnostics._0_refers_to_a_UMD_global_but_the_current_file_is_a_module_Consider_adding_an_import_instead, unescapeLeadingUnderscores(name));
                     }
                 }
             }
@@ -20443,7 +20443,7 @@ namespace ts {
 
         function getArrayifiedType(type: Type) {
             if (forEachType(type, t => !(t.flags & (TypeFlags.Any | TypeFlags.Instantiable) || isArrayType(t) || isTupleType(t)))) {
-                return createArrayType(getIndexTypeOfType(type, IndexKind.Number) || errorType);
+                return createArrayType(getIndexedAccessType(type, numberType));
             }
             return type;
         }
diff --git a/src/compiler/commandLineParser.ts b/src/compiler/commandLineParser.ts
@@ -588,6 +588,13 @@ namespace ts {
             category: Diagnostics.Module_Resolution_Options,
             description: Diagnostics.Do_not_resolve_the_real_path_of_symlinks,
         },
+        {
+            name: "allowUmdGlobalAccess",
+            type: "boolean",
+            affectsSemanticDiagnostics: true,
+            category: Diagnostics.Module_Resolution_Options,
+            description: Diagnostics.Allow_accessing_UMD_globals_from_modules,
+        },
 
         // Source Maps
         {
diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json
@@ -4946,5 +4946,9 @@
     "Convert parameters to destructured object": {
         "category": "Message",
         "code": 95075
+    },
+    "Allow accessing UMD globals from modules.": {
+        "category": "Message",
+        "code": 95076
     }
 }
diff --git a/src/compiler/transformers/declarations.ts b/src/compiler/transformers/declarations.ts
@@ -63,7 +63,7 @@ namespace ts {
         let enclosingDeclaration: Node;
         let necessaryTypeReferences: Map<true> | undefined;
         let lateMarkedStatements: LateVisibilityPaintedStatement[] | undefined;
-        let lateStatementReplacementMap: Map<VisitResult<LateVisibilityPaintedStatement>>;
+        let lateStatementReplacementMap: Map<VisitResult<LateVisibilityPaintedStatement | ExportAssignment>>;
         let suppressNewDiagnosticContexts: boolean;
         let exportedModulesFromDeclarationEmit: Symbol[] | undefined;
 
@@ -701,12 +701,12 @@ namespace ts {
             }
         }
 
-        function isExternalModuleIndicator(result: LateVisibilityPaintedStatement) {
+        function isExternalModuleIndicator(result: LateVisibilityPaintedStatement | ExportAssignment) {
             // Exported top-level member indicates moduleness
             return isAnyImportOrReExport(result) || isExportAssignment(result) || hasModifier(result, ModifierFlags.Export);
         }
 
-        function needsScopeMarker(result: LateVisibilityPaintedStatement) {
+        function needsScopeMarker(result: LateVisibilityPaintedStatement | ExportAssignment) {
             return !isAnyImportOrReExport(result) && !isExportAssignment(result) && !hasModifier(result, ModifierFlags.Export) && !isAmbientModule(result);
         }
 
@@ -1047,7 +1047,43 @@ namespace ts {
                             return createVariableStatement(/*modifiers*/ undefined, createVariableDeclarationList([varDecl]));
                         });
                         const namespaceDecl = createModuleDeclaration(/*decorators*/ undefined, ensureModifiers(input, isPrivate), input.name!, createModuleBlock(declarations), NodeFlags.Namespace);
-                        return [clean, namespaceDecl];
+
+                        if (!hasModifier(clean, ModifierFlags.ExportDefault)) {
+                            return [clean, namespaceDecl];
+                        }
+
+                        const modifiers = createModifiersFromModifierFlags((getModifierFlags(clean) & ~ModifierFlags.ExportDefault) | ModifierFlags.Ambient);
+                        const cleanDeclaration = updateFunctionDeclaration(
+                            clean,
+                            /*decorators*/ undefined,
+                            modifiers,
+                            /*asteriskToken*/ undefined,
+                            clean.name,
+                            clean.typeParameters,
+                            clean.parameters,
+                            clean.type,
+                            /*body*/ undefined
+                        );
+
+                        const namespaceDeclaration = updateModuleDeclaration(
+                            namespaceDecl,
+                            /*decorators*/ undefined,
+                            modifiers,
+                            namespaceDecl.name,
+                            namespaceDecl.body
+                        );
+
+                        const exportDefaultDeclaration = createExportAssignment(
+                            /*decorators*/ undefined,
+                            /*modifiers*/ undefined,
+                            /*isExportEquals*/ false,
+                            namespaceDecl.name
+                        );
+
+                        resultHasExternalModuleIndicator = true;
+                        resultHasScopeMarker = true;
+
+                        return [cleanDeclaration, namespaceDeclaration, exportDefaultDeclaration];
                     }
                     else {
                         return clean;
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
@@ -4589,6 +4589,7 @@ namespace ts {
         allowJs?: boolean;
         /*@internal*/ allowNonTsExtensions?: boolean;
         allowSyntheticDefaultImports?: boolean;
+        allowUmdGlobalAccess?: boolean;
         allowUnreachableCode?: boolean;
         allowUnusedLabels?: boolean;
         alwaysStrict?: boolean;  // Always combine with strict property
diff --git a/tests/baselines/reference/api/tsserverlibrary.d.ts b/tests/baselines/reference/api/tsserverlibrary.d.ts
@@ -2492,6 +2492,7 @@ declare namespace ts {
     interface CompilerOptions {
         allowJs?: boolean;
         allowSyntheticDefaultImports?: boolean;
+        allowUmdGlobalAccess?: boolean;
         allowUnreachableCode?: boolean;
         allowUnusedLabels?: boolean;
         alwaysStrict?: boolean;
diff --git a/tests/baselines/reference/api/typescript.d.ts b/tests/baselines/reference/api/typescript.d.ts
@@ -2492,6 +2492,7 @@ declare namespace ts {
     interface CompilerOptions {
         allowJs?: boolean;
         allowSyntheticDefaultImports?: boolean;
+        allowUmdGlobalAccess?: boolean;
         allowUnreachableCode?: boolean;
         allowUnusedLabels?: boolean;
         alwaysStrict?: boolean;
diff --git a/tests/baselines/reference/exportDefaultNamespace.js b/tests/baselines/reference/exportDefaultNamespace.js
@@ -0,0 +1,24 @@
+//// [exportDefaultNamespace.ts]
+export default function someFunc() {
+    return 'hello!';
+}
+
+someFunc.someProp = 'yo';
+
+
+//// [exportDefaultNamespace.js]
+"use strict";
+exports.__esModule = true;
+function someFunc() {
+    return 'hello!';
+}
+exports["default"] = someFunc;
+someFunc.someProp = 'yo';
+
+
+//// [exportDefaultNamespace.d.ts]
+declare function someFunc(): string;
+declare namespace someFunc {
+    var someProp: string;
+}
+export default someFunc;
diff --git a/tests/baselines/reference/exportDefaultNamespace.symbols b/tests/baselines/reference/exportDefaultNamespace.symbols
@@ -0,0 +1,12 @@
+=== tests/cases/conformance/declarationEmit/exportDefaultNamespace.ts ===
+export default function someFunc() {
+>someFunc : Symbol(someFunc, Decl(exportDefaultNamespace.ts, 0, 0), Decl(exportDefaultNamespace.ts, 2, 1))
+
+    return 'hello!';
+}
+
+someFunc.someProp = 'yo';
+>someFunc.someProp : Symbol(someFunc.someProp, Decl(exportDefaultNamespace.ts, 2, 1))
+>someFunc : Symbol(someFunc, Decl(exportDefaultNamespace.ts, 0, 0), Decl(exportDefaultNamespace.ts, 2, 1))
+>someProp : Symbol(someFunc.someProp, Decl(exportDefaultNamespace.ts, 2, 1))
+
diff --git a/tests/baselines/reference/exportDefaultNamespace.types b/tests/baselines/reference/exportDefaultNamespace.types
@@ -0,0 +1,15 @@
+=== tests/cases/conformance/declarationEmit/exportDefaultNamespace.ts ===
+export default function someFunc() {
+>someFunc : typeof someFunc
+
+    return 'hello!';
+>'hello!' : "hello!"
+}
+
+someFunc.someProp = 'yo';
+>someFunc.someProp = 'yo' : "yo"
+>someFunc.someProp : string
+>someFunc : typeof someFunc
+>someProp : string
+>'yo' : "yo"
+
diff --git a/tests/baselines/reference/restTypeRetainsMappyness.errors.txt b/tests/baselines/reference/restTypeRetainsMappyness.errors.txt
@@ -0,0 +1,15 @@
+tests/cases/compiler/restTypeRetainsMappyness.ts(7,8): error TS2345: Argument of type 'Foo<T>[number][]' is not assignable to parameter of type 'Foo<T>'.
+
+
+==== tests/cases/compiler/restTypeRetainsMappyness.ts (1 errors) ====
+    type Foo<T extends any[]> = {
+        [P in keyof T]: T[P]
+    }
+    
+    function test<T extends any[]>(fn: (...args: Foo<T>) => void) {
+        const arr: Foo<T> = {} as any
+        fn(...arr) // Error: Argument of type 'any[]' is not assignable to parameter of type 'Foo<T>'
+           ~~~~~~
+!!! error TS2345: Argument of type 'Foo<T>[number][]' is not assignable to parameter of type 'Foo<T>'.
+    }
+    
diff --git a/tests/baselines/reference/restTypeRetainsMappyness.js b/tests/baselines/reference/restTypeRetainsMappyness.js
@@ -0,0 +1,16 @@
+//// [restTypeRetainsMappyness.ts]
+type Foo<T extends any[]> = {
+    [P in keyof T]: T[P]
+}
+
+function test<T extends any[]>(fn: (...args: Foo<T>) => void) {
+    const arr: Foo<T> = {} as any
+    fn(...arr) // Error: Argument of type 'any[]' is not assignable to parameter of type 'Foo<T>'
+}
+
+
+//// [restTypeRetainsMappyness.js]
+function test(fn) {
+    var arr = {};
+    fn.apply(void 0, arr); // Error: Argument of type 'any[]' is not assignable to parameter of type 'Foo<T>'
+}
diff --git a/tests/baselines/reference/restTypeRetainsMappyness.symbols b/tests/baselines/reference/restTypeRetainsMappyness.symbols
@@ -0,0 +1,30 @@
+=== tests/cases/compiler/restTypeRetainsMappyness.ts ===
+type Foo<T extends any[]> = {
+>Foo : Symbol(Foo, Decl(restTypeRetainsMappyness.ts, 0, 0))
+>T : Symbol(T, Decl(restTypeRetainsMappyness.ts, 0, 9))
+
+    [P in keyof T]: T[P]
+>P : Symbol(P, Decl(restTypeRetainsMappyness.ts, 1, 5))
+>T : Symbol(T, Decl(restTypeRetainsMappyness.ts, 0, 9))
+>T : Symbol(T, Decl(restTypeRetainsMappyness.ts, 0, 9))
+>P : Symbol(P, Decl(restTypeRetainsMappyness.ts, 1, 5))
+}
+
+function test<T extends any[]>(fn: (...args: Foo<T>) => void) {
+>test : Symbol(test, Decl(restTypeRetainsMappyness.ts, 2, 1))
+>T : Symbol(T, Decl(restTypeRetainsMappyness.ts, 4, 14))
+>fn : Symbol(fn, Decl(restTypeRetainsMappyness.ts, 4, 31))
+>args : Symbol(args, Decl(restTypeRetainsMappyness.ts, 4, 36))
+>Foo : Symbol(Foo, Decl(restTypeRetainsMappyness.ts, 0, 0))
+>T : Symbol(T, Decl(restTypeRetainsMappyness.ts, 4, 14))
+
+    const arr: Foo<T> = {} as any
+>arr : Symbol(arr, Decl(restTypeRetainsMappyness.ts, 5, 9))
+>Foo : Symbol(Foo, Decl(restTypeRetainsMappyness.ts, 0, 0))
+>T : Symbol(T, Decl(restTypeRetainsMappyness.ts, 4, 14))
+
+    fn(...arr) // Error: Argument of type 'any[]' is not assignable to parameter of type 'Foo<T>'
+>fn : Symbol(fn, Decl(restTypeRetainsMappyness.ts, 4, 31))
+>arr : Symbol(arr, Decl(restTypeRetainsMappyness.ts, 5, 9))
+}
+
diff --git a/tests/baselines/reference/restTypeRetainsMappyness.types b/tests/baselines/reference/restTypeRetainsMappyness.types
@@ -0,0 +1,24 @@
+=== tests/cases/compiler/restTypeRetainsMappyness.ts ===
+type Foo<T extends any[]> = {
+>Foo : Foo<T>
+
+    [P in keyof T]: T[P]
+}
+
+function test<T extends any[]>(fn: (...args: Foo<T>) => void) {
+>test : <T extends any[]>(fn: (...args: Foo<T>) => void) => void
+>fn : (...args: Foo<T>) => void
+>args : Foo<T>
+
+    const arr: Foo<T> = {} as any
+>arr : Foo<T>
+>{} as any : any
+>{} : {}
+
+    fn(...arr) // Error: Argument of type 'any[]' is not assignable to parameter of type 'Foo<T>'
+>fn(...arr) : void
+>fn : (...args: Foo<T>) => void
+>...arr : any
+>arr : Foo<T>
+}
+
diff --git a/tests/baselines/reference/showConfig/Shows tsconfig for single option/allowUmdGlobalAccess/tsconfig.json b/tests/baselines/reference/showConfig/Shows tsconfig for single option/allowUmdGlobalAccess/tsconfig.json
@@ -0,0 +1,5 @@
+{
+    "compilerOptions": {
+        "allowUmdGlobalAccess": true
+    }
+}
diff --git a/tests/baselines/reference/tsConfig/Default initialized TSConfig/tsconfig.json b/tests/baselines/reference/tsConfig/Default initialized TSConfig/tsconfig.json
@@ -48,6 +48,7 @@
     // "allowSyntheticDefaultImports": true,  /* Allow default imports from modules with no default export. This does not affect code emit, just typechecking. */
     "esModuleInterop": true                   /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */
     // "preserveSymlinks": true,              /* Do not resolve the real path of symlinks. */
+    // "allowUmdGlobalAccess": true,          /* Allow accessing UMD globals from modules. */
 
     /* Source Map Options */
     // "sourceRoot": "",                      /* Specify the location where debugger should locate TypeScript files instead of source locations. */
diff --git a/tests/baselines/reference/tsConfig/Initialized TSConfig with advanced options/tsconfig.json b/tests/baselines/reference/tsConfig/Initialized TSConfig with advanced options/tsconfig.json
@@ -48,6 +48,7 @@
     // "allowSyntheticDefaultImports": true,  /* Allow default imports from modules with no default export. This does not affect code emit, just typechecking. */
     "esModuleInterop": true,                  /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */
     // "preserveSymlinks": true,              /* Do not resolve the real path of symlinks. */
+    // "allowUmdGlobalAccess": true,          /* Allow accessing UMD globals from modules. */
 
     /* Source Map Options */
     // "sourceRoot": "",                      /* Specify the location where debugger should locate TypeScript files instead of source locations. */
diff --git a/tests/baselines/reference/tsConfig/Initialized TSConfig with boolean value compiler options/tsconfig.json b/tests/baselines/reference/tsConfig/Initialized TSConfig with boolean value compiler options/tsconfig.json
@@ -48,6 +48,7 @@
     // "allowSyntheticDefaultImports": true,  /* Allow default imports from modules with no default export. This does not affect code emit, just typechecking. */
     "esModuleInterop": true                   /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */
     // "preserveSymlinks": true,              /* Do not resolve the real path of symlinks. */
+    // "allowUmdGlobalAccess": true,          /* Allow accessing UMD globals from modules. */
 
     /* Source Map Options */
     // "sourceRoot": "",                      /* Specify the location where debugger should locate TypeScript files instead of source locations. */
diff --git a/tests/baselines/reference/tsConfig/Initialized TSConfig with enum value compiler options/tsconfig.json b/tests/baselines/reference/tsConfig/Initialized TSConfig with enum value compiler options/tsconfig.json
@@ -48,6 +48,7 @@
     // "allowSyntheticDefaultImports": true,  /* Allow default imports from modules with no default export. This does not affect code emit, just typechecking. */
     "esModuleInterop": true                   /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */
     // "preserveSymlinks": true,              /* Do not resolve the real path of symlinks. */
+    // "allowUmdGlobalAccess": true,          /* Allow accessing UMD globals from modules. */
 
     /* Source Map Options */
     // "sourceRoot": "",                      /* Specify the location where debugger should locate TypeScript files instead of source locations. */
diff --git a/tests/baselines/reference/tsConfig/Initialized TSConfig with files options/tsconfig.json b/tests/baselines/reference/tsConfig/Initialized TSConfig with files options/tsconfig.json
@@ -48,6 +48,7 @@
     // "allowSyntheticDefaultImports": true,  /* Allow default imports from modules with no default export. This does not affect code emit, just typechecking. */
     "esModuleInterop": true                   /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */
     // "preserveSymlinks": true,              /* Do not resolve the real path of symlinks. */
+    // "allowUmdGlobalAccess": true,          /* Allow accessing UMD globals from modules. */
 
     /* Source Map Options */
     // "sourceRoot": "",                      /* Specify the location where debugger should locate TypeScript files instead of source locations. */
diff --git a/tests/baselines/reference/tsConfig/Initialized TSConfig with incorrect compiler option value/tsconfig.json b/tests/baselines/reference/tsConfig/Initialized TSConfig with incorrect compiler option value/tsconfig.json
@@ -48,6 +48,7 @@
     // "allowSyntheticDefaultImports": true,  /* Allow default imports from modules with no default export. This does not affect code emit, just typechecking. */
     "esModuleInterop": true                   /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */
     // "preserveSymlinks": true,              /* Do not resolve the real path of symlinks. */
+    // "allowUmdGlobalAccess": true,          /* Allow accessing UMD globals from modules. */
 
     /* Source Map Options */
     // "sourceRoot": "",                      /* Specify the location where debugger should locate TypeScript files instead of source locations. */
diff --git a/tests/baselines/reference/tsConfig/Initialized TSConfig with incorrect compiler option/tsconfig.json b/tests/baselines/reference/tsConfig/Initialized TSConfig with incorrect compiler option/tsconfig.json
@@ -48,6 +48,7 @@
     // "allowSyntheticDefaultImports": true,  /* Allow default imports from modules with no default export. This does not affect code emit, just typechecking. */
     "esModuleInterop": true                   /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */
     // "preserveSymlinks": true,              /* Do not resolve the real path of symlinks. */
+    // "allowUmdGlobalAccess": true,          /* Allow accessing UMD globals from modules. */
 
     /* Source Map Options */
     // "sourceRoot": "",                      /* Specify the location where debugger should locate TypeScript files instead of source locations. */
diff --git a/tests/baselines/reference/tsConfig/Initialized TSConfig with list compiler options with enum value/tsconfig.json b/tests/baselines/reference/tsConfig/Initialized TSConfig with list compiler options with enum value/tsconfig.json
@@ -48,6 +48,7 @@
     // "allowSyntheticDefaultImports": true,  /* Allow default imports from modules with no default export. This does not affect code emit, just typechecking. */
     "esModuleInterop": true                   /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */
     // "preserveSymlinks": true,              /* Do not resolve the real path of symlinks. */
+    // "allowUmdGlobalAccess": true,          /* Allow accessing UMD globals from modules. */
 
     /* Source Map Options */
     // "sourceRoot": "",                      /* Specify the location where debugger should locate TypeScript files instead of source locations. */
diff --git a/tests/baselines/reference/tsConfig/Initialized TSConfig with list compiler options/tsconfig.json b/tests/baselines/reference/tsConfig/Initialized TSConfig with list compiler options/tsconfig.json
@@ -48,6 +48,7 @@
     // "allowSyntheticDefaultImports": true,  /* Allow default imports from modules with no default export. This does not affect code emit, just typechecking. */
     "esModuleInterop": true                   /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */
     // "preserveSymlinks": true,              /* Do not resolve the real path of symlinks. */
+    // "allowUmdGlobalAccess": true,          /* Allow accessing UMD globals from modules. */
 
     /* Source Map Options */
     // "sourceRoot": "",                      /* Specify the location where debugger should locate TypeScript files instead of source locations. */
diff --git a/tests/baselines/reference/umd9.js b/tests/baselines/reference/umd9.js
@@ -0,0 +1,19 @@
+//// [tests/cases/conformance/externalModules/umd9.ts] ////
+
+//// [foo.d.ts]
+declare class Thing {
+  foo(): number;
+}
+export = Thing;
+export as namespace Foo;
+
+//// [a.ts]
+/// <reference path="foo.d.ts" />
+export const x = Foo; // OK in value position because allowUmdGlobalAccess: true
+
+
+//// [a.js]
+"use strict";
+exports.__esModule = true;
+/// <reference path="foo.d.ts" />
+exports.x = Foo; // OK in value position because allowUmdGlobalAccess: true
diff --git a/tests/baselines/reference/umd9.symbols b/tests/baselines/reference/umd9.symbols
@@ -0,0 +1,19 @@
+=== tests/cases/conformance/externalModules/a.ts ===
+/// <reference path="foo.d.ts" />
+export const x = Foo; // OK in value position because allowUmdGlobalAccess: true
+>x : Symbol(x, Decl(a.ts, 1, 12))
+>Foo : Symbol(Foo, Decl(foo.d.ts, 3, 15))
+
+=== tests/cases/conformance/externalModules/foo.d.ts ===
+declare class Thing {
+>Thing : Symbol(Thing, Decl(foo.d.ts, 0, 0))
+
+  foo(): number;
+>foo : Symbol(Thing.foo, Decl(foo.d.ts, 0, 21))
+}
+export = Thing;
+>Thing : Symbol(Thing, Decl(foo.d.ts, 0, 0))
+
+export as namespace Foo;
+>Foo : Symbol(Foo, Decl(foo.d.ts, 3, 15))
+
diff --git a/tests/baselines/reference/umd9.types b/tests/baselines/reference/umd9.types
diff --git a/tests/cases/compiler/restTypeRetainsMappyness.ts b/tests/cases/compiler/restTypeRetainsMappyness.ts
diff --git a/tests/cases/conformance/declarationEmit/exportDefaultNamespace.ts b/tests/cases/conformance/declarationEmit/exportDefaultNamespace.ts
diff --git a/tests/cases/conformance/externalModules/umd9.ts b/tests/cases/conformance/externalModules/umd9.ts

Original file line number	Diff line number	Diff line change
`@@ -1648,7 +1648,7 @@ namespace ts {`
`1648`	`1648`	`if (result && isInExternalModule && (meaning & SymbolFlags.Value) === SymbolFlags.Value && !(originalLocation!.flags & NodeFlags.JSDoc)) {`
`1649`	`1649`	`const merged = getMergedSymbol(result);`
`1650`	`1650`	`if (length(merged.declarations) && every(merged.declarations, d => isNamespaceExportDeclaration(d) \|\| isSourceFile(d) && !!d.symbol.globalExports)) {`
`1651`		`- error(errorLocation!, Diagnostics._0_refers_to_a_UMD_global_but_the_current_file_is_a_module_Consider_adding_an_import_instead, unescapeLeadingUnderscores(name)); // TODO: GH#18217`
	`1651`	`+ errorOrSuggestion(!compilerOptions.allowUmdGlobalAccess, errorLocation!, Diagnostics._0_refers_to_a_UMD_global_but_the_current_file_is_a_module_Consider_adding_an_import_instead, unescapeLeadingUnderscores(name));`
`1652`	`1652`	`}`
`1653`	`1653`	`}`
`1654`	`1654`	`}`
`@@ -20443,7 +20443,7 @@ namespace ts {`
`20443`	`20443`
`20444`	`20444`	`function getArrayifiedType(type: Type) {`
`20445`	`20445`	`if (forEachType(type, t => !(t.flags & (TypeFlags.Any \| TypeFlags.Instantiable) \|\| isArrayType(t) \|\| isTupleType(t)))) {`
`20446`		`- return createArrayType(getIndexTypeOfType(type, IndexKind.Number) \|\| errorType);`
	`20446`	`+ return createArrayType(getIndexedAccessType(type, numberType));`
`20447`	`20447`	`}`
`20448`	`20448`	`return type;`
`20449`	`20449`	`}`
Original file line number	Diff line number	Diff line change
`@@ -4946,5 +4946,9 @@`
`4946`	`4946`	`"Convert parameters to destructured object": {`
`4947`	`4947`	`"category": "Message",`
`4948`	`4948`	`"code": 95075`
	`4949`	`+ },`
	`4950`	`+ "Allow accessing UMD globals from modules.": {`
	`4951`	`+ "category": "Message",`
	`4952`	`+ "code": 95076`
`4949`	`4953`	`}`
`4950`	`4954`	`}`