Merge pull request #4059 from CamWass:fix-args

PiperOrigin-RevId: 509388769

Author: copybara-github

src/com/google/javascript/jscomp/OptimizeArgumentsArray.java

@@ -149,6 +149,12 @@ public void visit(NodeTraversal traversal, Node node, Node parent) {
    * @param scope scope of the function
    */
   private void tryReplaceArguments(Node scopeRoot) {
+    Node scopeRootParent = scopeRoot.getParent();
+    // Getters cannot have any params, so there are none to replace or synthesize.
+    if (scopeRootParent.isGetterDef()) {
+      return;
+    }
+
     // Find the number of parameters that can be accessed without using `arguments`.
     Node parametersList = NodeUtil.getFunctionParameters(scopeRoot);
     checkState(parametersList.isParamList(), parametersList);
@@ -161,8 +167,14 @@ private void tryReplaceArguments(Node scopeRoot) {
       return;
     }
 
-    ImmutableSortedMap<Integer, String> argNames =
-        assembleParamNames(parametersList, highestIndex + 1);
+    int maxCount = highestIndex + 1;
+    // Setters can only have one param and it is required to be present, so we cannot synthesize any
+    // new params, but we can still replace references to the first param.
+    if (scopeRootParent.isSetterDef()) {
+      maxCount = 1;
+    }
+
+    ImmutableSortedMap<Integer, String> argNames = assembleParamNames(parametersList, maxCount);
     changeMethodSignature(argNames, parametersList);
     changeBody(argNames);
   }

test/com/google/javascript/jscomp/OptimizeArgumentsArrayTest.java

@@ -352,4 +352,33 @@ public void testGlobalArgumentsReferences() {
             "  console.log(arguments);",
             "}"));
   }
+
+  @Test
+  public void testGettersCannotHaveAnyParams() {
+    // Getters cannot have any parameters; synthesizing them would be an error.
+    testSame("class Foo { get prop() { arguments[0] } }");
+    testSame("const a = { get prop() { arguments[0] } }");
+
+    // Ensure references in nested functions are still eligible.
+    test(
+        "class Foo { get prop() { function f(  ) { arguments[0] } } }", //
+        "class Foo { get prop() { function f(p0) {           p0 } } }");
+  }
+
+  @Test
+  public void testSettersCanOnlyHaveOneParam() {
+    // Setters can only have one parameter; synthesizing any more would be an error.
+    testSame("class Foo { set prop(x) { arguments[1] } }");
+    testSame("const a = { set prop(x) { arguments[1] } }");
+
+    // We can still replace references to the first param.
+    test(
+        "class Foo { set prop(x) { arguments[0]; arguments[1] } }", //
+        "class Foo { set prop(x) {            x; arguments[1] } }");
+
+    // Ensure references in nested functions are still eligible.
+    test(
+        "class Foo { set prop(x) { function f(  ) { arguments[0] } } }", //
+        "class Foo { set prop(x) { function f(p0) {           p0 } } }");
+  }
 }