Merge branch '10758-always-strict' of https://github.com/slawomir/TypeScript into slawomir-10758-always-strict

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.
+    }

tests/baselines/reference/alwaysStrict.js

@@ -0,0 +1,11 @@
+//// [alwaysStrict.ts]
+
+function f() {
+    var arguments = [];
+}
+
+//// [alwaysStrict.js]
+"use strict";
+function f() {
+    var arguments = [];
+}

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 = [];
+}

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))
+}

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[]
+}

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.
+    }

tests/baselines/reference/alwaysStrictES6.js

@@ -0,0 +1,11 @@
+//// [alwaysStrictES6.ts]
+
+function f() {
+    var arguments = [];
+}
+
+//// [alwaysStrictES6.js]
+"use strict";
+function f() {
+    var arguments = [];
+}

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.
+        }
+    }

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 = {}));

tests/baselines/reference/alwaysStrictNoImplicitUseStrict.errors.txt

@@ -0,0 +1,12 @@
+tests/cases/compiler/alwaysStrictNoImplicitUseStrict.ts(4,13): error TS1100: Invalid use of 'arguments' in strict mode.
+
+
+==== tests/cases/compiler/alwaysStrictNoImplicitUseStrict.ts (1 errors) ====
+    
+    module M {
+        export function f() {
+            var arguments = [];
+                ~~~~~~~~~
+!!! error TS1100: Invalid use of 'arguments' in strict mode.
+        }
+    }

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 = {}));

tests/baselines/reference/transpile/Supports setting alwaysStrict.js

@@ -0,0 +1,3 @@
+"use strict";
+x;
+//# sourceMappingURL=input.js.map

tests/cases/compiler/alwaysStrict.ts

@@ -0,0 +1,5 @@
+// @alwaysStrict: true
+
+function f() {
+    var arguments = [];
+}

tests/cases/compiler/alwaysStrictAlreadyUseStrict.ts

@@ -0,0 +1,5 @@
+// @alwaysStrict: true
+"use strict"
+function f() {
+    var a = [];
+}

tests/cases/compiler/alwaysStrictES6.ts

@@ -0,0 +1,6 @@
+// @target: ES6
+// @alwaysStrict: true
+
+function f() {
+    var arguments = [];
+}

tests/cases/compiler/alwaysStrictModule.ts

@@ -0,0 +1,8 @@
+// @module: commonjs
+// @alwaysStrict: true
+
+module M {
+    export function f() {
+        var arguments = [];
+    }
+}

tests/cases/compiler/alwaysStrictNoImplicitUseStrict.ts

@@ -0,0 +1,9 @@
+// @module: commonjs
+// @alwaysStrict: true
+// @noImplicitUseStrict: true
+
+module M {
+    export function f() {
+        var arguments = [];
+    }
+}