Merge release-2.1 into master

src/compiler/checker.ts

@@ -11493,7 +11493,7 @@ namespace ts {
         function checkJsxOpeningLikeElement(node: JsxOpeningLikeElement) {
             checkGrammarJsxElement(node);
             checkJsxPreconditions(node);
-            // The reactNamespace/jsxFactory's root symbol should be marked as 'used' so we don't incorrectly elide its import. 
+            // The reactNamespace/jsxFactory's root symbol should be marked as 'used' so we don't incorrectly elide its import.
             // And if there is no reactNamespace/jsxFactory's symbol in scope when targeting React emit, we should issue an error.
             const reactRefErr = compilerOptions.jsx === JsxEmit.React ? Diagnostics.Cannot_find_name_0 : undefined;
             const reactNamespace = getJsxNamespace();

src/compiler/program.ts

@@ -476,7 +476,7 @@ namespace ts {
                 return resolveModuleNamesWorker(moduleNames, containingFile);
             }
 
-            // at this point we know that either 
+            // at this point we know that either
             // - file has local declarations for ambient modules
             // OR
             // - old program state is available
@@ -670,7 +670,7 @@ namespace ts {
             }
 
             const modifiedFilePaths = modifiedSourceFiles.map(f => f.newFile.path);
-            // try to verify results of module resolution 
+            // try to verify results of module resolution
             for (const { oldFile: oldSourceFile, newFile: newSourceFile } of modifiedSourceFiles) {
                 const newSourceFilePath = getNormalizedAbsolutePath(newSourceFile.fileName, currentDirectory);
                 if (resolveModuleNamesWorker) {
@@ -1447,7 +1447,9 @@ namespace ts {
             collectExternalModuleReferences(file);
             if (file.imports.length || file.moduleAugmentations.length) {
                 file.resolvedModules = createMap<ResolvedModuleFull>();
-                const moduleNames = map(concatenate(file.imports, file.moduleAugmentations), getTextOfLiteral);
+                // Because global augmentation doesn't have string literal name, we can check for global augmentation as such.
+                const nonGlobalAugmentation = filter(file.moduleAugmentations, (moduleAugmentation) => moduleAugmentation.kind === SyntaxKind.StringLiteral);
+                const moduleNames = map(concatenate(file.imports, nonGlobalAugmentation), getTextOfLiteral);
                 const resolutions = resolveModuleNamesReusingOldState(moduleNames, getNormalizedAbsolutePath(file.fileName, currentDirectory), file);
                 Debug.assert(resolutions.length === moduleNames.length);
                 for (let i = 0; i < moduleNames.length; i++) {

src/compiler/transformers/ts.ts

@@ -471,7 +471,11 @@ namespace ts {
             currentSourceFile = node;
 
             // ensure "use strict" is emitted in all scenarios in alwaysStrict mode
-            if (compilerOptions.alwaysStrict) {
+            // There is no need to emit "use strict" in the following cases:
+            //      1. The file is an external module and target is es2015 or higher
+            //      or 2. The file is an external module and module-kind is es6 or es2015 as such value is not allowed when targeting es5 or lower
+            if (compilerOptions.alwaysStrict &&
+                !(isExternalModule(node) && (compilerOptions.target >= ScriptTarget.ES2015 || compilerOptions.module === ModuleKind.ES2015))) {
                 node = ensureUseStrict(node);
             }
 

src/server/typingsInstaller/typingsInstaller.ts

@@ -69,7 +69,7 @@ namespace ts.server.typingsInstaller {
         requestId: number;
         args: string[];
         cwd: string;
-        onRequestCompleted: RequestCompletedAction
+        onRequestCompleted: RequestCompletedAction;
     };
 
     export abstract class TypingsInstaller {
@@ -380,7 +380,7 @@ namespace ts.server.typingsInstaller {
                 compilerOptions: request.compilerOptions,
                 typings,
                 unresolvedImports: request.unresolvedImports,
-                kind: server.ActionSet
+                kind: ActionSet
             };
         }
 

tests/baselines/reference/alwaysStrictModule3.js

@@ -0,0 +1,8 @@
+//// [alwaysStrictModule3.ts]
+
+// module ES2015
+export const a = 1;
+
+//// [alwaysStrictModule3.js]
+// module ES2015
+export var a = 1;

tests/baselines/reference/alwaysStrictModule3.symbols

@@ -0,0 +1,6 @@
+=== tests/cases/compiler/alwaysStrictModule3.ts ===
+
+// module ES2015
+export const a = 1;
+>a : Symbol(a, Decl(alwaysStrictModule3.ts, 2, 12))
+

tests/baselines/reference/alwaysStrictModule3.types

@@ -0,0 +1,7 @@
+=== tests/cases/compiler/alwaysStrictModule3.ts ===
+
+// module ES2015
+export const a = 1;
+>a : 1
+>1 : 1
+

tests/baselines/reference/alwaysStrictModule4.js

@@ -0,0 +1,9 @@
+//// [alwaysStrictModule4.ts]
+
+// Module commonjs
+export const a = 1
+
+//// [alwaysStrictModule4.js]
+"use strict";
+// Module commonjs
+exports.a = 1;

tests/baselines/reference/alwaysStrictModule4.symbols

@@ -0,0 +1,6 @@
+=== tests/cases/compiler/alwaysStrictModule4.ts ===
+
+// Module commonjs
+export const a = 1
+>a : Symbol(a, Decl(alwaysStrictModule4.ts, 2, 12))
+

tests/baselines/reference/alwaysStrictModule4.types

@@ -0,0 +1,7 @@
+=== tests/cases/compiler/alwaysStrictModule4.ts ===
+
+// Module commonjs
+export const a = 1
+>a : 1
+>1 : 1
+

tests/baselines/reference/alwaysStrictModule5.js

@@ -0,0 +1,8 @@
+//// [alwaysStrictModule5.ts]
+
+// Targeting ES6
+export const a = 1; 
+
+//// [alwaysStrictModule5.js]
+// Targeting ES6
+export const a = 1;

tests/baselines/reference/alwaysStrictModule5.symbols

@@ -0,0 +1,6 @@
+=== tests/cases/compiler/alwaysStrictModule5.ts ===
+
+// Targeting ES6
+export const a = 1; 
+>a : Symbol(a, Decl(alwaysStrictModule5.ts, 2, 12))
+

tests/baselines/reference/alwaysStrictModule5.types

@@ -0,0 +1,7 @@
+=== tests/cases/compiler/alwaysStrictModule5.ts ===
+
+// Targeting ES6
+export const a = 1; 
+>a : 1
+>1 : 1
+

tests/baselines/reference/alwaysStrictModule6.js

@@ -0,0 +1,9 @@
+//// [alwaysStrictModule6.ts]
+
+// Targeting ES5
+export const a = 1; 
+
+//// [alwaysStrictModule6.js]
+"use strict";
+// Targeting ES5
+exports.a = 1;

tests/baselines/reference/alwaysStrictModule6.symbols

@@ -0,0 +1,6 @@
+=== tests/cases/compiler/alwaysStrictModule6.ts ===
+
+// Targeting ES5
+export const a = 1; 
+>a : Symbol(a, Decl(alwaysStrictModule6.ts, 2, 12))
+

tests/baselines/reference/alwaysStrictModule6.types

@@ -0,0 +1,7 @@
+=== tests/cases/compiler/alwaysStrictModule6.ts ===
+
+// Targeting ES5
+export const a = 1; 
+>a : 1
+>1 : 1
+

tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters2.js

@@ -0,0 +1,17 @@
+//// [declarationEmitTypeAliasWithTypeParameters2.ts]
+
+export type Bar<X, Y, Z> = () => [X, Y, Z];
+export type Baz<M, N> = Bar<M, string, N>;
+export type Baa<Y> = Baz<boolean, Y>;
+export const y = (x: Baa<number>) => 1
+
+//// [declarationEmitTypeAliasWithTypeParameters2.js]
+"use strict";
+exports.y = function (x) { return 1; };
+
+
+//// [declarationEmitTypeAliasWithTypeParameters2.d.ts]
+export declare type Bar<X, Y, Z> = () => [X, Y, Z];
+export declare type Baz<M, N> = Bar<M, string, N>;
+export declare type Baa<Y> = Baz<boolean, Y>;
+export declare const y: (x: Bar<boolean, string, number>) => number;

tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters2.symbols

@@ -0,0 +1,30 @@
+=== tests/cases/compiler/declarationEmitTypeAliasWithTypeParameters2.ts ===
+
+export type Bar<X, Y, Z> = () => [X, Y, Z];
+>Bar : Symbol(Bar, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 0, 0))
+>X : Symbol(X, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 1, 16))
+>Y : Symbol(Y, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 1, 18))
+>Z : Symbol(Z, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 1, 21))
+>X : Symbol(X, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 1, 16))
+>Y : Symbol(Y, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 1, 18))
+>Z : Symbol(Z, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 1, 21))
+
+export type Baz<M, N> = Bar<M, string, N>;
+>Baz : Symbol(Baz, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 1, 43))
+>M : Symbol(M, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 2, 16))
+>N : Symbol(N, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 2, 18))
+>Bar : Symbol(Bar, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 0, 0))
+>M : Symbol(M, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 2, 16))
+>N : Symbol(N, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 2, 18))
+
+export type Baa<Y> = Baz<boolean, Y>;
+>Baa : Symbol(Baa, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 2, 42))
+>Y : Symbol(Y, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 3, 16))
+>Baz : Symbol(Baz, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 1, 43))
+>Y : Symbol(Y, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 3, 16))
+
+export const y = (x: Baa<number>) => 1
+>y : Symbol(y, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 4, 12))
+>x : Symbol(x, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 4, 18))
+>Baa : Symbol(Baa, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 2, 42))
+

tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters2.types

@@ -0,0 +1,32 @@
+=== tests/cases/compiler/declarationEmitTypeAliasWithTypeParameters2.ts ===
+
+export type Bar<X, Y, Z> = () => [X, Y, Z];
+>Bar : Bar<X, Y, Z>
+>X : X
+>Y : Y
+>Z : Z
+>X : X
+>Y : Y
+>Z : Z
+
+export type Baz<M, N> = Bar<M, string, N>;
+>Baz : Bar<M, string, N>
+>M : M
+>N : N
+>Bar : Bar<X, Y, Z>
+>M : M
+>N : N
+
+export type Baa<Y> = Baz<boolean, Y>;
+>Baa : Bar<boolean, string, Y>
+>Y : Y
+>Baz : Bar<M, string, N>
+>Y : Y
+
+export const y = (x: Baa<number>) => 1
+>y : (x: Bar<boolean, string, number>) => number
+>(x: Baa<number>) => 1 : (x: Bar<boolean, string, number>) => number
+>x : Bar<boolean, string, number>
+>Baa : Bar<boolean, string, Y>
+>1 : 1
+

tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters3.js

@@ -0,0 +1,21 @@
+//// [declarationEmitTypeAliasWithTypeParameters3.ts]
+
+type Foo<T> = {
+    foo<U>(): Foo<U>
+};
+function bar() {
+    return {} as Foo<number>;
+}
+
+
+//// [declarationEmitTypeAliasWithTypeParameters3.js]
+function bar() {
+    return {};
+}
+
+
+//// [declarationEmitTypeAliasWithTypeParameters3.d.ts]
+declare type Foo<T> = {
+    foo<U>(): Foo<U>;
+};
+declare function bar(): Foo<number>;

tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters3.symbols

@@ -0,0 +1,20 @@
+=== tests/cases/compiler/declarationEmitTypeAliasWithTypeParameters3.ts ===
+
+type Foo<T> = {
+>Foo : Symbol(Foo, Decl(declarationEmitTypeAliasWithTypeParameters3.ts, 0, 0))
+>T : Symbol(T, Decl(declarationEmitTypeAliasWithTypeParameters3.ts, 1, 9))
+
+    foo<U>(): Foo<U>
+>foo : Symbol(foo, Decl(declarationEmitTypeAliasWithTypeParameters3.ts, 1, 15))
+>U : Symbol(U, Decl(declarationEmitTypeAliasWithTypeParameters3.ts, 2, 8))
+>Foo : Symbol(Foo, Decl(declarationEmitTypeAliasWithTypeParameters3.ts, 0, 0))
+>U : Symbol(U, Decl(declarationEmitTypeAliasWithTypeParameters3.ts, 2, 8))
+
+};
+function bar() {
+>bar : Symbol(bar, Decl(declarationEmitTypeAliasWithTypeParameters3.ts, 3, 2))
+
+    return {} as Foo<number>;
+>Foo : Symbol(Foo, Decl(declarationEmitTypeAliasWithTypeParameters3.ts, 0, 0))
+}
+

tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters3.types

@@ -0,0 +1,22 @@
+=== tests/cases/compiler/declarationEmitTypeAliasWithTypeParameters3.ts ===
+
+type Foo<T> = {
+>Foo : Foo<T>
+>T : T
+
+    foo<U>(): Foo<U>
+>foo : <U>() => Foo<U>
+>U : U
+>Foo : Foo<T>
+>U : U
+
+};
+function bar() {
+>bar : () => Foo<number>
+
+    return {} as Foo<number>;
+>{} as Foo<number> : Foo<number>
+>{} : {}
+>Foo : Foo<T>
+}
+

tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters4.js

@@ -0,0 +1,24 @@
+//// [declarationEmitTypeAliasWithTypeParameters4.ts]
+
+type Foo<T, Y> = {
+    foo<U, J>(): Foo<U, J>
+};
+type SubFoo<R> = Foo<string, R>;
+
+function foo() {
+    return {} as SubFoo<number>;
+}
+
+
+//// [declarationEmitTypeAliasWithTypeParameters4.js]
+function foo() {
+    return {};
+}
+
+
+//// [declarationEmitTypeAliasWithTypeParameters4.d.ts]
+declare type Foo<T, Y> = {
+    foo<U, J>(): Foo<U, J>;
+};
+declare type SubFoo<R> = Foo<string, R>;
+declare function foo(): Foo<string, number>;

tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters4.symbols

@@ -0,0 +1,29 @@
+=== tests/cases/compiler/declarationEmitTypeAliasWithTypeParameters4.ts ===
+
+type Foo<T, Y> = {
+>Foo : Symbol(Foo, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 0, 0))
+>T : Symbol(T, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 1, 9))
+>Y : Symbol(Y, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 1, 11))
+
+    foo<U, J>(): Foo<U, J>
+>foo : Symbol(foo, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 1, 18))
+>U : Symbol(U, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 2, 8))
+>J : Symbol(J, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 2, 10))
+>Foo : Symbol(Foo, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 0, 0))
+>U : Symbol(U, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 2, 8))
+>J : Symbol(J, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 2, 10))
+
+};
+type SubFoo<R> = Foo<string, R>;
+>SubFoo : Symbol(SubFoo, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 3, 2))
+>R : Symbol(R, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 4, 12))
+>Foo : Symbol(Foo, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 0, 0))
+>R : Symbol(R, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 4, 12))
+
+function foo() {
+>foo : Symbol(foo, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 4, 32))
+
+    return {} as SubFoo<number>;
+>SubFoo : Symbol(SubFoo, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 3, 2))
+}
+