diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArgumentsES6.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments01.errors.txt
similarity index 76%
rename from tests/baselines/reference/emitArrowFunctionWhenUsingArgumentsES6.errors.txt
rename to tests/baselines/reference/emitArrowFunctionWhenUsingArguments01.errors.txt
index 26f204d3ee6..ddae6bca8a4 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArgumentsES6.errors.txt
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments01.errors.txt
@@ -1,10 +1,10 @@
-tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArgumentsES6.ts(2,15): error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
-tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArgumentsES6.ts(7,19): error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
-tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArgumentsES6.ts(13,13): error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
-tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArgumentsES6.ts(19,15): error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
+tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments01.ts(2,15): error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
+tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments01.ts(7,19): error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
+tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments01.ts(13,13): error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
+tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments01.ts(19,15): error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
 
 
-==== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArgumentsES6.ts (4 errors) ====
+==== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments01.ts (4 errors) ====
     var a = () => {
         var arg = arguments[0];  // error
                   ~~~~~~~~~
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArgumentsES6.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments01.js
similarity index 78%
rename from tests/baselines/reference/emitArrowFunctionWhenUsingArgumentsES6.js
rename to tests/baselines/reference/emitArrowFunctionWhenUsingArguments01.js
index 2f84d0843de..40a2748fdae 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArgumentsES6.js
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments01.js
@@ -1,4 +1,4 @@
-//// [emitArrowFunctionWhenUsingArgumentsES6.ts]
+//// [emitArrowFunctionWhenUsingArguments01.ts]
 var a = () => {
     var arg = arguments[0];  // error
 }
@@ -31,28 +31,28 @@ function bar() {
 	}
 }
 
