From dc8f02a066371b01e27e541585e702a32514402d Mon Sep 17 00:00:00 2001
From: Zzzen <callmetsing@gmail.com>
Date: Tue, 8 Mar 2022 13:00:48 +0800
Subject: [PATCH 1/7] `arguments` should not be allowed in class static block

---
 src/compiler/checker.ts                       |  18 +-
 src/compiler/diagnosticMessages.json          |   2 +-
 ...izerOrStaticInitializationBlock.errors.txt | 117 +++++++++++--
 ...dInitializerOrStaticInitializationBlock.js | 157 +++++++++++++++++-
 ...ializerOrStaticInitializationBlock.symbols | 126 ++++++++++++++
 ...itializerOrStaticInitializationBlock.types | 144 ++++++++++++++++
 .../reference/classStaticBlock6.errors.txt    |   8 +-
 ...dInitializerOrStaticInitializationBlock.ts |  71 +++++++-
 8 files changed, 624 insertions(+), 19 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index eee32406b7790..818102e656705 100644
--- a/src/compiler/checker.ts
+++ b/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.
diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json
index dba50cfb5330a..385a7dcb1434d 100644
--- a/src/compiler/diagnosticMessages.json
+++ b/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
     },
diff --git a/tests/baselines/reference/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.errors.txt b/tests/baselines/reference/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.errors.txt
index 3cd9988e78de3..79392677795e2 100644
--- a/tests/baselines/reference/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.errors.txt
+++ b/tests/baselines/reference/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.errors.txt
@@ -1,15 +1,24 @@
-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.
       }
     }
     
@@ -17,7 +26,7 @@ tests/cases/compiler/argumentsUsedInClassFieldInitializerOrStaticInitializationB
       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.
       }
     }
     
@@ -25,7 +34,7 @@ tests/cases/compiler/argumentsUsedInClassFieldInitializerOrStaticInitializationB
       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.
       }
     }
     
@@ -33,7 +42,7 @@ tests/cases/compiler/argumentsUsedInClassFieldInitializerOrStaticInitializationB
       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.
       }
     }
     
@@ -41,4 +50,92 @@ tests/cases/compiler/argumentsUsedInClassFieldInitializerOrStaticInitializationB
       return class T {
          a = function () { arguments }
       }
-    }
\ No newline at end of file
+    }
+    
+    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.
+      }
+    }
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.js b/tests/baselines/reference/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.js
index a162ab0cb8430..7bd74bee6a14a 100644
--- a/tests/baselines/reference/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.js
+++ b/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;
+    }());
+}
diff --git a/tests/baselines/reference/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.symbols b/tests/baselines/reference/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.symbols
index b087127c45773..13b8ff1f98db5 100644
--- a/tests/baselines/reference/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.symbols
+++ b/tests/baselines/reference/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.symbols
@@ -60,3 +60,129 @@ function C() {
 >arguments : Symbol(arguments)
   }
 }
+
+function D() {
+>D : Symbol(D, Decl(argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts, 28, 1))
+
+  return class T {
+>T : Symbol(T, Decl(argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts, 31, 8))
+
+     a = () => arguments  // should error
+>a : Symbol(T.a, Decl(argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts, 31, 18))
+>arguments : Symbol(arguments)
+  }
+}
+
+function D1() {
+>D1 : Symbol(D1, Decl(argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts, 34, 1))
+
+  return class T {
+>T : Symbol(T, Decl(argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts, 37, 8))
+
+    a = () => {
+>a : Symbol(T.a, Decl(argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts, 37, 18))
+
+      arguments;    // should error
+>arguments : Symbol(arguments)
+
+      const b = () => {
+>b : Symbol(b, Decl(argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts, 40, 11))
+
+        return arguments;     // should error
+>arguments : Symbol(arguments)
+      }
+
+      function f() {
+>f : Symbol(f, Decl(argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts, 42, 7))
+
+        return arguments;      // ok
+>arguments : Symbol(arguments)
+      }
+    }
+ }
+}
+
+function D2() {
+>D2 : Symbol(D2, Decl(argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts, 49, 1))
+
+  return class {
+    constructor() {
+      arguments;  // ok
+>arguments : Symbol(arguments)
+    }
+    get foo() {
+>foo : Symbol((Anonymous class).foo, Decl(argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts, 55, 5), Decl(argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts, 58, 5))
+
+      return arguments;  // ok
+>arguments : Symbol(arguments)
+    }
+    set foo(foo: any) {
+>foo : Symbol((Anonymous class).foo, Decl(argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts, 55, 5), Decl(argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts, 58, 5))
+>foo : Symbol(foo, Decl(argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts, 59, 12))
+
+      arguments;  // ok
+>arguments : Symbol(arguments)
+    }
+    bar() {
+>bar : Symbol((Anonymous class).bar, Decl(argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts, 61, 5))
+
+      arguments;  // ok
+>arguments : Symbol(arguments)
+    }
+    [Symbol.iterator]() {
+>[Symbol.iterator] : Symbol((Anonymous class)[Symbol.iterator], Decl(argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts, 64, 5))
+
+      arguments;  // ok
+>arguments : Symbol(arguments)
+    }
+  }
+}
+
+function D3() {
+>D3 : Symbol(D3, Decl(argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts, 69, 1))
+
+  return class T {
+>T : Symbol(T, Decl(argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts, 72, 8))
+
+    static {
+      arguments;  // should error
+>arguments : Symbol(arguments)
+
+      while(1) {
+        arguments // should error
+>arguments : Symbol(arguments)
+      }
+    }
+  }
+}
+
+function D4() {
+>D4 : Symbol(D4, Decl(argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts, 80, 1))
+
+  return class T {
+>T : Symbol(T, Decl(argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts, 83, 8))
+
+    static {
+      function f() {
+>f : Symbol(f, Decl(argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts, 84, 12))
+
+        arguments;  // ok
+>arguments : Symbol(arguments)
+      }
+    }
+  }
+}
+
+
+function D5() {
+>D5 : Symbol(D5, Decl(argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts, 90, 1))
+
+  return class T {
+>T : Symbol(T, Decl(argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts, 94, 8))
+
+     a = (() => { return arguments; })()  // should error
+>a : Symbol(T.a, Decl(argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts, 94, 18))
+>arguments : Symbol(arguments)
+  }
+}
+
diff --git a/tests/baselines/reference/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.types b/tests/baselines/reference/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.types
index d68759ae2f99d..9e35c0d31cb2f 100644
--- a/tests/baselines/reference/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.types
+++ b/tests/baselines/reference/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.types
@@ -70,3 +70,147 @@ function C() {
 >arguments : IArguments
   }
 }
