Restrict goog.callerLocation usage to being a default value in a function's parameter's list

Throw a generic JSC_CALLER_LOCATION_MISUSE_ERROR if `goog.callerLocation` is used anywhere it shouldn't be

PiperOrigin-RevId: 693487657

Author: rahul-kamat

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

@@ -92,33 +92,56 @@ private class FindCallerLocationFunctions extends AbstractPostOrderCallback {
 
     @Override
     public void visit(NodeTraversal t, Node n, Node parent) {
+      if (isGoogCallerLocationMisused(n, parent)) {
+        compiler.report(JSError.make(parent.getParent(), JSC_CALLER_LOCATION_MISUSE_ERROR));
+      }
+
       if (n.isParamList()) {
         visitParamListAndAddCallerLocationFunctionNames(n, t);
       }
-      if (n.isCall()) {
-        // Check for misuse of goog.callerLocation.
-        Node firstChild = n.getFirstChild();
-        if (GOOG_CALLER_LOCATION_QUALIFIED_NAME.matches(firstChild)) {
-          if (!parent.isDefaultValue()) {
-            // Throw an error when goog.callerLocation() is NOT used as a default value in a
-            // function's parameter.
-            compiler.report(JSError.make(firstChild, JSC_CALLER_LOCATION_MISUSE_ERROR));
-          }
-          if (parent.getParent().isStringKey()) {
-            // Throw an error when goog.callerLocation() is used in an object literal.
-            // E.g:
-            // function foo({val1, val2, here = goog.callerLocation()}) {}
-            // The AST for `here = goog.callerLocation()`looks like:
-            // STRING_KEY here (This node tells us we are in an object literal)
-            //   DEFAULT_VALUE
-            //     NAME here 1:26
-            //     CALL 1:33
-            //       GETPROP callerLocation
-            //         NAME goog 1:33
-            compiler.report(JSError.make(parent.getParent(), JSC_CALLER_LOCATION_MISUSE_ERROR));
-          }
+    }
+
+    /**
+     * Checks if `goog.callerLocation` is misused. `goog.callerLocation` should only be used as a
+     * default parameter initializer.
+     *
+     * @param n node to check
+     * @param parent parent node
+     * @return true if goog.callerLocation is misused, false otherwise
+     */
+    private boolean isGoogCallerLocationMisused(Node n, Node parent) {
+      if (!GOOG_CALLER_LOCATION_QUALIFIED_NAME.matches(n)) {
+        // not a `goog.callerLocation` node
+        return false;
+      }
+
+      // Check for misuse of goog.callerLocation.
+      if (parent.isCall() && parent.getParent().isDefaultValue()) {
+        if (parent.getParent().getParent().isStringKey()) {
+          // Throw an error when `goog.callerLocation` is used in an object literal.
+          // E.g:
+          // function foo({val1, val2, here = goog.callerLocation()}) {}
+          // The AST for `here = goog.callerLocation()`looks like:
+          // STRING_KEY here (This node tells us we are in an object literal)
+          //   DEFAULT_VALUE
+          //     NAME here 1:26
+          //     CALL 1:33
+          //       GETPROP callerLocation (This is the node `n` we are currently at)
+          //         NAME goog 1:33
+          return true;
         }
+
+        // `goog.callerLocation` is used correctly as a default value in a function's parameter
+        // list.
+        return false;
+      }
+
+      if (n.getSourceFileName().contains("javascript/closure/base.js")) {
+        return false;
       }
+
+      // `goog.callerLocation` is NOT used as a default value in a function's parameter list.
+      return true;
     }
 
     /**

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

@@ -196,45 +196,59 @@ public void testNoCallerLocationDefaultParameter() {
   }
 
   @Test
-  public void testCallerLocationIsSpecified() {
+  public void testGoogCallerLocationDefinitionInBaseJsDoesNotError() {
+    String baseJsSource =
+        lines(
+            "var goog = goog || {};", //
+            "goog.callerLocation = function() {};");
+    SourceFile baseJs = SourceFile.fromCode("javascript/closure/base.js", baseJsSource);
+    // this code is only allowed in base.js
+    test(srcs(baseJs), expected(baseJs));
+  }
+
+  @Test
+  public void testNoRewritingIfCallerLocationIsSpecified() {
     enableTypeCheck();
     enableParseTypeInfo();
+
+    String baseJsSource =
+        lines(
+            "var goog = goog || {};", //
+            "goog.callerLocation = function() {};");
+    SourceFile baseJs = SourceFile.fromCode("javascript/closure/base.js", baseJsSource);
+
     // no rewriting if CodeLocation is provided as an argument
-    testSame(
+    String codeLocationProvided =
         lines(
-            "var goog = goog || {};",
-            "goog.callerLocation = function() {};",
             "function signal(here = goog.callerLocation()) {}",
-            "const mySignal = signal('path/to/file.ts:25');"));
+            "const mySignal = signal('path/to/file.ts:25');");
+    SourceFile testJs = SourceFile.fromCode("codeLocationProvided.js", codeLocationProvided);
+    testSame(srcs(baseJs, testJs));
 
-    testSame(
+    String codeLocationProvided2 =
         lines(
-            "var goog = goog || {};",
-            "goog.callerLocation = function() {};",
             "function signal(val, here = goog.callerLocation()) {}",
-            "const mySignal = signal(0, xid('path/to/file.ts:25'));"));
+            "const mySignal = signal(0, xid('path/to/file.ts:25'));");
+    SourceFile testJs2 = SourceFile.fromCode("codeLocationProvided2.js", codeLocationProvided2);
+    testSame(srcs(baseJs, testJs2));
 
-    testSame(
+    String codeLocationProvided3 =
         lines(
-            "var goog = goog || {};",
-            "goog.callerLocation = function() {};",
             "function signal(val, here = goog.callerLocation()) {}",
             "const mySignal = signal(",
             "  () => foo() % 2 === 0,",
             "  xid('path/to/file.ts:25'),",
-            ");"));
-  }
+            ");");
+    SourceFile testJs3 = SourceFile.fromCode("codeLocationProvided3.js", codeLocationProvided3);
+    testSame(srcs(baseJs, testJs3));
 
-  @Test
-  public void testCallerLocationIsSpecified_withNonStringArgument() {
-    enableTypeCheck();
     // no rewriting if CodeLocation is provided as an argument, regardless of the type of the arg
-    testSame(
+    String codeLocationProvided4 =
         lines(
-            "var goog = goog || {};",
-            "goog.callerLocation = function() {};",
             "function signal(here = goog.callerLocation()) {}", //
-            "const mySignal = signal(foo());"));
+            "const mySignal = signal(foo());");
+    SourceFile testJs4 = SourceFile.fromCode("codeLocationProvided4.js", codeLocationProvided4);
+    testSame(srcs(baseJs, testJs4));
   }
 
   @Test