-//// [emitArrowFunctionWhenUsingArgumentsES6.js]
-var a = () => {
+//// [emitArrowFunctionWhenUsingArguments01.js]
+var a = function () {
     var arg = arguments[0]; // error
 };
 var b = function () {
-    var a = () => {
+    var a = function () {
         var arg = arguments[0]; // error
     };
 };
 function baz() {
-    (() => {
+    (function () {
         var arg = arguments[0];
     });
 }
 function foo(inputFunc) { }
-foo(() => {
+foo(function () {
     var arg = arguments[0]; // error
 });
 function bar() {
     var arg = arguments[0]; // no error
 }
-(() => {
+(function () {
     function foo() {
         var arg = arguments[0]; // no error
     }
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments01_ES6.errors.txt
similarity index 67%
rename from tests/baselines/reference/emitArrowFunctionWhenUsingArguments.errors.txt
rename to tests/baselines/reference/emitArrowFunctionWhenUsingArguments01_ES6.errors.txt
index 2f5ca2a387c..3eb07e965ba 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments.errors.txt
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments01_ES6.errors.txt
@@ -1,10 +1,10 @@
-tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments.ts(2,15): error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
-tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments.ts(7,19): error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
-tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments.ts(13,13): error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
-tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments.ts(19,15): error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
+tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments01_ES6.ts(2,15): error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
+tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments01_ES6.ts(7,19): error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
+tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments01_ES6.ts(13,13): error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
+tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments01_ES6.ts(19,15): error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
 
 
-==== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments.ts (4 errors) ====
+==== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments01_ES6.ts (4 errors) ====
     var a = () => {
         var arg = arguments[0];  // error
                   ~~~~~~~~~
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments01_ES6.js
similarity index 86%
rename from tests/baselines/reference/emitArrowFunctionWhenUsingArguments.js
rename to tests/baselines/reference/emitArrowFunctionWhenUsingArguments01_ES6.js
index 589449fad62..6641e28b867 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments.js
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments01_ES6.js
@@ -1,4 +1,4 @@
-//// [emitArrowFunctionWhenUsingArguments.ts]
+//// [emitArrowFunctionWhenUsingArguments01_ES6.ts]
 var a = () => {
     var arg = arguments[0];  // error
 }
@@ -31,7 +31,7 @@ function bar() {
 	}
 }
 
-//// [emitArrowFunctionWhenUsingArguments.js]
+//// [emitArrowFunctionWhenUsingArguments01_ES6.js]
 var a = () => {
     var arg = arguments[0]; // error
 };
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02.errors.txt
new file mode 100644
index 00000000000..47ffcccd216
--- /dev/null
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02.errors.txt
@@ -0,0 +1,8 @@
+tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments02.ts(2,15): error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
+
+
+==== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments02.ts (1 errors) ====
+    
+    var a = () => arguments;
+                  ~~~~~~~~~
+!!! error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
\ No newline at end of file
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02.js
new file mode 100644
index 00000000000..b6774dd5407
--- /dev/null
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02.js
@@ -0,0 +1,6 @@
+//// [emitArrowFunctionWhenUsingArguments02.ts]
+
+var a = () => arguments;
+
+//// [emitArrowFunctionWhenUsingArguments02.js]
+var a = function () { return arguments; };
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02_ES6.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02_ES6.errors.txt
new file mode 100644
index 00000000000..860700e0086
--- /dev/null
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02_ES6.errors.txt
@@ -0,0 +1,8 @@
+tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments02_ES6.ts(2,15): error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
+
+
+==== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments02_ES6.ts (1 errors) ====
+    
+    var a = () => arguments;
+                  ~~~~~~~~~
+!!! error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
\ No newline at end of file
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02_ES6.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02_ES6.js
new file mode 100644
index 00000000000..0f35b8898b2
--- /dev/null
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02_ES6.js
@@ -0,0 +1,6 @@
+//// [emitArrowFunctionWhenUsingArguments02_ES6.ts]
+
+var a = () => arguments;
+
+//// [emitArrowFunctionWhenUsingArguments02_ES6.js]
+var a = () => arguments;
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03.errors.txt
new file mode 100644
index 00000000000..153ea8003e0
--- /dev/null
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03.errors.txt
@@ -0,0 +1,9 @@
+tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments03.ts(3,15): error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
+
+
+==== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments03.ts (1 errors) ====
+    
+    var arguments;
+    var a = () => arguments;
+                  ~~~~~~~~~
+!!! error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
\ No newline at end of file
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03.js
new file mode 100644
index 00000000000..5b57f7acf0d
--- /dev/null
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03.js
@@ -0,0 +1,8 @@
+//// [emitArrowFunctionWhenUsingArguments03.ts]
+
+var arguments;
+var a = () => arguments;
+
+//// [emitArrowFunctionWhenUsingArguments03.js]
+var arguments;
+var a = function () { return arguments; };
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03_ES6.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03_ES6.errors.txt
new file mode 100644
index 00000000000..60b752bc569
--- /dev/null
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03_ES6.errors.txt
@@ -0,0 +1,9 @@
+tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments03_ES6.ts(3,15): error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
+
+
+==== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments03_ES6.ts (1 errors) ====
+    
+    var arguments;
+    var a = () => arguments;
+                  ~~~~~~~~~
+!!! error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
\ No newline at end of file
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03_ES6.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03_ES6.js
new file mode 100644
index 00000000000..d4d35e7abdc
--- /dev/null
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03_ES6.js
@@ -0,0 +1,8 @@
+//// [emitArrowFunctionWhenUsingArguments03_ES6.ts]
+
+var arguments;
+var a = () => arguments;
+
+//// [emitArrowFunctionWhenUsingArguments03_ES6.js]
+var arguments;
+var a = () => arguments;
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04.errors.txt
new file mode 100644
index 00000000000..2c7a08d7479
--- /dev/null
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04.errors.txt
@@ -0,0 +1,11 @@
+tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments04.ts(4,19): error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
+
+
+==== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments04.ts (1 errors) ====
+    
+    function f() {
+        var arguments;
+        var a = () => arguments;
+                      ~~~~~~~~~
+!!! error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04.js
new file mode 100644
index 00000000000..588610a4022
--- /dev/null
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04.js
@@ -0,0 +1,12 @@
+//// [emitArrowFunctionWhenUsingArguments04.ts]
+
+function f() {
+    var arguments;
+    var a = () => arguments;
+}
+
+//// [emitArrowFunctionWhenUsingArguments04.js]
+function f() {
+    var arguments;
+    var a = function () { return arguments; };
+}
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04_ES6.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04_ES6.errors.txt
new file mode 100644
index 00000000000..8ff3b9bc16e
--- /dev/null
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04_ES6.errors.txt
@@ -0,0 +1,11 @@
+tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments04_ES6.ts(4,19): error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
+
+
+==== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments04_ES6.ts (1 errors) ====
+    
+    function f() {
+        var arguments;
+        var a = () => arguments;
+                      ~~~~~~~~~
+!!! error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04_ES6.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04_ES6.js
new file mode 100644
index 00000000000..63e896039c9
--- /dev/null
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04_ES6.js
@@ -0,0 +1,12 @@
+//// [emitArrowFunctionWhenUsingArguments04_ES6.ts]
+
+function f() {
+    var arguments;
+    var a = () => arguments;
+}
+
+//// [emitArrowFunctionWhenUsingArguments04_ES6.js]
+function f() {
+    var arguments;
+    var a = () => arguments;
+}
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05.errors.txt
new file mode 100644
index 00000000000..8802a13e539
--- /dev/null
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05.errors.txt
@@ -0,0 +1,10 @@
+tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments05.ts(3,19): error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
+
+
+==== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments05.ts (1 errors) ====
+    
+    function f(arguments) {
+        var a = () => arguments;
+                      ~~~~~~~~~
+!!! error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05.js
new file mode 100644
index 00000000000..b4ed2b383b7
--- /dev/null
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05.js
@@ -0,0 +1,10 @@
+//// [emitArrowFunctionWhenUsingArguments05.ts]
+
+function f(arguments) {
+    var a = () => arguments;
+}
+
+//// [emitArrowFunctionWhenUsingArguments05.js]
+function f(arguments) {
+    var a = function () { return arguments; };
+}
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05_ES6.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05_ES6.errors.txt
new file mode 100644
index 00000000000..bd13e0a36a7
--- /dev/null
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05_ES6.errors.txt
@@ -0,0 +1,10 @@
+tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments05_ES6.ts(3,19): error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
+
+
+==== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments05_ES6.ts (1 errors) ====
+    
+    function f(arguments) {
+        var a = () => arguments;
+                      ~~~~~~~~~
+!!! error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05_ES6.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05_ES6.js
new file mode 100644
index 00000000000..9fe68e9bb48
--- /dev/null
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05_ES6.js
@@ -0,0 +1,10 @@
+//// [emitArrowFunctionWhenUsingArguments05_ES6.ts]
+
+function f(arguments) {
+    var a = () => arguments;
+}
+
+//// [emitArrowFunctionWhenUsingArguments05_ES6.js]
+function f(arguments) {
+    var a = () => arguments;
+}
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06.errors.txt
new file mode 100644
index 00000000000..138f9486d19
--- /dev/null
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06.errors.txt
@@ -0,0 +1,10 @@
+tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments06.ts(3,25): error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
+
+
+==== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments06.ts (1 errors) ====
+    
+    function f(arguments) {
+        var a = () => () => arguments;
+                            ~~~~~~~~~
+!!! error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06.js
new file mode 100644
index 00000000000..d004b77e947
--- /dev/null
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06.js
@@ -0,0 +1,10 @@
+//// [emitArrowFunctionWhenUsingArguments06.ts]
+
+function f(arguments) {
+    var a = () => () => arguments;
+}
+
+//// [emitArrowFunctionWhenUsingArguments06.js]
+function f(arguments) {
+    var a = function () { return function () { return arguments; }; };
+}
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06_ES6.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06_ES6.errors.txt
new file mode 100644
index 00000000000..08b9c64b49b
--- /dev/null
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06_ES6.errors.txt
@@ -0,0 +1,10 @@
+tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments06_ES6.ts(3,25): error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
+
+
+==== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments06_ES6.ts (1 errors) ====
+    
+    function f(arguments) {
+        var a = () => () => arguments;
+                            ~~~~~~~~~
+!!! error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06_ES6.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06_ES6.js
new file mode 100644
index 00000000000..6b83e0c60d9
--- /dev/null
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06_ES6.js
@@ -0,0 +1,10 @@
+//// [emitArrowFunctionWhenUsingArguments06_ES6.ts]
+
+function f(arguments) {
+    var a = () => () => arguments;
+}
+
+//// [emitArrowFunctionWhenUsingArguments06_ES6.js]
+function f(arguments) {
+    var a = () => () => arguments;
+}
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07.errors.txt
new file mode 100644
index 00000000000..a9c9638780e
--- /dev/null
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07.errors.txt
@@ -0,0 +1,10 @@
+tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments07.ts(3,34): error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
+
+
+==== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments07.ts (1 errors) ====
+    
+    function f(arguments) {
+        var a = (arguments) => () => arguments;
+                                     ~~~~~~~~~
+!!! error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07.js
new file mode 100644
index 00000000000..7f06036dfc1
--- /dev/null
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07.js
@@ -0,0 +1,10 @@
+//// [emitArrowFunctionWhenUsingArguments07.ts]
+
+function f(arguments) {
+    var a = (arguments) => () => arguments;
+}
+
+//// [emitArrowFunctionWhenUsingArguments07.js]
+function f(arguments) {
+    var a = function (arguments) { return function () { return arguments; }; };
+}
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07_ES6.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07_ES6.errors.txt
new file mode 100644
index 00000000000..51cac68f529
--- /dev/null
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07_ES6.errors.txt
@@ -0,0 +1,10 @@
+tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments07_ES6.ts(3,34): error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
+
+
+==== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments07_ES6.ts (1 errors) ====
+    
+    function f(arguments) {
+        var a = (arguments) => () => arguments;
+                                     ~~~~~~~~~
+!!! error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07_ES6.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07_ES6.js
new file mode 100644
index 00000000000..bdc8cf82d44
--- /dev/null
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07_ES6.js
@@ -0,0 +1,10 @@
+//// [emitArrowFunctionWhenUsingArguments07_ES6.ts]
+
+function f(arguments) {
+    var a = (arguments) => () => arguments;
+}
+
+//// [emitArrowFunctionWhenUsingArguments07_ES6.js]
+function f(arguments) {
+    var a = (arguments) => () => arguments;
+}
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08.js
new file mode 100644
index 00000000000..dbb89d4eb6b
--- /dev/null
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08.js
@@ -0,0 +1,10 @@
+//// [emitArrowFunctionWhenUsingArguments08.ts]
+
+function f(arguments) {
+    var a = () => (arguments) => arguments;
+}
+
+//// [emitArrowFunctionWhenUsingArguments08.js]
+function f(arguments) {
+    var a = function () { return function (arguments) { return arguments; }; };
+}
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08.types b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08.types
new file mode 100644
index 00000000000..4b6d1e19b4a
--- /dev/null
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08.types
@@ -0,0 +1,13 @@
+=== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments08.ts ===
+
+function f(arguments) {
+>f : (arguments: any) => void
+>arguments : any
+
+    var a = () => (arguments) => arguments;
+>a : () => (arguments: any) => any
+>() => (arguments) => arguments : () => (arguments: any) => any
+>(arguments) => arguments : (arguments: any) => any
+>arguments : any
+>arguments : any
+}
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08_ES6.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08_ES6.js
new file mode 100644
index 00000000000..ee568185c0a
--- /dev/null
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08_ES6.js
@@ -0,0 +1,10 @@
+//// [emitArrowFunctionWhenUsingArguments08_ES6.ts]
+
+function f(arguments) {
+    var a = () => (arguments) => arguments;
+}
+
+//// [emitArrowFunctionWhenUsingArguments08_ES6.js]
+function f(arguments) {
+    var a = () => (arguments) => arguments;
+}
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08_ES6.types b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08_ES6.types
new file mode 100644
index 00000000000..ffa0f7f0bca
--- /dev/null
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments08_ES6.types
@@ -0,0 +1,13 @@
+=== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments08_ES6.ts ===
+
+function f(arguments) {
+>f : (arguments: any) => void
+>arguments : any
+
+    var a = () => (arguments) => arguments;
+>a : () => (arguments: any) => any
+>() => (arguments) => arguments : () => (arguments: any) => any
+>(arguments) => arguments : (arguments: any) => any
+>arguments : any
+>arguments : any
+}
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments09.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments09.errors.txt
new file mode 100644
index 00000000000..c5908cac978
--- /dev/null
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments09.errors.txt
@@ -0,0 +1,10 @@
+tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments09.ts(3,25): error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
+
+
+==== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments09.ts (1 errors) ====
+    
+    function f(_arguments) {
+        var a = () => () => arguments;
+                            ~~~~~~~~~
+!!! error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments09.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments09.js
new file mode 100644
index 00000000000..c879e6f1ce9
--- /dev/null
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments09.js
@@ -0,0 +1,10 @@
+//// [emitArrowFunctionWhenUsingArguments09.ts]
+
+function f(_arguments) {
+    var a = () => () => arguments;
+}
+
+//// [emitArrowFunctionWhenUsingArguments09.js]
+function f(_arguments) {
+    var a = function () { return function () { return arguments; }; };
+}
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments09_ES6.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments09_ES6.errors.txt
new file mode 100644
index 00000000000..20f316a0a4c
--- /dev/null
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments09_ES6.errors.txt
@@ -0,0 +1,10 @@
+tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments09_ES6.ts(3,25): error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
+
+
+==== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments09_ES6.ts (1 errors) ====
+    
+    function f(_arguments) {
+        var a = () => () => arguments;
+                            ~~~~~~~~~
+!!! error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments09_ES6.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments09_ES6.js
new file mode 100644
index 00000000000..15932510d39
--- /dev/null
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments09_ES6.js
@@ -0,0 +1,10 @@
+//// [emitArrowFunctionWhenUsingArguments09_ES6.ts]
+
+function f(_arguments) {
+    var a = () => () => arguments;
+}
+
+//// [emitArrowFunctionWhenUsingArguments09_ES6.js]
+function f(_arguments) {
+    var a = () => () => arguments;
+}
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments10.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments10.errors.txt
new file mode 100644
index 00000000000..4267d0d923f
--- /dev/null
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments10.errors.txt
@@ -0,0 +1,11 @@
+tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments10.ts(4,25): error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
+
+
+==== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments10.ts (1 errors) ====
+    
+    function f() {
+        var _arguments = 10;
+        var a = () => () => arguments;
+                            ~~~~~~~~~
+!!! error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments10.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments10.js
new file mode 100644
index 00000000000..a0da99f796c
--- /dev/null
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments10.js
@@ -0,0 +1,12 @@
+//// [emitArrowFunctionWhenUsingArguments10.ts]
+
+function f() {
+    var _arguments = 10;
+    var a = () => () => arguments;
+}
+
+//// [emitArrowFunctionWhenUsingArguments10.js]
+function f() {
+    var _arguments = 10;
+    var a = function () { return function () { return arguments; }; };
+}
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments10_ES6.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments10_ES6.errors.txt
new file mode 100644
index 00000000000..348e1088643
--- /dev/null
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments10_ES6.errors.txt
@@ -0,0 +1,11 @@
+tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments10_ES6.ts(4,25): error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
+
+
+==== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments10_ES6.ts (1 errors) ====
+    
+    function f() {
+        var _arguments = 10;
+        var a = () => () => arguments;
+                            ~~~~~~~~~
+!!! error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments10_ES6.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments10_ES6.js
new file mode 100644
index 00000000000..83d2b735829
--- /dev/null
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments10_ES6.js
@@ -0,0 +1,12 @@
+//// [emitArrowFunctionWhenUsingArguments10_ES6.ts]
+
+function f() {
+    var _arguments = 10;
+    var a = () => () => arguments;
+}
+
+//// [emitArrowFunctionWhenUsingArguments10_ES6.js]
+function f() {
+    var _arguments = 10;
+    var a = () => () => arguments;
+}
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11.errors.txt
new file mode 100644
index 00000000000..3b63ccd44a2
--- /dev/null
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11.errors.txt
@@ -0,0 +1,11 @@
+tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments11.ts(4,25): error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
+
+
+==== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments11.ts (1 errors) ====
+    
+    function f(arguments) {
+        var _arguments = 10;
+        var a = () => () => arguments;
+                            ~~~~~~~~~
+!!! error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11.js
new file mode 100644
index 00000000000..13c1c771c34
--- /dev/null
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11.js
@@ -0,0 +1,12 @@
+//// [emitArrowFunctionWhenUsingArguments11.ts]
+
+function f(arguments) {
+    var _arguments = 10;
+    var a = () => () => arguments;
+}
+
+//// [emitArrowFunctionWhenUsingArguments11.js]
+function f(arguments) {
+    var _arguments = 10;
+    var a = function () { return function () { return arguments; }; };
+}
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11_ES6.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11_ES6.errors.txt
new file mode 100644
index 00000000000..1dbeff0c45e
--- /dev/null
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11_ES6.errors.txt
@@ -0,0 +1,11 @@
+tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments11_ES6.ts(4,25): error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
+
+
+==== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments11_ES6.ts (1 errors) ====
+    
+    function f(arguments) {
+        var _arguments = 10;
+        var a = () => () => arguments;
+                            ~~~~~~~~~
+!!! error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11_ES6.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11_ES6.js
new file mode 100644
index 00000000000..9616d2d351c
--- /dev/null
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11_ES6.js
@@ -0,0 +1,12 @@
+//// [emitArrowFunctionWhenUsingArguments11_ES6.ts]
+
+function f(arguments) {
+    var _arguments = 10;
+    var a = () => () => arguments;
+}
+
+//// [emitArrowFunctionWhenUsingArguments11_ES6.js]
+function f(arguments) {
+    var _arguments = 10;
+    var a = () => () => arguments;
+}
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments12.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments12.errors.txt
new file mode 100644
index 00000000000..f641faebcca
--- /dev/null
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments12.errors.txt
@@ -0,0 +1,15 @@
+tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments12.ts(3,7): error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
+tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments12.ts(4,23): error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
+
+
+==== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments12.ts (2 errors) ====
+    
+    class C {
+        f(arguments) {
+          ~~~~~~~~~
+!!! error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
+            var a = () => arguments;
+                          ~~~~~~~~~
+!!! error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
+        }
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments12.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments12.js
new file mode 100644
index 00000000000..df4fddd3b32
--- /dev/null
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments12.js
@@ -0,0 +1,17 @@
+//// [emitArrowFunctionWhenUsingArguments12.ts]
+
+class C {
+    f(arguments) {
+        var a = () => arguments;
+    }
+}
+
+//// [emitArrowFunctionWhenUsingArguments12.js]
+var C = (function () {
+    function C() {
+    }
+    C.prototype.f = function (arguments) {
+        var a = function () { return arguments; };
+    };
+    return C;
+})();
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments12_ES6.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments12_ES6.errors.txt
new file mode 100644
index 00000000000..bcc926d83eb
--- /dev/null
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments12_ES6.errors.txt
@@ -0,0 +1,15 @@
+tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments12_ES6.ts(3,7): error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
+tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments12_ES6.ts(4,23): error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
+
+
+==== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments12_ES6.ts (2 errors) ====
+    
+    class C {
+        f(arguments) {
+          ~~~~~~~~~
+!!! error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
+            var a = () => arguments;
+                          ~~~~~~~~~
+!!! error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
+        }
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments12_ES6.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments12_ES6.js
new file mode 100644
index 00000000000..8e7631f6fed
--- /dev/null
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments12_ES6.js
@@ -0,0 +1,14 @@
+//// [emitArrowFunctionWhenUsingArguments12_ES6.ts]
+
+class C {
+    f(arguments) {
+        var a = () => arguments;
+    }
+}
+
+//// [emitArrowFunctionWhenUsingArguments12_ES6.js]
+class C {
+    f(arguments) {
+        var a = () => arguments;
+    }
+}
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13.js
new file mode 100644
index 00000000000..ead0a96dacd
--- /dev/null
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13.js
@@ -0,0 +1,12 @@
+//// [emitArrowFunctionWhenUsingArguments13.ts]
+
+function f() {
+    var _arguments = 10;
+    var a = (arguments) => () => _arguments;
+}
+
+//// [emitArrowFunctionWhenUsingArguments13.js]
+function f() {
+    var _arguments = 10;
+    var a = function (arguments) { return function () { return _arguments; }; };
+}
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13.types b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13.types
new file mode 100644
index 00000000000..6e5a7555315
--- /dev/null
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13.types
@@ -0,0 +1,16 @@
+=== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments13.ts ===
+
+function f() {
+>f : () => void
+
+    var _arguments = 10;
+>_arguments : number
+>10 : number
+
+    var a = (arguments) => () => _arguments;
+>a : (arguments: any) => () => number
+>(arguments) => () => _arguments : (arguments: any) => () => number
+>arguments : any
+>() => _arguments : () => number
+>_arguments : number
+}
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13_ES6.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13_ES6.js
new file mode 100644
index 00000000000..818d27a1f57
--- /dev/null
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13_ES6.js
@@ -0,0 +1,12 @@
+//// [emitArrowFunctionWhenUsingArguments13_ES6.ts]
+
+function f() {
+    var _arguments = 10;
+    var a = (arguments) => () => _arguments;
+}
+
+//// [emitArrowFunctionWhenUsingArguments13_ES6.js]
+function f() {
+    var _arguments = 10;
+    var a = (arguments) => () => _arguments;
+}
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13_ES6.types b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13_ES6.types
new file mode 100644
index 00000000000..294f5c692e4
--- /dev/null
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments13_ES6.types
@@ -0,0 +1,16 @@
+=== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments13_ES6.ts ===
+
+function f() {
+>f : () => void
+
+    var _arguments = 10;
+>_arguments : number
+>10 : number
+
+    var a = (arguments) => () => _arguments;
+>a : (arguments: any) => () => number
+>(arguments) => () => _arguments : (arguments: any) => () => number
+>arguments : any
+>() => _arguments : () => number
+>_arguments : number
+}
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14.errors.txt
new file mode 100644
index 00000000000..ceb03631830
--- /dev/null
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14.errors.txt
@@ -0,0 +1,13 @@
+tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments14.ts(5,22): error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
+
+
+==== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments14.ts (1 errors) ====
+    
+    function f() {
+        if (Math.random()) {
+            const arguments = 100;
+            return () => arguments;
+                         ~~~~~~~~~
+!!! error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
+        }
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14.js
new file mode 100644
index 00000000000..bd94a2fda9c
--- /dev/null
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14.js
@@ -0,0 +1,16 @@
+//// [emitArrowFunctionWhenUsingArguments14.ts]
+
+function f() {
+    if (Math.random()) {
+        const arguments = 100;
+        return () => arguments;
+    }
+}
+
+//// [emitArrowFunctionWhenUsingArguments14.js]
+function f() {
+    if (Math.random()) {
+        var arguments_1 = 100;
+        return function () { return arguments; };
+    }
+}
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.errors.txt
new file mode 100644
index 00000000000..d71a2518c07
--- /dev/null
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.errors.txt
@@ -0,0 +1,13 @@
+tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments14_ES6.ts(5,22): error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
+
+
+==== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments14_ES6.ts (1 errors) ====
+    
+    function f() {
+        if (Math.random()) {
+            let arguments = 100;
+            return () => arguments;
+                         ~~~~~~~~~
+!!! error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
+        }
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.js
new file mode 100644
index 00000000000..cea4589debb
--- /dev/null
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.js
@@ -0,0 +1,16 @@
+//// [emitArrowFunctionWhenUsingArguments14_ES6.ts]
+
+function f() {
+    if (Math.random()) {
+        let arguments = 100;
+        return () => arguments;
+    }
+}
+
+//// [emitArrowFunctionWhenUsingArguments14_ES6.js]
+function f() {
+    if (Math.random()) {
+        let arguments = 100;
+        return () => arguments;
+    }
+}
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15.errors.txt
new file mode 100644
index 00000000000..af684202b2f
--- /dev/null
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15.errors.txt
@@ -0,0 +1,14 @@
+tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments15.ts(6,22): error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
+
+
+==== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments15.ts (1 errors) ====
+    
+    function f() {
+        var arguments = "hello";
+        if (Math.random()) {
+            const arguments = 100;
+            return () => arguments;
+                         ~~~~~~~~~
+!!! error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
+        }
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15.js
new file mode 100644
index 00000000000..bc5f7dca7ee
--- /dev/null
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15.js
@@ -0,0 +1,18 @@
+//// [emitArrowFunctionWhenUsingArguments15.ts]
+
+function f() {
+    var arguments = "hello";
+    if (Math.random()) {
+        const arguments = 100;
+        return () => arguments;
+    }
+}
+
+//// [emitArrowFunctionWhenUsingArguments15.js]
+function f() {
+    var arguments = "hello";
+    if (Math.random()) {
+        var arguments_1 = 100;
+        return function () { return arguments; };
+    }
+}
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.errors.txt
new file mode 100644
index 00000000000..d26b919c16d
--- /dev/null
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.errors.txt
@@ -0,0 +1,14 @@
+tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments15_ES6.ts(6,22): error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
+
+
+==== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments15_ES6.ts (1 errors) ====
+    
+    function f() {
+        var arguments = "hello";
+        if (Math.random()) {
+            const arguments = 100;
+            return () => arguments;
+                         ~~~~~~~~~
+!!! error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
+        }
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.js
new file mode 100644
index 00000000000..0fa3c9d5f64
--- /dev/null
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.js
@@ -0,0 +1,18 @@
+//// [emitArrowFunctionWhenUsingArguments15_ES6.ts]
+
+function f() {
+    var arguments = "hello";
+    if (Math.random()) {
+        const arguments = 100;
+        return () => arguments;
+    }
+}
+
+//// [emitArrowFunctionWhenUsingArguments15_ES6.js]
+function f() {
+    var arguments = "hello";
+    if (Math.random()) {
+        const arguments = 100;
+        return () => arguments;
+    }
+}
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16.errors.txt
new file mode 100644
index 00000000000..39ce66e2ce5
--- /dev/null
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16.errors.txt
@@ -0,0 +1,14 @@
+tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments16.ts(5,22): error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
+
+
+==== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments16.ts (1 errors) ====
+    
+    function f() {
+        var arguments = "hello";
+        if (Math.random()) {
+            return () => arguments[0];
+                         ~~~~~~~~~
+!!! error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
+        }
+        var arguments = "world";
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16.js
new file mode 100644
index 00000000000..0a87a3c6ac2
--- /dev/null
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16.js
@@ -0,0 +1,18 @@
+//// [emitArrowFunctionWhenUsingArguments16.ts]
+
+function f() {
+    var arguments = "hello";
+    if (Math.random()) {
+        return () => arguments[0];
+    }
+    var arguments = "world";
+}
+
+//// [emitArrowFunctionWhenUsingArguments16.js]
+function f() {
+    var arguments = "hello";
+    if (Math.random()) {
+        return function () { return arguments[0]; };
+    }
+    var arguments = "world";
+}
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.errors.txt
new file mode 100644
index 00000000000..f3beb7f21b7
--- /dev/null
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.errors.txt
@@ -0,0 +1,14 @@
+tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments16_ES6.ts(5,22): error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
+
+
+==== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments16_ES6.ts (1 errors) ====
+    
+    function f() {
+        var arguments = "hello";
+        if (Math.random()) {
+            return () => arguments[0];
+                         ~~~~~~~~~
+!!! error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
+        }
+        var arguments = "world";
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.js
new file mode 100644
index 00000000000..b9aaf7240a7
--- /dev/null
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.js
@@ -0,0 +1,18 @@
+//// [emitArrowFunctionWhenUsingArguments16_ES6.ts]
+
+function f() {
+    var arguments = "hello";
+    if (Math.random()) {
+        return () => arguments[0];
+    }
+    var arguments = "world";
+}
+
+//// [emitArrowFunctionWhenUsingArguments16_ES6.js]
+function f() {
+    var arguments = "hello";
+    if (Math.random()) {
+        return () => arguments[0];
+    }
+    var arguments = "world";
+}
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17.errors.txt
new file mode 100644
index 00000000000..3d53f02a286
--- /dev/null
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17.errors.txt
@@ -0,0 +1,14 @@
+tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments17.ts(5,22): error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
+
+
+==== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments17.ts (1 errors) ====
+    
+    function f() {
+        var { arguments } = { arguments: "hello" };
+        if (Math.random()) {
+            return () => arguments[0];
+                         ~~~~~~~~~
+!!! error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
+        }
+        var arguments = "world";
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17.js
new file mode 100644
index 00000000000..8a845ab0cb2
--- /dev/null
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17.js
@@ -0,0 +1,18 @@
+//// [emitArrowFunctionWhenUsingArguments17.ts]
+
+function f() {
+    var { arguments } = { arguments: "hello" };
+    if (Math.random()) {
+        return () => arguments[0];
+    }
+    var arguments = "world";
+}
+
+//// [emitArrowFunctionWhenUsingArguments17.js]
+function f() {
+    var arguments = { arguments: "hello" }.arguments;
+    if (Math.random()) {
+        return function () { return arguments[0]; };
+    }
+    var arguments = "world";
+}
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.errors.txt
new file mode 100644
index 00000000000..2082323f158
--- /dev/null
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.errors.txt
@@ -0,0 +1,14 @@
+tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments17_ES6.ts(5,22): error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
+
+
+==== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments17_ES6.ts (1 errors) ====
+    
+    function f() {
+        var { arguments } = { arguments: "hello" };
+        if (Math.random()) {
+            return () => arguments[0];
+                         ~~~~~~~~~
+!!! error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
+        }
+        var arguments = "world";
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.js
new file mode 100644
index 00000000000..1d1a8ece338
--- /dev/null
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.js
@@ -0,0 +1,18 @@
+//// [emitArrowFunctionWhenUsingArguments17_ES6.ts]
+
+function f() {
+    var { arguments } = { arguments: "hello" };
+    if (Math.random()) {
+        return () => arguments[0];
+    }
+    var arguments = "world";
+}
+
+//// [emitArrowFunctionWhenUsingArguments17_ES6.js]
+function f() {
+    var { arguments } = { arguments: "hello" };
+    if (Math.random()) {
+        return () => arguments[0];
+    }
+    var arguments = "world";
+}
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18.errors.txt
new file mode 100644
index 00000000000..4827559f277
--- /dev/null
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18.errors.txt
@@ -0,0 +1,13 @@
+tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments18.ts(5,22): error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
+
+
+==== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments18.ts (1 errors) ====
+    
+    function f() {
+        var { arguments: args } = { arguments };
+        if (Math.random()) {
+            return () => arguments;
+                         ~~~~~~~~~
+!!! error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
+        }
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18.js
new file mode 100644
index 00000000000..dc40302892b
--- /dev/null
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18.js
@@ -0,0 +1,16 @@
+//// [emitArrowFunctionWhenUsingArguments18.ts]
+
+function f() {
+    var { arguments: args } = { arguments };
+    if (Math.random()) {
+        return () => arguments;
+    }
+}
+
+//// [emitArrowFunctionWhenUsingArguments18.js]
+function f() {
+    var args = { arguments: arguments }.arguments;
+    if (Math.random()) {
+        return function () { return arguments; };
+    }
+}
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.errors.txt
new file mode 100644
index 00000000000..b73e4399587
--- /dev/null
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.errors.txt
@@ -0,0 +1,13 @@
+tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments18_ES6.ts(5,22): error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
+
+
+==== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments18_ES6.ts (1 errors) ====
+    
+    function f() {
+        var { arguments: args } = { arguments };
+        if (Math.random()) {
+            return () => arguments;
+                         ~~~~~~~~~
+!!! error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
+        }
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.js
new file mode 100644
index 00000000000..ae9e7e4ef10
--- /dev/null
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.js
@@ -0,0 +1,16 @@
+//// [emitArrowFunctionWhenUsingArguments18_ES6.ts]
+
+function f() {
+    var { arguments: args } = { arguments };
+    if (Math.random()) {
+        return () => arguments;
+    }
+}
+
+//// [emitArrowFunctionWhenUsingArguments18_ES6.js]
+function f() {
+    var { arguments: args } = { arguments };
+    if (Math.random()) {
+        return () => arguments;
+    }
+}
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments19.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments19.errors.txt
new file mode 100644
index 00000000000..887cc4713c9
--- /dev/null
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments19.errors.txt
@@ -0,0 +1,20 @@
+tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments19.ts(6,33): error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
+
+
+==== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments19.ts (1 errors) ====
+    
+    function f() {
+        function g() {
+            var _arguments = 10;                // No capture in 'g', so no conflict.
+            function h() {
+                var capture = () => arguments;  // Should trigger an '_arguments' capture into function 'h'
+                                    ~~~~~~~~~
+!!! error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
+                foo(_arguments);                // Error as this does not resolve to the user defined '_arguments'
+            }
+        }
+    
+        function foo(x: any) {
+            return 100;
+        }
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments19.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments19.js
new file mode 100644
index 00000000000..566c0aa49cd
--- /dev/null
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments19.js
@@ -0,0 +1,29 @@
+//// [emitArrowFunctionWhenUsingArguments19.ts]
+
+function f() {
+    function g() {
+        var _arguments = 10;                // No capture in 'g', so no conflict.
+        function h() {
+            var capture = () => arguments;  // Should trigger an '_arguments' capture into function 'h'
+            foo(_arguments);                // Error as this does not resolve to the user defined '_arguments'
+        }
+    }
+
+    function foo(x: any) {
+        return 100;
+    }
+}
+
+//// [emitArrowFunctionWhenUsingArguments19.js]
+function f() {
+    function g() {
+        var _arguments = 10; // No capture in 'g', so no conflict.
+        function h() {
+            var capture = function () { return arguments; }; // Should trigger an '_arguments' capture into function 'h'
+            foo(_arguments); // Error as this does not resolve to the user defined '_arguments'
+        }
+    }
+    function foo(x) {
+        return 100;
+    }
+}
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments19_ES6.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments19_ES6.errors.txt
new file mode 100644
index 00000000000..1750cf065bb
--- /dev/null
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments19_ES6.errors.txt
@@ -0,0 +1,20 @@
+tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments19_ES6.ts(6,33): error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
+
+
+==== tests/cases/conformance/es6/arrowFunction/emitArrowFunctionWhenUsingArguments19_ES6.ts (1 errors) ====
+    
+    function f() {
+        function g() {
+            var _arguments = 10;                // No capture in 'g', so no conflict.
+            function h() {
+                var capture = () => arguments;  // Should trigger an '_arguments' capture into function 'h'
+                                    ~~~~~~~~~
+!!! error TS2496: The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.
+                foo(_arguments);                // Error as this does not resolve to the user defined '_arguments'
+            }
+        }
+    
+        function foo(x: any) {
+            return 100;
+        }
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments19_ES6.js b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments19_ES6.js
new file mode 100644
index 00000000000..e41aed4f4bf
--- /dev/null
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments19_ES6.js
@@ -0,0 +1,29 @@
+//// [emitArrowFunctionWhenUsingArguments19_ES6.ts]
+
+function f() {
+    function g() {
+        var _arguments = 10;                // No capture in 'g', so no conflict.
+        function h() {
+            var capture = () => arguments;  // Should trigger an '_arguments' capture into function 'h'
+            foo(_arguments);                // Error as this does not resolve to the user defined '_arguments'
+        }
+    }
+
+    function foo(x: any) {
+        return 100;
+    }
+}
+
+//// [emitArrowFunctionWhenUsingArguments19_ES6.js]
+function f() {
+    function g() {
+        var _arguments = 10; // No capture in 'g', so no conflict.
+        function h() {
+            var capture = () => arguments; // Should trigger an '_arguments' capture into function 'h'
+            foo(_arguments); // Error as this does not resolve to the user defined '_arguments'
+        }
+    }
+    function foo(x) {
+        return 100;
+    }
+}