diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 1510979305beb..7bd8dfae88b61 100644
--- a/src/compiler/checker.ts
+++ b/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();
diff --git a/src/compiler/program.ts b/src/compiler/program.ts
index eb7054a9f06e9..5d275afb78f1a 100644
--- a/src/compiler/program.ts
+++ b/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++) {
diff --git a/src/compiler/transformers/ts.ts b/src/compiler/transformers/ts.ts
index 1362746ba57a8..89fa039100a7e 100644
--- a/src/compiler/transformers/ts.ts
+++ b/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);
             }
 
diff --git a/src/server/typingsInstaller/typingsInstaller.ts b/src/server/typingsInstaller/typingsInstaller.ts
index da97dbcd194df..0873d5c328b2a 100644
--- a/src/server/typingsInstaller/typingsInstaller.ts
+++ b/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
             };
         }
 
diff --git a/tests/baselines/reference/alwaysStrictModule3.js b/tests/baselines/reference/alwaysStrictModule3.js
new file mode 100644
index 0000000000000..894bad25143d9
--- /dev/null
+++ b/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;
diff --git a/tests/baselines/reference/alwaysStrictModule3.symbols b/tests/baselines/reference/alwaysStrictModule3.symbols
new file mode 100644
index 0000000000000..6f053673f0e40
--- /dev/null
+++ b/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))
+
diff --git a/tests/baselines/reference/alwaysStrictModule3.types b/tests/baselines/reference/alwaysStrictModule3.types
new file mode 100644
index 0000000000000..75b11206a4f7a
--- /dev/null
+++ b/tests/baselines/reference/alwaysStrictModule3.types
@@ -0,0 +1,7 @@
+=== tests/cases/compiler/alwaysStrictModule3.ts ===
+
+// module ES2015
+export const a = 1;
+>a : 1
+>1 : 1
+
diff --git a/tests/baselines/reference/alwaysStrictModule4.js b/tests/baselines/reference/alwaysStrictModule4.js
new file mode 100644
index 0000000000000..1444f351bbd43
--- /dev/null
+++ b/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;
diff --git a/tests/baselines/reference/alwaysStrictModule4.symbols b/tests/baselines/reference/alwaysStrictModule4.symbols
new file mode 100644
index 0000000000000..4b8a968ae165d
--- /dev/null
+++ b/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))
+
diff --git a/tests/baselines/reference/alwaysStrictModule4.types b/tests/baselines/reference/alwaysStrictModule4.types
new file mode 100644
index 0000000000000..fff87967605c9
--- /dev/null
+++ b/tests/baselines/reference/alwaysStrictModule4.types
@@ -0,0 +1,7 @@
+=== tests/cases/compiler/alwaysStrictModule4.ts ===
+
+// Module commonjs
+export const a = 1
+>a : 1
+>1 : 1
+
diff --git a/tests/baselines/reference/alwaysStrictModule5.js b/tests/baselines/reference/alwaysStrictModule5.js
new file mode 100644
index 0000000000000..74b9d72263c4c
--- /dev/null
+++ b/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;
diff --git a/tests/baselines/reference/alwaysStrictModule5.symbols b/tests/baselines/reference/alwaysStrictModule5.symbols
new file mode 100644
index 0000000000000..903bf3c5c9893
--- /dev/null
+++ b/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))
+
diff --git a/tests/baselines/reference/alwaysStrictModule5.types b/tests/baselines/reference/alwaysStrictModule5.types
new file mode 100644
index 0000000000000..2bfa329ad7e8d
--- /dev/null
+++ b/tests/baselines/reference/alwaysStrictModule5.types
@@ -0,0 +1,7 @@
+=== tests/cases/compiler/alwaysStrictModule5.ts ===
+
+// Targeting ES6
+export const a = 1; 
+>a : 1
+>1 : 1
+
diff --git a/tests/baselines/reference/alwaysStrictModule6.js b/tests/baselines/reference/alwaysStrictModule6.js
new file mode 100644
index 0000000000000..9a60392616977
--- /dev/null
+++ b/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;
diff --git a/tests/baselines/reference/alwaysStrictModule6.symbols b/tests/baselines/reference/alwaysStrictModule6.symbols
new file mode 100644
index 0000000000000..59a70f3e5b5fe
--- /dev/null
+++ b/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))
+
diff --git a/tests/baselines/reference/alwaysStrictModule6.types b/tests/baselines/reference/alwaysStrictModule6.types
new file mode 100644
index 0000000000000..0970380911eb3
--- /dev/null
+++ b/tests/baselines/reference/alwaysStrictModule6.types
@@ -0,0 +1,7 @@
+=== tests/cases/compiler/alwaysStrictModule6.ts ===
+
+// Targeting ES5
+export const a = 1; 
+>a : 1
+>1 : 1
+
diff --git a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters2.js b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters2.js
new file mode 100644
index 0000000000000..d5bf31bd755aa
--- /dev/null
+++ b/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;
diff --git a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters2.symbols b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters2.symbols
new file mode 100644
index 0000000000000..cc13e9fd30b24
--- /dev/null
+++ b/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))
+
diff --git a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters2.types b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters2.types
new file mode 100644
index 0000000000000..74becc4976558
--- /dev/null
+++ b/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
+
diff --git a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters3.js b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters3.js
new file mode 100644
index 0000000000000..9e2a366a685b4
--- /dev/null
+++ b/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>;
diff --git a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters3.symbols b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters3.symbols
new file mode 100644
index 0000000000000..a18b1372cf14d
--- /dev/null
+++ b/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))
+}
+
diff --git a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters3.types b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters3.types
new file mode 100644
index 0000000000000..1b2ff140178c6
--- /dev/null
+++ b/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>
+}
+
diff --git a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters4.js b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters4.js
new file mode 100644
index 0000000000000..26908d915e062
--- /dev/null
+++ b/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>;
diff --git a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters4.symbols b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters4.symbols
new file mode 100644
index 0000000000000..de73f544645c2
--- /dev/null
+++ b/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))
+}
+
diff --git a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters4.types b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters4.types
new file mode 100644
index 0000000000000..c545ac6bb0505
--- /dev/null
+++ b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters4.types
@@ -0,0 +1,31 @@
+=== tests/cases/compiler/declarationEmitTypeAliasWithTypeParameters4.ts ===
+
+type Foo<T, Y> = {
+>Foo : Foo<T, Y>
+>T : T
+>Y : Y
+
+    foo<U, J>(): Foo<U, J>
+>foo : <U, J>() => Foo<U, J>
+>U : U
+>J : J
+>Foo : Foo<T, Y>
+>U : U
+>J : J
+
+};
+type SubFoo<R> = Foo<string, R>;
+>SubFoo : Foo<string, R>
+>R : R
+>Foo : Foo<T, Y>
+>R : R
+
+function foo() {
+>foo : () => Foo<string, number>
+
+    return {} as SubFoo<number>;
+>{} as SubFoo<number> : Foo<string, number>
+>{} : {}
+>SubFoo : Foo<string, R>
+}
+
diff --git a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters5.errors.txt b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters5.errors.txt
new file mode 100644
index 0000000000000..7f683dcc7b7b5
--- /dev/null
+++ b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters5.errors.txt
@@ -0,0 +1,16 @@
+tests/cases/compiler/declarationEmitTypeAliasWithTypeParameters5.ts(5,25): error TS4081: Exported type alias 'SubFoo' has or is using private name 'Foo'.
+
+
+==== tests/cases/compiler/declarationEmitTypeAliasWithTypeParameters5.ts (1 errors) ====
+    
+    type Foo<T, Y> = {
+        foo<U, J>(): Foo<U, J>
+    };
+    export type SubFoo<R> = Foo<string, R>;
+                            ~~~
+!!! error TS4081: Exported type alias 'SubFoo' has or is using private name 'Foo'.
+    
+    function foo() {
+        return {} as SubFoo<number>;
+    }
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters5.js b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters5.js
new file mode 100644
index 0000000000000..2f4fff7d72c25
--- /dev/null
+++ b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters5.js
@@ -0,0 +1,17 @@
+//// [declarationEmitTypeAliasWithTypeParameters5.ts]
+
+type Foo<T, Y> = {
+    foo<U, J>(): Foo<U, J>
+};
+export type SubFoo<R> = Foo<string, R>;
+
+function foo() {
+    return {} as SubFoo<number>;
+}
+
+
+//// [declarationEmitTypeAliasWithTypeParameters5.js]
+"use strict";
+function foo() {
+    return {};
+}
diff --git a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters6.js b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters6.js
new file mode 100644
index 0000000000000..c8001446e3e8c
--- /dev/null
+++ b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters6.js
@@ -0,0 +1,24 @@
+//// [declarationEmitTypeAliasWithTypeParameters6.ts]
+
+type Foo<T, Y> = {
+    foo<U, J>(): Foo<U, J>
+};
+type SubFoo<R, S> = Foo<S, R>;
+
+function foo() {
+    return {} as SubFoo<number, string>;
+}
+
+
+//// [declarationEmitTypeAliasWithTypeParameters6.js]
+function foo() {
+    return {};
+}
+
+
+//// [declarationEmitTypeAliasWithTypeParameters6.d.ts]
+declare type Foo<T, Y> = {
+    foo<U, J>(): Foo<U, J>;
+};
+declare type SubFoo<R, S> = Foo<S, R>;
+declare function foo(): Foo<string, number>;
diff --git a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters6.symbols b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters6.symbols
new file mode 100644
index 0000000000000..ec29989f0781e
--- /dev/null
+++ b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters6.symbols
@@ -0,0 +1,31 @@
+=== tests/cases/compiler/declarationEmitTypeAliasWithTypeParameters6.ts ===
+
+type Foo<T, Y> = {
+>Foo : Symbol(Foo, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 0, 0))
+>T : Symbol(T, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 1, 9))
+>Y : Symbol(Y, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 1, 11))
+
+    foo<U, J>(): Foo<U, J>
+>foo : Symbol(foo, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 1, 18))
+>U : Symbol(U, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 2, 8))
+>J : Symbol(J, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 2, 10))
+>Foo : Symbol(Foo, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 0, 0))
+>U : Symbol(U, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 2, 8))
+>J : Symbol(J, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 2, 10))
+
+};
+type SubFoo<R, S> = Foo<S, R>;
+>SubFoo : Symbol(SubFoo, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 3, 2))
+>R : Symbol(R, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 4, 12))
+>S : Symbol(S, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 4, 14))
+>Foo : Symbol(Foo, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 0, 0))
+>S : Symbol(S, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 4, 14))
+>R : Symbol(R, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 4, 12))
+
+function foo() {
+>foo : Symbol(foo, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 4, 30))
+
+    return {} as SubFoo<number, string>;
+>SubFoo : Symbol(SubFoo, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 3, 2))
+}
+
diff --git a/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters6.types b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters6.types
new file mode 100644
index 0000000000000..b02ccbc2be7bc
--- /dev/null
+++ b/tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters6.types
@@ -0,0 +1,33 @@
+=== tests/cases/compiler/declarationEmitTypeAliasWithTypeParameters6.ts ===
+
+type Foo<T, Y> = {
+>Foo : Foo<T, Y>
+>T : T
+>Y : Y
+
+    foo<U, J>(): Foo<U, J>
+>foo : <U, J>() => Foo<U, J>
+>U : U
+>J : J
+>Foo : Foo<T, Y>
+>U : U
+>J : J
+
+};
+type SubFoo<R, S> = Foo<S, R>;
+>SubFoo : Foo<S, R>
+>R : R
+>S : S
+>Foo : Foo<T, Y>
+>S : S
+>R : R
+
+function foo() {
+>foo : () => Foo<string, number>
+
+    return {} as SubFoo<number, string>;
+>{} as SubFoo<number, string> : Foo<string, number>
+>{} : {}
+>SubFoo : Foo<S, R>
+}
+
diff --git a/tests/baselines/reference/globalAugmentationModuleResolution.js b/tests/baselines/reference/globalAugmentationModuleResolution.js
new file mode 100644
index 0000000000000..e1a4ebce8c5de
--- /dev/null
+++ b/tests/baselines/reference/globalAugmentationModuleResolution.js
@@ -0,0 +1,10 @@
+//// [a.ts]
+
+export { };
+
+declare global {
+  var x: number;
+}
+
+//// [a.js]
+"use strict";
diff --git a/tests/baselines/reference/globalAugmentationModuleResolution.symbols b/tests/baselines/reference/globalAugmentationModuleResolution.symbols
new file mode 100644
index 0000000000000..614860d654e97
--- /dev/null
+++ b/tests/baselines/reference/globalAugmentationModuleResolution.symbols
@@ -0,0 +1,10 @@
+=== tests/cases/conformance/externalModules/a.ts ===
+
+export { };
+
+declare global {
+>global : Symbol(global, Decl(a.ts, 1, 11))
+
+  var x: number;
+>x : Symbol(x, Decl(a.ts, 4, 5))
+}
diff --git a/tests/baselines/reference/globalAugmentationModuleResolution.trace.json b/tests/baselines/reference/globalAugmentationModuleResolution.trace.json
new file mode 100644
index 0000000000000..0637a088a01e8
--- /dev/null
+++ b/tests/baselines/reference/globalAugmentationModuleResolution.trace.json
@@ -0,0 +1 @@
+[]
\ No newline at end of file
diff --git a/tests/baselines/reference/globalAugmentationModuleResolution.types b/tests/baselines/reference/globalAugmentationModuleResolution.types
new file mode 100644
index 0000000000000..c057ea2943db4
--- /dev/null
+++ b/tests/baselines/reference/globalAugmentationModuleResolution.types
@@ -0,0 +1,10 @@
+=== tests/cases/conformance/externalModules/a.ts ===
+
+export { };
+
+declare global {
+>global : any
+
+  var x: number;
+>x : number
+}
diff --git a/tests/cases/compiler/alwaysStrictModule3.ts b/tests/cases/compiler/alwaysStrictModule3.ts
new file mode 100644
index 0000000000000..adb93cede3616
--- /dev/null
+++ b/tests/cases/compiler/alwaysStrictModule3.ts
@@ -0,0 +1,5 @@
+// @alwaysStrict: true
+// @module: es2015
+
+// module ES2015
+export const a = 1;
\ No newline at end of file
diff --git a/tests/cases/compiler/alwaysStrictModule4.ts b/tests/cases/compiler/alwaysStrictModule4.ts
new file mode 100644
index 0000000000000..f731e6dd734a0
--- /dev/null
+++ b/tests/cases/compiler/alwaysStrictModule4.ts
@@ -0,0 +1,5 @@
+// @alwaysStrict: true
+// @module: commonjs
+
+// Module commonjs
+export const a = 1
\ No newline at end of file
diff --git a/tests/cases/compiler/alwaysStrictModule5.ts b/tests/cases/compiler/alwaysStrictModule5.ts
new file mode 100644
index 0000000000000..d1ac528837085
--- /dev/null
+++ b/tests/cases/compiler/alwaysStrictModule5.ts
@@ -0,0 +1,5 @@
+// @alwaysStrict: true
+// @target: es6
+
+// Targeting ES6
+export const a = 1; 
\ No newline at end of file
diff --git a/tests/cases/compiler/alwaysStrictModule6.ts b/tests/cases/compiler/alwaysStrictModule6.ts
new file mode 100644
index 0000000000000..064ece1a4e1a9
--- /dev/null
+++ b/tests/cases/compiler/alwaysStrictModule6.ts
@@ -0,0 +1,5 @@
+// @alwaysStrict: true
+// @target: es5
+
+// Targeting ES5
+export const a = 1; 
\ No newline at end of file
diff --git a/tests/cases/compiler/declarationEmitTypeAliasWithTypeParameters2.ts b/tests/cases/compiler/declarationEmitTypeAliasWithTypeParameters2.ts
new file mode 100644
index 0000000000000..de94ad4998d71
--- /dev/null
+++ b/tests/cases/compiler/declarationEmitTypeAliasWithTypeParameters2.ts
@@ -0,0 +1,6 @@
+// @declaration: true
+
+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
\ No newline at end of file
diff --git a/tests/cases/compiler/declarationEmitTypeAliasWithTypeParameters3.ts b/tests/cases/compiler/declarationEmitTypeAliasWithTypeParameters3.ts
new file mode 100644
index 0000000000000..6c7d4799abc39
--- /dev/null
+++ b/tests/cases/compiler/declarationEmitTypeAliasWithTypeParameters3.ts
@@ -0,0 +1,8 @@
+// @declaration: true
+
+type Foo<T> = {
+    foo<U>(): Foo<U>
+};
+function bar() {
+    return {} as Foo<number>;
+}
diff --git a/tests/cases/compiler/declarationEmitTypeAliasWithTypeParameters4.ts b/tests/cases/compiler/declarationEmitTypeAliasWithTypeParameters4.ts
new file mode 100644
index 0000000000000..42bb8097997e4
--- /dev/null
+++ b/tests/cases/compiler/declarationEmitTypeAliasWithTypeParameters4.ts
@@ -0,0 +1,10 @@
+// @declaration: true
+
+type Foo<T, Y> = {
+    foo<U, J>(): Foo<U, J>
+};
+type SubFoo<R> = Foo<string, R>;
+
+function foo() {
+    return {} as SubFoo<number>;
+}
diff --git a/tests/cases/compiler/declarationEmitTypeAliasWithTypeParameters5.ts b/tests/cases/compiler/declarationEmitTypeAliasWithTypeParameters5.ts
new file mode 100644
index 0000000000000..b6334e763374b
--- /dev/null
+++ b/tests/cases/compiler/declarationEmitTypeAliasWithTypeParameters5.ts
@@ -0,0 +1,10 @@
+// @declaration: true
+
+type Foo<T, Y> = {
+    foo<U, J>(): Foo<U, J>
+};
+export type SubFoo<R> = Foo<string, R>;
+
+function foo() {
+    return {} as SubFoo<number>;
+}
diff --git a/tests/cases/compiler/declarationEmitTypeAliasWithTypeParameters6.ts b/tests/cases/compiler/declarationEmitTypeAliasWithTypeParameters6.ts
new file mode 100644
index 0000000000000..9b31302702125
--- /dev/null
+++ b/tests/cases/compiler/declarationEmitTypeAliasWithTypeParameters6.ts
@@ -0,0 +1,10 @@
+// @declaration: true
+
+type Foo<T, Y> = {
+    foo<U, J>(): Foo<U, J>
+};
+type SubFoo<R, S> = Foo<S, R>;
+
+function foo() {
+    return {} as SubFoo<number, string>;
+}
diff --git a/tests/cases/conformance/externalModules/globalAugmentationModuleResolution.ts b/tests/cases/conformance/externalModules/globalAugmentationModuleResolution.ts
new file mode 100644
index 0000000000000..4d87ffcab1398
--- /dev/null
+++ b/tests/cases/conformance/externalModules/globalAugmentationModuleResolution.ts
@@ -0,0 +1,8 @@
+// @traceResolution: true
+
+// @fileName: a.ts
+export { };
+
+declare global {
+  var x: number;
+}
\ No newline at end of file