+
+function D() {
+>D : () => typeof T
+
+  return class T {
+>class T {     a = () => arguments  // should error  } : typeof T
+>T : typeof T
+
+     a = () => arguments  // should error
+>a : () => any
+>() => arguments : () => any
+>arguments : any
+  }
+}
+
+function D1() {
+>D1 : () => typeof T
+
+  return class T {
+>class T {    a = () => {      arguments;    // should error      const b = () => {        return arguments;     // should error      }      function f() {        return arguments;      // ok      }    } } : typeof T
+>T : typeof T
+
+    a = () => {
+>a : () => void
+>() => {      arguments;    // should error      const b = () => {        return arguments;     // should error      }      function f() {        return arguments;      // ok      }    } : () => void
+
+      arguments;    // should error
+>arguments : any
+
+      const b = () => {
+>b : () => any
+>() => {        return arguments;     // should error      } : () => any
+
+        return arguments;     // should error
+>arguments : any
+      }
+
+      function f() {
+>f : () => IArguments
+
+        return arguments;      // ok
+>arguments : IArguments
+      }
+    }
+ }
+}
+
+function D2() {
+>D2 : () => typeof (Anonymous class)
+
+  return class {
+>class {    constructor() {      arguments;  // ok    }    get foo() {      return arguments;  // ok    }    set foo(foo: any) {      arguments;  // ok    }    bar() {      arguments;  // ok    }    [Symbol.iterator]() {      arguments;  // ok    }  } : typeof (Anonymous class)
+
+    constructor() {
+      arguments;  // ok
+>arguments : IArguments
+    }
+    get foo() {
+>foo : any
+
+      return arguments;  // ok
+>arguments : IArguments
+    }
+    set foo(foo: any) {
+>foo : any
+>foo : any
+
+      arguments;  // ok
+>arguments : IArguments
+    }
+    bar() {
+>bar : () => void
+
+      arguments;  // ok
+>arguments : IArguments
+    }
+    [Symbol.iterator]() {
+>[Symbol.iterator] : () => void
+>Symbol.iterator : any
+>Symbol : any
+>iterator : any
+
+      arguments;  // ok
+>arguments : IArguments
+    }
+  }
+}
+
+function D3() {
+>D3 : () => typeof T
+
+  return class T {
+>class T {    static {      arguments;  // should error      while(1) {        arguments // should error      }    }  } : typeof T
+>T : typeof T
+
+    static {
+      arguments;  // should error
+>arguments : any
+
+      while(1) {
+>1 : 1
+
+        arguments // should error
+>arguments : any
+      }
+    }
+  }
+}
+
+function D4() {
+>D4 : () => typeof T
+
+  return class T {
+>class T {    static {      function f() {        arguments;  // ok      }    }  } : typeof T
+>T : typeof T
+
+    static {
+      function f() {
+>f : () => void
+
+        arguments;  // ok
+>arguments : IArguments
+      }
+    }
+  }
+}
+
+
+function D5() {
+>D5 : () => typeof T
+
+  return class T {
+>class T {     a = (() => { return arguments; })()  // should error  } : typeof T
+>T : typeof T
+
+     a = (() => { return arguments; })()  // should error
+>a : any
+>(() => { return arguments; })() : any
+>(() => { return arguments; }) : () => any
+>() => { return arguments; } : () => any
+>arguments : any
+  }
+}
+
diff --git a/tests/baselines/reference/classStaticBlock6.errors.txt b/tests/baselines/reference/classStaticBlock6.errors.txt
index de890470ed4ba..5d92ff772a8f2 100644
--- a/tests/baselines/reference/classStaticBlock6.errors.txt
+++ b/tests/baselines/reference/classStaticBlock6.errors.txt
@@ -7,12 +7,12 @@ tests/cases/conformance/classes/classStaticBlock/classStaticBlock6.ts(18,9): err
 tests/cases/conformance/classes/classStaticBlock/classStaticBlock6.ts(18,14): error TS1109: Expression expected.
 tests/cases/conformance/classes/classStaticBlock/classStaticBlock6.ts(19,9): error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors.
 tests/cases/conformance/classes/classStaticBlock/classStaticBlock6.ts(32,17): error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors.
-tests/cases/conformance/classes/classStaticBlock/classStaticBlock6.ts(41,13): error TS2815: 'arguments' cannot be referenced in property initializers.
+tests/cases/conformance/classes/classStaticBlock/classStaticBlock6.ts(41,13): error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization block.
 tests/cases/conformance/classes/classStaticBlock/classStaticBlock6.ts(42,13): error TS18037: Await expression cannot be used inside a class static block.
 tests/cases/conformance/classes/classStaticBlock/classStaticBlock6.ts(42,18): error TS1109: Expression expected.
 tests/cases/conformance/classes/classStaticBlock/classStaticBlock6.ts(45,17): error TS2522: The 'arguments' object cannot be referenced in an async function or method in ES3 and ES5. Consider using a standard function or method.
 tests/cases/conformance/classes/classStaticBlock/classStaticBlock6.ts(46,22): error TS1109: Expression expected.
-tests/cases/conformance/classes/classStaticBlock/classStaticBlock6.ts(55,13): error TS2815: 'arguments' cannot be referenced in property initializers.
+tests/cases/conformance/classes/classStaticBlock/classStaticBlock6.ts(55,13): error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization block.
 
 
 ==== tests/cases/conformance/classes/classStaticBlock/classStaticBlock6.ts (15 errors) ====
@@ -76,7 +76,7 @@ tests/cases/conformance/classes/classStaticBlock/classStaticBlock6.ts(55,13): er
             static {
                 arguments;
                 ~~~~~~~~~
-!!! error TS2815: 'arguments' cannot be referenced in property initializers.
+!!! error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization block.
                 await;
                 ~~~~~
 !!! error TS18037: Await expression cannot be used inside a class static block.
@@ -100,7 +100,7 @@ tests/cases/conformance/classes/classStaticBlock/classStaticBlock6.ts(55,13): er
             static {
                 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 ff () {
                     arguments;
diff --git a/tests/cases/compiler/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts b/tests/cases/compiler/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts
index 50e762e03fb9a..b25850652bc55 100644
--- a/tests/cases/compiler/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts
+++ b/tests/cases/compiler/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts
@@ -26,4 +26,73 @@ function C() {
   return class T {
      a = function () { arguments }
   }
-}
\ No newline at end of file
+}
+
+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
+  }
+}

From 9e6603c00eb04dd7394bf9c71598181bdcb8a2f4 Mon Sep 17 00:00:00 2001
From: Zzzen <callmetsing@gmail.com>
Date: Fri, 11 Mar 2022 20:01:14 +0800
Subject: [PATCH 2/7] update isInPropertyInitializerOrClassStaticBlock

---
 src/compiler/checker.ts                       | 26 +++++-------------
 .../reference/classStaticBlock6.errors.txt    | 22 +++++++++++++--
 .../baselines/reference/classStaticBlock6.js  | 27 ++++++++++++++++++-
 .../reference/classStaticBlock6.symbols       | 20 ++++++++++++++
 .../reference/classStaticBlock6.types         | 23 ++++++++++++++++
 .../classStaticBlock/classStaticBlock6.ts     | 11 ++++++++
 6 files changed, 107 insertions(+), 22 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 818102e656705..07f6c2dcd648a 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -25347,7 +25347,7 @@ 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 (isArgumentsInPropertyInitializerOrClassStaticBlock(node)) {
+                if (isInPropertyInitializerOrClassStaticBlock(node, /* ignoreArrowFunctions */true)) {
                     error(node, Diagnostics.arguments_cannot_be_referenced_in_property_initializers_or_class_static_initialization_block);
                     return errorType;
                 }
@@ -28869,11 +28869,12 @@ namespace ts {
             }
         }
 
-        function isInPropertyInitializerOrClassStaticBlock(node: Node): boolean {
+        function isInPropertyInitializerOrClassStaticBlock(node: Node, ignoreArrowFunctions?: boolean): boolean {
             return !!findAncestor(node, node => {
                 switch (node.kind) {
                     case SyntaxKind.PropertyDeclaration:
-                        return true;
+                    case SyntaxKind.ClassStaticBlockDeclaration:
+                            return true;
                     case SyntaxKind.PropertyAssignment:
                     case SyntaxKind.MethodDeclaration:
                     case SyntaxKind.GetAccessor:
@@ -28889,23 +28890,10 @@ namespace ts {
                     case SyntaxKind.ExpressionWithTypeArguments:
                     case SyntaxKind.HeritageClause:
                         return false;
+                    case SyntaxKind.JsxClosingElement:  // already reported in JsxOpeningElement
+                        return "quit";
                     case SyntaxKind.ArrowFunction:
-                    case SyntaxKind.ExpressionStatement:
-                        return isBlock(node.parent) && isClassStaticBlockDeclaration(node.parent.parent) ? true : "quit";
-                    default:
-                        return isExpressionNode(node) ? false : "quit";
-                }
-            });
-        }
-
-        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;
+                        return ignoreArrowFunctions ? false : "quit";
                     default:
                         return isFunctionLikeDeclaration(node) ? "quit" : false;
                 }
diff --git a/tests/baselines/reference/classStaticBlock6.errors.txt b/tests/baselines/reference/classStaticBlock6.errors.txt
index 5d92ff772a8f2..eb89e9e71d6f3 100644
--- a/tests/baselines/reference/classStaticBlock6.errors.txt
+++ b/tests/baselines/reference/classStaticBlock6.errors.txt
@@ -13,9 +13,11 @@ tests/cases/conformance/classes/classStaticBlock/classStaticBlock6.ts(42,18): er
 tests/cases/conformance/classes/classStaticBlock/classStaticBlock6.ts(45,17): error TS2522: The 'arguments' object cannot be referenced in an async function or method in ES3 and ES5. Consider using a standard function or method.
 tests/cases/conformance/classes/classStaticBlock/classStaticBlock6.ts(46,22): error TS1109: Expression expected.
 tests/cases/conformance/classes/classStaticBlock/classStaticBlock6.ts(55,13): error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization block.
+tests/cases/conformance/classes/classStaticBlock/classStaticBlock6.ts(66,14): error TS2729: Property 'b' is used before its initialization.
+tests/cases/conformance/classes/classStaticBlock/classStaticBlock6.ts(68,18): error TS2729: Property 'b' is used before its initialization.
 
 
-==== tests/cases/conformance/classes/classStaticBlock/classStaticBlock6.ts (15 errors) ====
+==== tests/cases/conformance/classes/classStaticBlock/classStaticBlock6.ts (17 errors) ====
     class B {
         static a = 1;
     }
@@ -108,4 +110,20 @@ tests/cases/conformance/classes/classStaticBlock/classStaticBlock6.ts(55,13): er
             }
         }
     }
-    
\ No newline at end of file
+    
+    class foo2 {
+        static {
+            this.b  // should error
+                 ~
+!!! error TS2729: Property 'b' is used before its initialization.
+!!! related TS2728 tests/cases/conformance/classes/classStaticBlock/classStaticBlock6.ts:72:12: 'b' is declared here.
+            if (1) {
+                this.b; // should error
+                     ~
+!!! error TS2729: Property 'b' is used before its initialization.
+!!! related TS2728 tests/cases/conformance/classes/classStaticBlock/classStaticBlock6.ts:72:12: 'b' is declared here.
+            }
+        }
+    
+        static b = 1;
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/classStaticBlock6.js b/tests/baselines/reference/classStaticBlock6.js
index 69d146407890e..4e7d7ec7d6376 100644
--- a/tests/baselines/reference/classStaticBlock6.js
+++ b/tests/baselines/reference/classStaticBlock6.js
@@ -61,7 +61,17 @@ function foo1 () {
         }
     }
 }
-
+
+class foo2 {
+    static {
+        this.b  // should error
+        if (1) {
+            this.b; // should error
+        }
+    }
+
+    static b = 1;
+}
 
 //// [classStaticBlock6.js]
 var __extends = (this && this.__extends) || (function () {
@@ -115,6 +125,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
+var _this = this;
 var B = /** @class */ (function () {
     function B() {
     }
@@ -211,3 +222,17 @@ function foo1() {
         }
     })();
 }
+var foo2 = /** @class */ (function () {
+    function foo2() {
+    }
+    var _a;
+    _a = foo2;
+    (function () {
+        _a.b; // should error
+        if (1) {
+            _a.b; // should error
+        }
+    })();
+    foo2.b = 1;
+    return foo2;
+}());
diff --git a/tests/baselines/reference/classStaticBlock6.symbols b/tests/baselines/reference/classStaticBlock6.symbols
index 6505cd0cf9a99..6973287272347 100644
--- a/tests/baselines/reference/classStaticBlock6.symbols
+++ b/tests/baselines/reference/classStaticBlock6.symbols
@@ -102,3 +102,23 @@ function foo1 () {
     }
 }
 
+class foo2 {
+>foo2 : Symbol(foo2, Decl(classStaticBlock6.ts, 61, 1))
+
+    static {
+        this.b  // should error
+>this.b : Symbol(foo2.b, Decl(classStaticBlock6.ts, 69, 5))
+>this : Symbol(foo2, Decl(classStaticBlock6.ts, 61, 1))
+>b : Symbol(foo2.b, Decl(classStaticBlock6.ts, 69, 5))
+
+        if (1) {
+            this.b; // should error
+>this.b : Symbol(foo2.b, Decl(classStaticBlock6.ts, 69, 5))
+>this : Symbol(foo2, Decl(classStaticBlock6.ts, 61, 1))
+>b : Symbol(foo2.b, Decl(classStaticBlock6.ts, 69, 5))
+        }
+    }
+
+    static b = 1;
+>b : Symbol(foo2.b, Decl(classStaticBlock6.ts, 69, 5))
+}
diff --git a/tests/baselines/reference/classStaticBlock6.types b/tests/baselines/reference/classStaticBlock6.types
index af1243a74f89a..d899d8bd474ef 100644
--- a/tests/baselines/reference/classStaticBlock6.types
+++ b/tests/baselines/reference/classStaticBlock6.types
@@ -123,3 +123,26 @@ function foo1 () {
     }
 }
 
+class foo2 {
+>foo2 : foo2
+
+    static {
+        this.b  // should error
+>this.b : number
+>this : typeof foo2
+>b : number
+
+        if (1) {
+>1 : 1
+
+            this.b; // should error
+>this.b : number
+>this : typeof foo2
+>b : number
+        }
+    }
+
+    static b = 1;
+>b : number
+>1 : 1
+}
diff --git a/tests/cases/conformance/classes/classStaticBlock/classStaticBlock6.ts b/tests/cases/conformance/classes/classStaticBlock/classStaticBlock6.ts
index cdd0cda2fe7af..fd5301fa1d79c 100644
--- a/tests/cases/conformance/classes/classStaticBlock/classStaticBlock6.ts
+++ b/tests/cases/conformance/classes/classStaticBlock/classStaticBlock6.ts
@@ -60,3 +60,14 @@ function foo1 () {
         }
     }
 }
+
+class foo2 {
+    static {
+        this.b  // should error
+        if (1) {
+            this.b; // should error
+        }
+    }
+
+    static b = 1;
+}
\ No newline at end of file

From c03698954d7cd489eb697bc7e443ea02da0da9bf Mon Sep 17 00:00:00 2001
From: Zzzen <callmetsing@gmail.com>
Date: Sun, 20 Mar 2022 15:20:32 +0800
Subject: [PATCH 3/7] simplify implementation

---
 src/compiler/checker.ts                       | 24 +++++--------------
 .../reference/classStaticBlock6.errors.txt    |  7 +++---
 .../baselines/reference/classStaticBlock6.js  |  2 ++
 .../reference/classStaticBlock6.symbols       | 16 +++++++++----
 .../reference/classStaticBlock6.types         |  6 +++++
 .../classStaticBlock/classStaticBlock6.ts     |  1 +
 6 files changed, 30 insertions(+), 26 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 07f6c2dcd648a..c7eb82d78ce4c 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -25347,7 +25347,7 @@ 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, /* ignoreArrowFunctions */true)) {
+                if (isInPropertyInitializerOrClassStaticBlock(node, /* ignoreArrowFunctions */ true)) {
                     error(node, Diagnostics.arguments_cannot_be_referenced_in_property_initializers_or_class_static_initialization_block);
                     return errorType;
                 }
@@ -28874,28 +28874,16 @@ namespace ts {
                 switch (node.kind) {
                     case SyntaxKind.PropertyDeclaration:
                     case SyntaxKind.ClassStaticBlockDeclaration:
-                            return true;
-                    case SyntaxKind.PropertyAssignment:
-                    case SyntaxKind.MethodDeclaration:
-                    case SyntaxKind.GetAccessor:
-                    case SyntaxKind.SetAccessor:
-                    case SyntaxKind.SpreadAssignment:
-                    case SyntaxKind.ComputedPropertyName:
-                    case SyntaxKind.TemplateSpan:
-                    case SyntaxKind.JsxExpression:
-                    case SyntaxKind.JsxAttribute:
-                    case SyntaxKind.JsxAttributes:
-                    case SyntaxKind.JsxSpreadAttribute:
-                    case SyntaxKind.JsxOpeningElement:
-                    case SyntaxKind.ExpressionWithTypeArguments:
-                    case SyntaxKind.HeritageClause:
-                        return false;
+                        return true;
+                    case SyntaxKind.TypeQuery:
                     case SyntaxKind.JsxClosingElement:  // already reported in JsxOpeningElement
                         return "quit";
                     case SyntaxKind.ArrowFunction:
                         return ignoreArrowFunctions ? false : "quit";
+                    case SyntaxKind.Block:
+                        return isFunctionLikeDeclaration(node.parent) && node.parent.kind !== SyntaxKind.ArrowFunction ? "quit" : false;
                     default:
-                        return isFunctionLikeDeclaration(node) ? "quit" : false;
+                        return false;
                 }
             });
         }
diff --git a/tests/baselines/reference/classStaticBlock6.errors.txt b/tests/baselines/reference/classStaticBlock6.errors.txt
index eb89e9e71d6f3..3845754e85416 100644
--- a/tests/baselines/reference/classStaticBlock6.errors.txt
+++ b/tests/baselines/reference/classStaticBlock6.errors.txt
@@ -14,7 +14,7 @@ tests/cases/conformance/classes/classStaticBlock/classStaticBlock6.ts(45,17): er
 tests/cases/conformance/classes/classStaticBlock/classStaticBlock6.ts(46,22): error TS1109: Expression expected.
 tests/cases/conformance/classes/classStaticBlock/classStaticBlock6.ts(55,13): error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization block.
 tests/cases/conformance/classes/classStaticBlock/classStaticBlock6.ts(66,14): error TS2729: Property 'b' is used before its initialization.
-tests/cases/conformance/classes/classStaticBlock/classStaticBlock6.ts(68,18): error TS2729: Property 'b' is used before its initialization.
+tests/cases/conformance/classes/classStaticBlock/classStaticBlock6.ts(69,18): error TS2729: Property 'b' is used before its initialization.
 
 
 ==== tests/cases/conformance/classes/classStaticBlock/classStaticBlock6.ts (17 errors) ====
@@ -116,12 +116,13 @@ tests/cases/conformance/classes/classStaticBlock/classStaticBlock6.ts(68,18): er
             this.b  // should error
                  ~
 !!! error TS2729: Property 'b' is used before its initialization.
-!!! related TS2728 tests/cases/conformance/classes/classStaticBlock/classStaticBlock6.ts:72:12: 'b' is declared here.
+!!! related TS2728 tests/cases/conformance/classes/classStaticBlock/classStaticBlock6.ts:73:12: 'b' is declared here.
+            let b: typeof this.b;   // ok
             if (1) {
                 this.b; // should error
                      ~
 !!! error TS2729: Property 'b' is used before its initialization.
-!!! related TS2728 tests/cases/conformance/classes/classStaticBlock/classStaticBlock6.ts:72:12: 'b' is declared here.
+!!! related TS2728 tests/cases/conformance/classes/classStaticBlock/classStaticBlock6.ts:73:12: 'b' is declared here.
             }
         }
     
diff --git a/tests/baselines/reference/classStaticBlock6.js b/tests/baselines/reference/classStaticBlock6.js
index 4e7d7ec7d6376..a7604a3c0bbba 100644
--- a/tests/baselines/reference/classStaticBlock6.js
+++ b/tests/baselines/reference/classStaticBlock6.js
@@ -65,6 +65,7 @@ function foo1 () {
 class foo2 {
     static {
         this.b  // should error
+        let b: typeof this.b;   // ok
         if (1) {
             this.b; // should error
         }
@@ -229,6 +230,7 @@ var foo2 = /** @class */ (function () {
     _a = foo2;
     (function () {
         _a.b; // should error
+        var b; // ok
         if (1) {
             _a.b; // should error
         }
diff --git a/tests/baselines/reference/classStaticBlock6.symbols b/tests/baselines/reference/classStaticBlock6.symbols
index 6973287272347..1eb5d8054d312 100644
--- a/tests/baselines/reference/classStaticBlock6.symbols
+++ b/tests/baselines/reference/classStaticBlock6.symbols
@@ -107,18 +107,24 @@ class foo2 {
 
     static {
         this.b  // should error
->this.b : Symbol(foo2.b, Decl(classStaticBlock6.ts, 69, 5))
+>this.b : Symbol(foo2.b, Decl(classStaticBlock6.ts, 70, 5))
 >this : Symbol(foo2, Decl(classStaticBlock6.ts, 61, 1))
->b : Symbol(foo2.b, Decl(classStaticBlock6.ts, 69, 5))
+>b : Symbol(foo2.b, Decl(classStaticBlock6.ts, 70, 5))
+
+        let b: typeof this.b;   // ok
+>b : Symbol(b, Decl(classStaticBlock6.ts, 66, 11))
+>this.b : Symbol(foo2.b, Decl(classStaticBlock6.ts, 70, 5))
+>this : Symbol(foo2, Decl(classStaticBlock6.ts, 61, 1))
+>b : Symbol(foo2.b, Decl(classStaticBlock6.ts, 70, 5))
 
         if (1) {
             this.b; // should error
->this.b : Symbol(foo2.b, Decl(classStaticBlock6.ts, 69, 5))
+>this.b : Symbol(foo2.b, Decl(classStaticBlock6.ts, 70, 5))
 >this : Symbol(foo2, Decl(classStaticBlock6.ts, 61, 1))
->b : Symbol(foo2.b, Decl(classStaticBlock6.ts, 69, 5))
+>b : Symbol(foo2.b, Decl(classStaticBlock6.ts, 70, 5))
         }
     }
 
     static b = 1;
->b : Symbol(foo2.b, Decl(classStaticBlock6.ts, 69, 5))
+>b : Symbol(foo2.b, Decl(classStaticBlock6.ts, 70, 5))
 }
diff --git a/tests/baselines/reference/classStaticBlock6.types b/tests/baselines/reference/classStaticBlock6.types
index d899d8bd474ef..970ecfead2015 100644
--- a/tests/baselines/reference/classStaticBlock6.types
+++ b/tests/baselines/reference/classStaticBlock6.types
@@ -130,6 +130,12 @@ class foo2 {
         this.b  // should error
 >this.b : number
 >this : typeof foo2
+>b : number
+
+        let b: typeof this.b;   // ok
+>b : number
+>this.b : number
+>this : typeof foo2
 >b : number
 
         if (1) {
diff --git a/tests/cases/conformance/classes/classStaticBlock/classStaticBlock6.ts b/tests/cases/conformance/classes/classStaticBlock/classStaticBlock6.ts
index fd5301fa1d79c..86b32e979f95b 100644
--- a/tests/cases/conformance/classes/classStaticBlock/classStaticBlock6.ts
+++ b/tests/cases/conformance/classes/classStaticBlock/classStaticBlock6.ts
@@ -64,6 +64,7 @@ function foo1 () {
 class foo2 {
     static {
         this.b  // should error
+        let b: typeof this.b;   // ok
         if (1) {
             this.b; // should error
         }

From 5c37aa3251682f7cc37e3dce9d9c7bf16676f06a Mon Sep 17 00:00:00 2001
From: Zzzen <callmetsing@gmail.com>
Date: Sun, 20 Mar 2022 18:01:20 +0800
Subject: [PATCH 4/7] add tests

---
 ...izerOrStaticInitializationBlock.errors.txt | 19 ++++++++++-
 ...dInitializerOrStaticInitializationBlock.js | 34 +++++++++++++++++++
 ...ializerOrStaticInitializationBlock.symbols | 28 +++++++++++++++
 ...itializerOrStaticInitializationBlock.types | 31 +++++++++++++++++
 ...dInitializerOrStaticInitializationBlock.ts | 14 ++++++++
 5 files changed, 125 insertions(+), 1 deletion(-)

diff --git a/tests/baselines/reference/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.errors.txt b/tests/baselines/reference/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.errors.txt
index 79392677795e2..7d1563d78758f 100644
--- a/tests/baselines/reference/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.errors.txt
+++ b/tests/baselines/reference/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.errors.txt
@@ -11,9 +11,10 @@ tests/cases/compiler/argumentsUsedInClassFieldInitializerOrStaticInitializationB
 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(102,15): error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization block.
 
 
-==== tests/cases/compiler/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts (13 errors) ====
+==== tests/cases/compiler/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts (14 errors) ====
     function A() {
       return class T {
          a = arguments
@@ -138,4 +139,20 @@ tests/cases/compiler/argumentsUsedInClassFieldInitializerOrStaticInitializationB
 !!! error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization block.
       }
     }
+    
+    function D6() {
+      return class T {
+         a = (x = arguments) => {}    // should error
+                  ~~~~~~~~~
+!!! error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization block.
+      }
+    }
+    
+    function D7() {
+      return class T {
+         a(x = arguments){  // ok
+    
+         }
+      }
+    }
     
\ No newline at end of file
diff --git a/tests/baselines/reference/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.js b/tests/baselines/reference/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.js
index 7bd74bee6a14a..7d04f425b2329 100644
--- a/tests/baselines/reference/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.js
+++ b/tests/baselines/reference/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.js
@@ -97,6 +97,20 @@ function D5() {
      a = (() => { return arguments; })()  // should error
   }
 }
+
+function D6() {
+  return class T {
+     a = (x = arguments) => {}    // should error
+  }
+}
+
+function D7() {
+  return class T {
+     a(x = arguments){  // ok
+
+     }
+  }
+}
 
 
 //// [argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.js]
@@ -225,3 +239,23 @@ function D5() {
         return T;
     }());
 }
+function D6() {
+    return /** @class */ (function () {
+        function T() {
+            this.a = function (x) {
+                if (x === void 0) { x = arguments; }
+            }; // should error
+        }
+        return T;
+    }());
+}
+function D7() {
+    return /** @class */ (function () {
+        function T() {
+        }
+        T.prototype.a = function (x) {
+            if (x === void 0) { x = arguments; }
+        };
+        return T;
+    }());
+}
diff --git a/tests/baselines/reference/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.symbols b/tests/baselines/reference/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.symbols
index 13b8ff1f98db5..8aefa5237a0e6 100644
--- a/tests/baselines/reference/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.symbols
+++ b/tests/baselines/reference/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.symbols
@@ -186,3 +186,31 @@ function D5() {
   }
 }
 
+function D6() {
+>D6 : Symbol(D6, Decl(argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts, 97, 1))
+
+  return class T {
+>T : Symbol(T, Decl(argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts, 100, 8))
+
+     a = (x = arguments) => {}    // should error
+>a : Symbol(T.a, Decl(argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts, 100, 18))
+>x : Symbol(x, Decl(argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts, 101, 10))
+>arguments : Symbol(arguments)
+  }
+}
+
+function D7() {
+>D7 : Symbol(D7, Decl(argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts, 103, 1))
+
+  return class T {
+>T : Symbol(T, Decl(argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts, 106, 8))
+
+     a(x = arguments){  // ok
+>a : Symbol(T.a, Decl(argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts, 106, 18))
+>x : Symbol(x, Decl(argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts, 107, 7))
+>arguments : Symbol(arguments)
+
+     }
+  }
+}
+
diff --git a/tests/baselines/reference/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.types b/tests/baselines/reference/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.types
index 9e35c0d31cb2f..8b958c125928d 100644
--- a/tests/baselines/reference/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.types
+++ b/tests/baselines/reference/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.types
@@ -214,3 +214,34 @@ function D5() {
   }
 }
 
+function D6() {
+>D6 : () => typeof T
+
+  return class T {
+>class T {     a = (x = arguments) => {}    // should error  } : typeof T
+>T : typeof T
+
+     a = (x = arguments) => {}    // should error
+>a : (x?: any) => void
+>(x = arguments) => {} : (x?: any) => void
+>x : any
+>arguments : any
+  }
+}
+
+function D7() {
+>D7 : () => typeof T
+
+  return class T {
+>class T {     a(x = arguments){  // ok     }  } : typeof T
+>T : typeof T
+
+     a(x = arguments){  // ok
+>a : (x?: IArguments) => void
+>x : IArguments
+>arguments : IArguments
+
+     }
+  }
+}
+
diff --git a/tests/cases/compiler/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts b/tests/cases/compiler/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts
index b25850652bc55..daeb5438c9f18 100644
--- a/tests/cases/compiler/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts
+++ b/tests/cases/compiler/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts
@@ -96,3 +96,17 @@ function D5() {
      a = (() => { return arguments; })()  // should error
   }
 }
+
+function D6() {
+  return class T {
+     a = (x = arguments) => {}    // should error
+  }
+}
+
+function D7() {
+  return class T {
+     a(x = arguments){  // ok
+
+     }
+  }
+}

From 0276f058ce48382127fa58e9fdcb047ca712f7ce Mon Sep 17 00:00:00 2001
From: Nathan Shively-Sanders <293473+sandersn@users.noreply.github.com>
Date: Mon, 14 Apr 2025 08:11:52 -0700
Subject: [PATCH 5/7] hereby format

---
 src/compiler/checker.ts | 36 ++++++++++++++++++------------------
 1 file changed, 18 insertions(+), 18 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index df8acfde42435..e48a1f2862b5a 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -34335,24 +34335,24 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         }
     }
 
-        function isInPropertyInitializerOrClassStaticBlock(node: Node, ignoreArrowFunctions?: boolean): boolean {
-            return !!findAncestor(node, node => {
-                switch (node.kind) {
-                    case SyntaxKind.PropertyDeclaration:
-                    case SyntaxKind.ClassStaticBlockDeclaration:
-                        return true;
-                    case SyntaxKind.TypeQuery:
-                    case SyntaxKind.JsxClosingElement:  // already reported in JsxOpeningElement
-                        return "quit";
-                    case SyntaxKind.ArrowFunction:
-                        return ignoreArrowFunctions ? false : "quit";
-                    case SyntaxKind.Block:
-                        return isFunctionLikeDeclaration(node.parent) && node.parent.kind !== SyntaxKind.ArrowFunction ? "quit" : false;
-                    default:
-                        return false;
-                }
-            });
-        }
+    function isInPropertyInitializerOrClassStaticBlock(node: Node, ignoreArrowFunctions?: boolean): boolean {
+        return !!findAncestor(node, node => {
+            switch (node.kind) {
+                case SyntaxKind.PropertyDeclaration:
+                case SyntaxKind.ClassStaticBlockDeclaration:
+                    return true;
+                case SyntaxKind.TypeQuery:
+                case SyntaxKind.JsxClosingElement: // already reported in JsxOpeningElement
+                    return "quit";
+                case SyntaxKind.ArrowFunction:
+                    return ignoreArrowFunctions ? false : "quit";
+                case SyntaxKind.Block:
+                    return isFunctionLikeDeclaration(node.parent) && node.parent.kind !== SyntaxKind.ArrowFunction ? "quit" : false;
+                default:
+                    return false;
+            }
+        });
+    }
 
     /**
      * It's possible that "prop.valueDeclaration" is a local declaration, but the property was also declared in a superclass.

From 165e12762a0c44b31fbf7f06e07db5a1c8c6e0c4 Mon Sep 17 00:00:00 2001
From: Zzzen <callmetsing@gmail.com>
Date: Fri, 18 Apr 2025 10:37:17 +0800
Subject: [PATCH 6/7] Update src/compiler/diagnosticMessages.json

Co-authored-by: Jake Bailey <5341706+jakebailey@users.noreply.github.com>
---
 src/compiler/diagnosticMessages.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json
index 75e348388ef22..d137bd53fd1cd 100644
--- a/src/compiler/diagnosticMessages.json
+++ b/src/compiler/diagnosticMessages.json
@@ -3767,7 +3767,7 @@
         "category": "Error",
         "code": 2814
     },
-    "'arguments' cannot be referenced in property initializers or class static initialization block.": {
+    "'arguments' cannot be referenced in property initializers or class static initialization blocks.": {
         "category": "Error",
         "code": 2815
     },

From 1e500821d7044f995360b41092311b66472dc4ca Mon Sep 17 00:00:00 2001
From: Zzzen <callmetsing@gmail.com>
Date: Thu, 1 May 2025 20:18:46 +0800
Subject: [PATCH 7/7] update baselines

---
 src/compiler/checker.ts                       |  2 +-
 ...izerOrStaticInitializationBlock.errors.txt | 44 +++++++++----------
 .../reference/classStaticBlock6.errors.txt    |  8 ++--
 3 files changed, 27 insertions(+), 27 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index e48a1f2862b5a..72055b4b0b832 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -30286,7 +30286,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         // can explicitly bound arguments objects
         if (symbol === argumentsSymbol) {
             if (isInPropertyInitializerOrClassStaticBlock(node, /*ignoreArrowFunctions*/ true)) {
-                error(node, Diagnostics.arguments_cannot_be_referenced_in_property_initializers_or_class_static_initialization_block);
+                error(node, Diagnostics.arguments_cannot_be_referenced_in_property_initializers_or_class_static_initialization_blocks);
                 return;
             }
 
diff --git a/tests/baselines/reference/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.errors.txt b/tests/baselines/reference/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.errors.txt
index 99da57353f738..f382004c03e37 100644
--- a/tests/baselines/reference/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.errors.txt
+++ b/tests/baselines/reference/argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.errors.txt
@@ -1,15 +1,15 @@
-argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(3,10): error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization block.
-argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(9,10): error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization block.
-argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(15,15): error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization block.
-argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(21,15): error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization block.
-argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(33,16): error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization block.
-argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(40,7): error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization block.
-argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(42,16): error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization block.
+argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(3,10): error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization blocks.
+argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(9,10): error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization blocks.
+argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(15,15): error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization blocks.
+argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(21,15): error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization blocks.
+argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(33,16): error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization blocks.
+argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(40,7): error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization blocks.
+argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(42,16): error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization blocks.
 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.
-argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(75,7): error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization block.
-argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(77,9): error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization block.
-argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(96,26): error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization block.
-argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(102,15): error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization block.
+argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(75,7): error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization blocks.
+argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(77,9): error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization blocks.
+argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(96,26): error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization blocks.
+argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(102,15): error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization blocks.
 
 
 ==== argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts (12 errors) ====
@@ -17,7 +17,7 @@ argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(102,15): erro
       return class T {
          a = arguments
              ~~~~~~~~~
-!!! error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization block.
+!!! error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization blocks.
       }
     }
     
@@ -25,7 +25,7 @@ argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(102,15): erro
       return new class T {
          a = arguments
              ~~~~~~~~~
-!!! error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization block.
+!!! error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization blocks.
       }
     }
     
@@ -33,7 +33,7 @@ argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(102,15): erro
       return class T {
          a = { b: arguments }
                   ~~~~~~~~~
-!!! error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization block.
+!!! error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization blocks.
       }
     }
     
@@ -41,7 +41,7 @@ argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(102,15): erro
       return new class T {
          a = { b: arguments }
                   ~~~~~~~~~
-!!! error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization block.
+!!! error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization blocks.
       }
     }
     
@@ -55,7 +55,7 @@ argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(102,15): erro
       return class T {
          a = () => arguments  // should error
                    ~~~~~~~~~
-!!! error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization block.
+!!! error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization blocks.
       }
     }
     
@@ -64,11 +64,11 @@ argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(102,15): erro
         a = () => {
           arguments;    // should error
           ~~~~~~~~~
-!!! error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization block.
+!!! error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization blocks.
           const b = () => {
             return arguments;     // should error
                    ~~~~~~~~~
-!!! error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization block.
+!!! error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization blocks.
           }
     
           function f() {
@@ -105,11 +105,11 @@ argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(102,15): erro
         static {
           arguments;  // should error
           ~~~~~~~~~
-!!! error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization block.
+!!! error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization blocks.
           while(1) {
             arguments // should error
             ~~~~~~~~~
-!!! error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization block.
+!!! error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization blocks.
           }
         }
       }
@@ -130,7 +130,7 @@ argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(102,15): erro
       return class T {
          a = (() => { return arguments; })()  // should error
                              ~~~~~~~~~
-!!! error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization block.
+!!! error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization blocks.
       }
     }
     
@@ -138,7 +138,7 @@ argumentsUsedInClassFieldInitializerOrStaticInitializationBlock.ts(102,15): erro
       return class T {
          a = (x = arguments) => {}    // should error
                   ~~~~~~~~~
-!!! error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization block.
+!!! error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization blocks.
       }
     }
     
diff --git a/tests/baselines/reference/classStaticBlock6.errors.txt b/tests/baselines/reference/classStaticBlock6.errors.txt
index a99d0367b6640..321325c296527 100644
--- a/tests/baselines/reference/classStaticBlock6.errors.txt
+++ b/tests/baselines/reference/classStaticBlock6.errors.txt
@@ -7,12 +7,12 @@ classStaticBlock6.ts(18,9): error TS18037: 'await' expression cannot be used ins
 classStaticBlock6.ts(18,14): error TS1109: Expression expected.
 classStaticBlock6.ts(19,9): error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors.
 classStaticBlock6.ts(32,17): error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors.
-classStaticBlock6.ts(41,13): error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization block.
+classStaticBlock6.ts(41,13): error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization blocks.
 classStaticBlock6.ts(42,13): error TS18037: 'await' expression cannot be used inside a class static block.
 classStaticBlock6.ts(42,18): error TS1109: Expression expected.
 classStaticBlock6.ts(45,17): error TS2522: The 'arguments' object cannot be referenced in an async function or method in ES5. Consider using a standard function or method.
 classStaticBlock6.ts(46,22): error TS1109: Expression expected.
-classStaticBlock6.ts(55,13): error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization block.
+classStaticBlock6.ts(55,13): error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization blocks.
 classStaticBlock6.ts(66,14): error TS2729: Property 'b' is used before its initialization.
 classStaticBlock6.ts(69,18): error TS2729: Property 'b' is used before its initialization.
 
@@ -78,7 +78,7 @@ classStaticBlock6.ts(69,18): error TS2729: Property 'b' is used before its initi
             static {
                 arguments;
                 ~~~~~~~~~
-!!! error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization block.
+!!! error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization blocks.
                 await;
                 ~~~~~
 !!! error TS18037: 'await' expression cannot be used inside a class static block.
@@ -102,7 +102,7 @@ classStaticBlock6.ts(69,18): error TS2729: Property 'b' is used before its initi
             static {
                 arguments;
                 ~~~~~~~~~
-!!! error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization block.
+!!! error TS2815: 'arguments' cannot be referenced in property initializers or class static initialization blocks.
     
                 function ff () {
                     arguments;