arguments should not be allowed in class static block

src/compiler/checker.ts

@@ -25347,8 +25347,8 @@ namespace ts {
             // To avoid that we will give an error to users if they use arguments objects in arrow function so that they
             // can explicitly bound arguments objects
             if (symbol === argumentsSymbol) {
-                if (isInPropertyInitializerOrClassStaticBlock(node)) {
-                    error(node, Diagnostics.arguments_cannot_be_referenced_in_property_initializers);
+                if (isArgumentsInPropertyInitializerOrClassStaticBlock(node)) {
+                    error(node, Diagnostics.arguments_cannot_be_referenced_in_property_initializers_or_class_static_initialization_block);
                     return errorType;
                 }
 
@@ -28898,6 +28898,20 @@ namespace ts {
             });
         }
 
+        function isArgumentsInPropertyInitializerOrClassStaticBlock(node: Node): boolean {
+            return !!findAncestor(node, node => {
+                switch(node.kind) {
+                    case SyntaxKind.PropertyDeclaration:
+                    case SyntaxKind.ClassStaticBlockDeclaration:
+                        return true;
+                    case SyntaxKind.ArrowFunction:
+                        return false;
+                    default:
+                        return isFunctionLikeDeclaration(node) ? "quit" : false;
+                }
+            });
+        }
+
         /**
          * It's possible that "prop.valueDeclaration" is a local declaration, but the property was also declared in a superclass.
          * In that case we won't consider it used before its declaration, because it gets its value from the superclass' declaration.

src/compiler/diagnosticMessages.json

@@ -3353,7 +3353,7 @@
         "category": "Error",
         "code": 2814
     },
-    "'arguments' cannot be referenced in property initializers.": {
+    "'arguments' cannot be referenced in property initializers or class static initialization block.": {
         "category": "Error",
         "code": 2815
     },

tests/baselines/reference/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.errors.txt

@@ -1,44 +1,141 @@
-tests/cases/compiler/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(3,10): error TS2815: 'arguments' cannot be referenced in property initializers.
-tests/cases/compiler/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(9,10): error TS2815: 'arguments' cannot be referenced in property initializers.
-tests/cases/compiler/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(15,15): error TS2815: 'arguments' cannot be referenced in property initializers.
-tests/cases/compiler/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(21,15): error TS2815: 'arguments' cannot be referenced in property initializers.
+tests/cases/compiler/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(3,10): error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization block.
+tests/cases/compiler/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(9,10): error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization block.
+tests/cases/compiler/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(15,15): error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization block.
+tests/cases/compiler/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(21,15): error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization block.
+tests/cases/compiler/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(33,16): error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization block.
+tests/cases/compiler/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(40,7): error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization block.
+tests/cases/compiler/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(42,16): error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization block.
+tests/cases/compiler/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(57,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
+tests/cases/compiler/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(60,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
+tests/cases/compiler/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(66,6): error TS2585: 'Symbol' only refers to a type, but is being used as a value here. Do you need to change your target library? Try changing the 'lib' compiler option to es2015 or later.
+tests/cases/compiler/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(75,7): error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization block.
+tests/cases/compiler/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(77,9): error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization block.
+tests/cases/compiler/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(96,26): error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization block.
 
 
-==== tests/cases/compiler/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts (4 errors) ====
+==== tests/cases/compiler/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts (13 errors) ====
     function A() {
       return class T {
          a = arguments
              ~~~~~~~~~
-!!! error TS2815: 'arguments' cannot be referenced in property initializers.
+!!! error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization block.
       }
     }
 
     function A1() {
       return new class T {
          a = arguments
              ~~~~~~~~~
-!!! error TS2815: 'arguments' cannot be referenced in property initializers.
+!!! error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization block.
       }
     }
 
     function B() {
       return class T {
          a = { b: arguments }
                   ~~~~~~~~~
-!!! error TS2815: 'arguments' cannot be referenced in property initializers.
+!!! error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization block.
       }
     }
 
     function B1() {
       return new class T {
          a = { b: arguments }
                   ~~~~~~~~~
-!!! error TS2815: 'arguments' cannot be referenced in property initializers.
+!!! error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization block.
       }
     }
 
     function C() {
       return class T {
          a = function () { arguments }
       }
-    }
+    }
+
+    function D() {
+      return class T {
+         a = () => arguments  // should error
+                   ~~~~~~~~~
+!!! error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization block.
+      }
+    }
+
+    function D1() {
+      return class T {
+        a = () => {
+          arguments;    // should error
+          ~~~~~~~~~
+!!! error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization block.
+          const b = () => {
+            return arguments;     // should error
+                   ~~~~~~~~~
+!!! error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization block.
+          }
+
+          function f() {
+            return arguments;      // ok
+          }
+        }
+     }
+    }
+
+    function D2() {
+      return class {
+        constructor() {
+          arguments;  // ok
+        }
+        get foo() {
+            ~~~
+!!! error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
+          return arguments;  // ok
+        }
+        set foo(foo: any) {
+            ~~~
+!!! error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
+          arguments;  // ok
+        }
+        bar() {
+          arguments;  // ok
+        }
+        [Symbol.iterator]() {
+         ~~~~~~
+!!! error TS2585: 'Symbol' only refers to a type, but is being used as a value here. Do you need to change your target library? Try changing the 'lib' compiler option to es2015 or later.
+          arguments;  // ok
+        }
+      }
+    }
+
+    function D3() {
+      return class T {
+        static {
+          arguments;  // should error
+          ~~~~~~~~~
+!!! error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization block.
+          while(1) {
+            arguments // should error
+            ~~~~~~~~~
+!!! error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization block.
+          }
+        }
+      }
+    }
+
+    function D4() {
+      return class T {
+        static {
+          function f() {
+            arguments;  // ok
+          }
+        }
+      }
+    }
+
+
+    function D5() {
+      return class T {
+         a = (() => { return arguments; })()  // should error
+                             ~~~~~~~~~
+!!! error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization block.
+      }
+    }
+

tests/baselines/reference/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.js

@@ -27,7 +27,77 @@ function C() {
   return class T {
      a = function () { arguments }
   }
-}
+}
+
+function D() {
+  return class T {
+     a = () => arguments  // should error
+  }
+}
+
+function D1() {
+  return class T {
+    a = () => {
+      arguments;    // should error
+      const b = () => {
+        return arguments;     // should error
+      }
+
+      function f() {
+        return arguments;      // ok
+      }
+    }
+ }
+}
+
+function D2() {
+  return class {
+    constructor() {
+      arguments;  // ok
+    }
+    get foo() {
+      return arguments;  // ok
+    }
+    set foo(foo: any) {
+      arguments;  // ok
+    }
+    bar() {
+      arguments;  // ok
+    }
+    [Symbol.iterator]() {
+      arguments;  // ok
+    }
+  }
+}
+
+function D3() {
+  return class T {
+    static {
+      arguments;  // should error
+      while(1) {
+        arguments // should error
+      }
+    }
+  }
+}
+
+function D4() {
+  return class T {
+    static {
+      function f() {
+        arguments;  // ok
+      }
+    }
+  }
+}
+
+
+function D5() {
+  return class T {
+     a = (() => { return arguments; })()  // should error
+  }
+}
+
 
 //// [argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.js]
 function A() {
@@ -70,3 +140,88 @@ function C() {
         return T;
     }());
 }
+function D() {
+    return /** @class */ (function () {
+        function T() {
+            this.a = function () { return arguments; }; // should error
+        }
+        return T;
+    }());
+}
+function D1() {
+    return /** @class */ (function () {
+        function T() {
+            this.a = function () {
+                arguments; // should error
+                var b = function () {
+                    return arguments; // should error
+                };
+                function f() {
+                    return arguments; // ok
+                }
+            };
+        }
+        return T;
+    }());
+}
+function D2() {
+    return /** @class */ (function () {
+        function class_1() {
+            arguments; // ok
+        }
+        Object.defineProperty(class_1.prototype, "foo", {
+            get: function () {
+                return arguments; // ok
+            },
+            set: function (foo) {
+                arguments; // ok
+            },
+            enumerable: false,
+            configurable: true
+        });
+        class_1.prototype.bar = function () {
+            arguments; // ok
+        };
+        class_1.prototype[Symbol.iterator] = function () {
+            arguments; // ok
+        };
+        return class_1;
+    }());
+}
+function D3() {
+    var _a;
+    return _a = /** @class */ (function () {
+            function T() {
+            }
+            return T;
+        }()),
+        (function () {
+            arguments; // should error
+            while (1) {
+                arguments; // should error
+            }
+        })(),
+        _a;
+}
+function D4() {
+    var _a;
+    return _a = /** @class */ (function () {
+            function T() {
+            }
+            return T;
+        }()),
+        (function () {
+            function f() {
+                arguments; // ok
+            }
+        })(),
+        _a;
+}
+function D5() {
+    return /** @class */ (function () {
+        function T() {
+            this.a = (function () { return arguments; })(); // should error
+        }
+        return T;
+    }());
+}