Merge branch 'slawomir-10758-always-strict'

mhegazy · mhegazy · commit fc641b93be3c · 2016-10-13T16:57:06.000-07:00
diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts
@@ -122,7 +122,8 @@ namespace ts {
 
         // If this file is an external module, then it is automatically in strict-mode according to
         // ES6.  If it is not an external module, then we'll determine if it is in strict mode or
-        // not depending on if we see "use strict" in certain places (or if we hit a class/namespace).
+        // not depending on if we see "use strict" in certain places or if we hit a class/namespace
+        // or if compiler options contain alwaysStrict.
         let inStrictMode: boolean;
 
         let symbolCount = 0;
@@ -140,7 +141,7 @@ namespace ts {
             file = f;
             options = opts;
             languageVersion = getEmitScriptTarget(options);
-            inStrictMode = !!file.externalModuleIndicator;
+            inStrictMode = bindInStrictMode(file, opts);
             classifiableNames = createMap<string>();
             symbolCount = 0;
             skipTransformFlagAggregation = isDeclarationFile(file);
@@ -175,6 +176,16 @@ namespace ts {
 
         return bindSourceFile;
 
+        function bindInStrictMode(file: SourceFile, opts: CompilerOptions): boolean {
+            if (opts.alwaysStrict && !isDeclarationFile(file)) {
+                // bind in strict mode source files with alwaysStrict option
+                return true;
+            }
+            else {
+                return !!file.externalModuleIndicator;
+            }
+        }
+
         function createSymbol(flags: SymbolFlags, name: string): Symbol {
             symbolCount++;
             return new Symbol(flags, name);
diff --git a/src/compiler/commandLineParser.ts b/src/compiler/commandLineParser.ts
@@ -444,6 +444,11 @@ namespace ts {
             name: "importHelpers",
             type: "boolean",
             description: Diagnostics.Import_emit_helpers_from_tslib
+        },
+        {
+            name: "alwaysStrict",
+            type: "boolean",
+            description: Diagnostics.Parse_in_strict_mode_and_emit_use_strict_for_each_source_file
         }
     ];
 
diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json
@@ -2861,6 +2861,10 @@
         "category": "Error",
         "code": 6140
     },
+    "Parse in strict mode and emit \"use strict\" for each source file": {
+        "category": "Message",
+        "code": 6141
+    },
     "Variable '{0}' implicitly has an '{1}' type.": {
         "category": "Error",
         "code": 7005
diff --git a/src/compiler/factory.ts b/src/compiler/factory.ts
@@ -2235,6 +2235,33 @@ namespace ts {
         return statementOffset;
     }
 
+    /**
+     * Ensures "use strict" directive is added
+     * 
+     * @param node source file
+     */
+    export function ensureUseStrict(node: SourceFile): SourceFile {
+        let foundUseStrict = false;
+        for (const statement of node.statements) {
+            if (isPrologueDirective(statement)) {
+                if (isUseStrictPrologue(statement as ExpressionStatement)) {
+                    foundUseStrict = true;
+                    break;
+                }
+            }
+            else {
+                break;
+            }
+        }
+        if (!foundUseStrict) {
+            const statements: Statement[] = [];
+            statements.push(startOnNewLine(createStatement(createLiteral("use strict"))));
+            // add "use strict" as the first statement
+            return updateSourceFileNode(node, statements.concat(node.statements));
+        }
+        return node;
+    }
+
     /**
      * Wraps the operand to a BinaryExpression in parentheses if they are needed to preserve the intended
      * order of operations.
diff --git a/src/compiler/program.ts b/src/compiler/program.ts
@@ -1473,6 +1473,10 @@ namespace ts {
                 programDiagnostics.add(createCompilerDiagnostic(Diagnostics.Option_0_cannot_be_specified_with_option_1, "lib", "noLib"));
             }
 
+            if (options.noImplicitUseStrict && options.alwaysStrict) {
+                programDiagnostics.add(createCompilerDiagnostic(Diagnostics.Option_0_cannot_be_specified_with_option_1, "noImplicitUseStrict", "alwaysStrict"));
+            }
+
             const languageVersion = options.target || ScriptTarget.ES3;
             const outFile = options.outFile || options.out;
 
diff --git a/src/compiler/transformers/ts.ts b/src/compiler/transformers/ts.ts
@@ -436,6 +436,11 @@ namespace ts {
         function visitSourceFile(node: SourceFile) {
             currentSourceFile = node;
 
+            // ensure "use strict" is emitted in all scenarios in alwaysStrict mode
+            if (compilerOptions.alwaysStrict) {
+                node = ensureUseStrict(node);
+            }
+
             // If the source file requires any helpers and is an external module, and
             // the importHelpers compiler option is enabled, emit a synthesized import
             // statement for the helpers library.
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
@@ -2925,6 +2925,7 @@ namespace ts {
         allowSyntheticDefaultImports?: boolean;
         allowUnreachableCode?: boolean;
         allowUnusedLabels?: boolean;
+        alwaysStrict?: boolean;
         baseUrl?: string;
         charset?: string;
         /* @internal */ configFilePath?: string;
diff --git a/src/harness/unittests/transpile.ts b/src/harness/unittests/transpile.ts
@@ -253,6 +253,10 @@ var x = 0;`, {
             options: { compilerOptions: { allowUnusedLabels: true }, fileName: "input.js", reportDiagnostics: true }
         });
 
+        transpilesCorrectly("Supports setting 'alwaysStrict'", "x;", {
+            options: { compilerOptions: { alwaysStrict: true }, fileName: "input.js", reportDiagnostics: true }
+        });
+
         transpilesCorrectly("Supports setting 'baseUrl'", "x;", {
             options: { compilerOptions: { baseUrl: "./folder/baseUrl" }, fileName: "input.js", reportDiagnostics: true }
         });
diff --git a/tests/baselines/reference/alwaysStrict.errors.txt b/tests/baselines/reference/alwaysStrict.errors.txt
@@ -0,0 +1,10 @@
+tests/cases/compiler/alwaysStrict.ts(3,9): error TS1100: Invalid use of 'arguments' in strict mode.
+
+
+==== tests/cases/compiler/alwaysStrict.ts (1 errors) ====
+    
+    function f() {
+        var arguments = [];
+            ~~~~~~~~~
+!!! error TS1100: Invalid use of 'arguments' in strict mode.
+    }
diff --git a/tests/baselines/reference/alwaysStrict.js b/tests/baselines/reference/alwaysStrict.js
@@ -0,0 +1,11 @@
+//// [alwaysStrict.ts]
+
+function f() {
+    var arguments = [];
+}
+
+//// [alwaysStrict.js]
+"use strict";
+function f() {
+    var arguments = [];
+}
diff --git a/tests/baselines/reference/alwaysStrictAlreadyUseStrict.js b/tests/baselines/reference/alwaysStrictAlreadyUseStrict.js
@@ -0,0 +1,11 @@
+//// [alwaysStrictAlreadyUseStrict.ts]
+"use strict"
+function f() {
+    var a = [];
+}
+
+//// [alwaysStrictAlreadyUseStrict.js]
+"use strict";
+function f() {
+    var a = [];
+}
diff --git a/tests/baselines/reference/alwaysStrictAlreadyUseStrict.symbols b/tests/baselines/reference/alwaysStrictAlreadyUseStrict.symbols
@@ -0,0 +1,8 @@
+=== tests/cases/compiler/alwaysStrictAlreadyUseStrict.ts ===
+"use strict"
+function f() {
+>f : Symbol(f, Decl(alwaysStrictAlreadyUseStrict.ts, 0, 12))
+
+    var a = [];
+>a : Symbol(a, Decl(alwaysStrictAlreadyUseStrict.ts, 2, 7))
+}
diff --git a/tests/baselines/reference/alwaysStrictAlreadyUseStrict.types b/tests/baselines/reference/alwaysStrictAlreadyUseStrict.types
@@ -0,0 +1,11 @@
+=== tests/cases/compiler/alwaysStrictAlreadyUseStrict.ts ===
+"use strict"
+>"use strict" : "use strict"
+
+function f() {
+>f : () => void
+
+    var a = [];
+>a : any[]
+>[] : undefined[]
+}
diff --git a/tests/baselines/reference/alwaysStrictES6.errors.txt b/tests/baselines/reference/alwaysStrictES6.errors.txt
@@ -0,0 +1,10 @@
+tests/cases/compiler/alwaysStrictES6.ts(3,9): error TS1100: Invalid use of 'arguments' in strict mode.
+
+
+==== tests/cases/compiler/alwaysStrictES6.ts (1 errors) ====
+    
+    function f() {
+        var arguments = [];
+            ~~~~~~~~~
+!!! error TS1100: Invalid use of 'arguments' in strict mode.
+    }
diff --git a/tests/baselines/reference/alwaysStrictES6.js b/tests/baselines/reference/alwaysStrictES6.js
@@ -0,0 +1,11 @@
+//// [alwaysStrictES6.ts]
+
+function f() {
+    var arguments = [];
+}
+
+//// [alwaysStrictES6.js]
+"use strict";
+function f() {
+    var arguments = [];
+}
diff --git a/tests/baselines/reference/alwaysStrictModule.errors.txt b/tests/baselines/reference/alwaysStrictModule.errors.txt
@@ -0,0 +1,12 @@
+tests/cases/compiler/alwaysStrictModule.ts(4,13): error TS1100: Invalid use of 'arguments' in strict mode.
+
+
+==== tests/cases/compiler/alwaysStrictModule.ts (1 errors) ====
+    
+    module M {
+        export function f() {
+            var arguments = [];
+                ~~~~~~~~~
+!!! error TS1100: Invalid use of 'arguments' in strict mode.
+        }
+    }
diff --git a/tests/baselines/reference/alwaysStrictModule.js b/tests/baselines/reference/alwaysStrictModule.js
@@ -0,0 +1,17 @@
+//// [alwaysStrictModule.ts]
+
+module M {
+    export function f() {
+        var arguments = [];
+    }
+}
+
+//// [alwaysStrictModule.js]
+"use strict";
+var M;
+(function (M) {
+    function f() {
+        var arguments = [];
+    }
+    M.f = f;
+})(M || (M = {}));
diff --git a/tests/baselines/reference/alwaysStrictModule2.errors.txt b/tests/baselines/reference/alwaysStrictModule2.errors.txt
@@ -0,0 +1,22 @@
+tests/cases/compiler/a.ts(4,13): error TS1100: Invalid use of 'arguments' in strict mode.
+tests/cases/compiler/b.ts(3,13): error TS1100: Invalid use of 'arguments' in strict mode.
+
+
+==== tests/cases/compiler/a.ts (1 errors) ====
+    
+    module M {
+        export function f() {
+            var arguments = [];
+                ~~~~~~~~~
+!!! error TS1100: Invalid use of 'arguments' in strict mode.
+        }
+    }
+    
+==== tests/cases/compiler/b.ts (1 errors) ====
+    module M {
+        export function f2() {
+            var arguments = [];
+                ~~~~~~~~~
+!!! error TS1100: Invalid use of 'arguments' in strict mode.
+        }
+    }
diff --git a/tests/baselines/reference/alwaysStrictModule2.js b/tests/baselines/reference/alwaysStrictModule2.js
@@ -0,0 +1,34 @@
+//// [tests/cases/compiler/alwaysStrictModule2.ts] ////
+
+//// [a.ts]
+
+module M {
+    export function f() {
+        var arguments = [];
+    }
+}
+
+//// [b.ts]
+module M {
+    export function f2() {
+        var arguments = [];
+    }
+}
+
+//// [out.js]
+"use strict";
+var M;
+(function (M) {
+    function f() {
+        var arguments = [];
+    }
+    M.f = f;
+})(M || (M = {}));
+"use strict";
+var M;
+(function (M) {
+    function f2() {
+        var arguments = [];
+    }
+    M.f2 = f2;
+})(M || (M = {}));
diff --git a/tests/baselines/reference/alwaysStrictNoImplicitUseStrict.errors.txt b/tests/baselines/reference/alwaysStrictNoImplicitUseStrict.errors.txt
@@ -0,0 +1,14 @@
+error TS5053: Option 'noImplicitUseStrict' cannot be specified with option 'alwaysStrict'.
+tests/cases/compiler/alwaysStrictNoImplicitUseStrict.ts(4,13): error TS1100: Invalid use of 'arguments' in strict mode.
+
+
+!!! error TS5053: Option 'noImplicitUseStrict' cannot be specified with option 'alwaysStrict'.
+==== tests/cases/compiler/alwaysStrictNoImplicitUseStrict.ts (1 errors) ====
+    
+    module M {
+        export function f() {
+            var arguments = [];
+                ~~~~~~~~~
+!!! error TS1100: Invalid use of 'arguments' in strict mode.
+        }
+    }
diff --git a/tests/baselines/reference/alwaysStrictNoImplicitUseStrict.js b/tests/baselines/reference/alwaysStrictNoImplicitUseStrict.js
@@ -0,0 +1,17 @@
+//// [alwaysStrictNoImplicitUseStrict.ts]
+
+module M {
+    export function f() {
+        var arguments = [];
+    }
+}
+
+//// [alwaysStrictNoImplicitUseStrict.js]
+"use strict";
+var M;
+(function (M) {
+    function f() {
+        var arguments = [];
+    }
+    M.f = f;
+})(M || (M = {}));
diff --git a/tests/baselines/reference/transpile/Supports setting alwaysStrict.js b/tests/baselines/reference/transpile/Supports setting alwaysStrict.js
diff --git a/tests/cases/compiler/alwaysStrict.ts b/tests/cases/compiler/alwaysStrict.ts
@@ -0,0 +1,5 @@
+// @alwaysStrict: true
+
+function f() {
+    var arguments = [];
+}
diff --git a/tests/cases/compiler/alwaysStrictAlreadyUseStrict.ts b/tests/cases/compiler/alwaysStrictAlreadyUseStrict.ts
@@ -0,0 +1,5 @@
+// @alwaysStrict: true
+"use strict"
+function f() {
+    var a = [];
+}
diff --git a/tests/cases/compiler/alwaysStrictES6.ts b/tests/cases/compiler/alwaysStrictES6.ts
@@ -0,0 +1,6 @@
+// @target: ES6
+// @alwaysStrict: true
+
+function f() {
+    var arguments = [];
+}
diff --git a/tests/cases/compiler/alwaysStrictModule.ts b/tests/cases/compiler/alwaysStrictModule.ts
@@ -0,0 +1,8 @@
+// @module: commonjs
+// @alwaysStrict: true
+
+module M {
+    export function f() {
+        var arguments = [];
+    }
+}
diff --git a/tests/cases/compiler/alwaysStrictModule2.ts b/tests/cases/compiler/alwaysStrictModule2.ts
@@ -0,0 +1,16 @@
+// @alwaysStrict: true
+// @outFile: out.js
+
+// @fileName: a.ts
+module M {
+    export function f() {
+        var arguments = [];
+    }
+}
+
+// @fileName: b.ts
+module M {
+    export function f2() {
+        var arguments = [];
+    }
+}
diff --git a/tests/cases/compiler/alwaysStrictNoImplicitUseStrict.ts b/tests/cases/compiler/alwaysStrictNoImplicitUseStrict.ts

Original file line number	Diff line number	Diff line change
`@@ -1473,6 +1473,10 @@ namespace ts {`
`1473`	`1473`	`programDiagnostics.add(createCompilerDiagnostic(Diagnostics.Option_0_cannot_be_specified_with_option_1, "lib", "noLib"));`
`1474`	`1474`	`}`
`1475`	`1475`
	`1476`	`+ if (options.noImplicitUseStrict && options.alwaysStrict) {`
	`1477`	`+ programDiagnostics.add(createCompilerDiagnostic(Diagnostics.Option_0_cannot_be_specified_with_option_1, "noImplicitUseStrict", "alwaysStrict"));`
	`1478`	`+ }`
	`1479`	`+`
`1476`	`1480`	`const languageVersion = options.target \|\| ScriptTarget.ES3;`
`1477`	`1481`	`const outFile = options.outFile \|\| options.out;`
`1478`	`1482`