Fix incorrect error location for some missing goog.require warnings.

This change fixes a bug where the "missing require" compiler warning pointed to the wrong location in the code. For an expression like `dom.TagName.B`, the warning incorrectly highlighted the entire expression instead of just the part with the missing dependency, `dom.TagName`.

The fix addresses two distinct issues:
1. For qualified names in code, the pass now correctly traverses the `GETPROP` tree to find the specific sub-expression that matches the missing namespace.
2. For qualified names in JSDoc, the pass now calculates the correct length of the missing namespace prefix to ensure the error highlight is accurate.

This change also includes a variety of unit tests for edge cases and to verify the correctness of the new `getComponentCount` implementations.

PiperOrigin-RevId: 800515083

Author: concavelenz

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

@@ -506,7 +506,13 @@ private void checkMissingRequireThroughShortNameInGoogScope(
         }
       }
       checkNormalizedShortNameImport(
-          t, n, currentFile, originalImport, normalizedQualifiedName, referenceStrength);
+          t,
+          n,
+          currentFile,
+          originalImport,
+          qualifiedName,
+          normalizedQualifiedName,
+          referenceStrength);
       return;
     }
 
@@ -529,7 +535,13 @@ private void checkMissingRequireThroughShortNameInGoogScope(
     }
     QualifiedName normalizedQualifiedName = swapRootOfQualifiedName(qualifiedName, aliasedName);
     checkNormalizedShortNameImport(
-        t, n, currentFile, originalImport, normalizedQualifiedName, referenceStrength);
+        t,
+        n,
+        currentFile,
+        originalImport,
+        qualifiedName,
+        normalizedQualifiedName,
+        referenceStrength);
   }
 
   private void checkMissingRequireThroughShortNameInModule(
@@ -558,14 +570,21 @@ private void checkMissingRequireThroughShortNameInModule(
     QualifiedName normalizeQualifiedName = normalizeQualifiedNamePlusImport(qualifiedName, require);
 
     checkNormalizedShortNameImport(
-        t, n, currentFile, originalRequiredFile, normalizeQualifiedName, referenceStrength);
+        t,
+        n,
+        currentFile,
+        originalRequiredFile,
+        qualifiedName,
+        normalizeQualifiedName,
+        referenceStrength);
   }
 
   private void checkNormalizedShortNameImport(
       NodeTraversal t,
       Node n,
       ModuleMetadata currentFile,
       ModuleMetadata originalImport,
+      QualifiedName originalQualifiedName,
       QualifiedName normalizedQualifiedName,
       Strength referenceStrength) {
     // TESTCASES, where A.B should not be used through A:
@@ -620,7 +639,33 @@ private void checkNormalizedShortNameImport(
                   ? MISSING_REQUIRE_IN_GOOG_SCOPE
                   : MISSING_REQUIRE_TYPE_IN_GOOG_SCOPE;
         }
-        t.report(n, toReport, namespace);
+
+        Node errorNode = n;
+        // Get the right location if it is a code reference.
+        int diff = normalizedQualifiedName.getComponentCount() - subName.getComponentCount();
+        if (n.isQualifiedName()) {
+          for (int i = 0; i < diff && errorNode.isGetProp(); i++) {
+            errorNode = errorNode.getFirstChild();
+          }
+          t.report(NodeUtil.getRootOfQualifiedName(errorNode), errorNode, toReport, namespace);
+        } else {
+          // JSDoc reference case
+          // Trim the original qualified name from the source text by the same difference.
+          QualifiedName errorQName = originalQualifiedName;
+          for (int i = 0; i < diff; i++) {
+            errorQName = errorQName.getOwner();
+          }
+
+          String correctName = errorQName.join();
+          // For JSDoc, the entire qualified name is a single STRINGLIT node.
+          // To report the error on the correct sub-expression, we create a new
+          // temporary node with the correct string and length.
+          Node newErrorNode = n.cloneNode();
+          newErrorNode.setString(correctName);
+          newErrorNode.setLength(correctName.length());
+
+          t.report(newErrorNode, toReport, namespace);
+        }
       }
 
       // We found the imported namespace: done

src/com/google/javascript/rhino/QualifiedName.java

@@ -128,6 +128,8 @@ public String join() {
     return sb.toString();
   }
 
+  public abstract int getComponentCount();
+
   /**
    * Returns a new qualified name object with {@code this} name as the owner and the given string as
    * the property name.
@@ -176,6 +178,11 @@ public Iterable<String> components() {
       return terms.subList(0, size);
     }
 
+    @Override
+    public int getComponentCount() {
+      return size;
+    }
+
     @Override
     public boolean matches(Node n) {
       int pos = size - 1;
@@ -237,6 +244,11 @@ public boolean matches(Node n) {
           && RhinoStringPool.uncheckedEquals(n.getString(), prop)
           && owner.matches(n.getFirstChild());
     }
+
+    @Override
+    public int getComponentCount() {
+      return owner.getComponentCount() + 1;
+    }
   }
 
   /**
@@ -284,6 +296,17 @@ public String join() {
     public boolean matches(Node n) {
       return n.matchesQualifiedName(node);
     }
+
+    @Override
+    public int getComponentCount() {
+      int count = 1;
+      Node current = this.node;
+      while (current.isGetProp()) {
+        count++;
+        current = current.getFirstChild();
+      }
+      return count;
+    }
   }
 
   private static final String THIS = RhinoStringPool.addOrGet("this");

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

@@ -835,6 +835,67 @@ public void testWarning_missingRequireType_nestedProvideIndirectRef() throws Exc
         """);
   }
 
+  @Test
+  public void testIndirectNamespaceRef_errorLocation() {
+    test(
+        srcs(
+            "goog.provide('goog.dom');",
+            "goog.provide('goog.dom.TagName'); goog.dom.TagName = {B: 'b'};",
+            """
+            goog.module('test');
+            const dom = goog.require('goog.dom');
+            const x = dom.TagName.B;
+            """),
+        warning(CheckMissingRequires.INDIRECT_NAMESPACE_REF_REQUIRE)
+            .withMessage(
+                "'goog.dom.TagName' should have its own goog.require.\n"
+                    + "Please add a separate goog.require and use that alias instead.")
+            .withLocation(3, 10, 11));
+  }
+
+  @Test
+  public void testIndirectNamespaceRef_jsdoc_errorLocation() {
+    test(
+        srcs(
+            "goog.provide('goog.dom');",
+            """
+            goog.provide('goog.dom.TagName');
+            /** @const */
+            goog.dom.TagName = {};
+            goog.dom.TagName.C = class {};
+            """,
+            """
+            goog.module('test');
+            const dom = goog.require('goog.dom');
+            /** @type {dom.TagName.C} */
+            const x = null;
+            """),
+        warning(CheckMissingRequires.INDIRECT_NAMESPACE_REF_REQUIRE_TYPE)
+            .withMessage(
+                "'goog.dom.TagName' should have its own goog.requireType.\n"
+                    + "Please add a separate goog.requireType and use that alias instead.")
+            .withLocation(3, 11, 11));
+  }
+
+  @Test
+  public void testIndirectNamespaceRef_jsdoc_errorLocation_withFunction() {
+    test(
+        srcs(
+            "goog.provide('goog.dom');",
+            "goog.provide('goog.dom.TagName'); /** @enum {string} */ goog.dom.TagName = {B: 'b'};",
+            """
+            goog.module('test');
+            const dom = goog.require('goog.dom');
+            /** @type {function(dom.TagName)} */
+            const x = null;
+            """),
+        warning(CheckMissingRequires.INDIRECT_NAMESPACE_REF_REQUIRE_TYPE)
+            .withMessage(
+                "'goog.dom.TagName' should have its own goog.requireType.\n"
+                    + "Please add a separate goog.requireType and use that alias instead.")
+            .withLocation(3, 20, 11));
+  }
+
   @Test
   public void testWarning_missingRequire_nestedModuleIndirectRef() throws Exception {
     checkIndirectNamespaceRefRequireWarning(
@@ -1983,4 +2044,24 @@ private void checkRequireForGoogModuleGetWarning(String namespace, String... js)
         warning(CheckMissingRequires.MISSING_REQUIRE_FOR_GOOG_MODULE_GET)
             .withMessageContaining("'" + namespace + "'"));
   }
+
+  @Test
+  public void testIndirectNamespaceRef_jsdoc_errorLocation_longNamespace() {
+    test(
+        srcs(
+            "goog.provide('goog.dom');",
+            "goog.provide('goog.dom.tags');",
+            "goog.provide('goog.dom.tags.misc'); /** @const */ goog.dom.tags.misc = {FOO: 'foo'};",
+            """
+            goog.module('test');
+            const dom = goog.require('goog.dom');
+            /** @type {dom.tags.misc.FOO} */
+            const x = null;
+            """),
+        warning(CheckMissingRequires.INDIRECT_NAMESPACE_REF_REQUIRE_TYPE)
+            .withMessage(
+                "'goog.dom.tags.misc' should have its own goog.requireType.\n"
+                    + "Please add a separate goog.requireType and use that alias instead.")
+            .withLocation(3, 11, 13)); // dom.tags.misc
+  }
 }

test/com/google/javascript/rhino/QualifiedNameTest.java

@@ -193,4 +193,34 @@ public void testMatch_fromGetprop() {
     assertThat(n.matches(qname(IR.superNode(), "qux"))).isTrue();
     assertThat(n.matches(qname(IR.name("x"), "qux"))).isFalse();
   }
+
+  @Test
+  public void testEdgeCases_fromString() {
+    assertThat(QualifiedName.of("").components()).containsExactly("");
+    assertThat(QualifiedName.of(".").components()).containsExactly("", "");
+    assertThat(QualifiedName.of(".foo.bar").components()).containsExactly("", "foo", "bar");
+    assertThat(QualifiedName.of("foo.bar.").components()).containsExactly("foo", "bar", "");
+    assertThat(QualifiedName.of("foo..bar").components()).containsExactly("foo", "", "bar");
+  }
+
+  @Test
+  public void testGetComponentCount_fromString() {
+    assertThat(QualifiedName.of("foo").getComponentCount()).isEqualTo(1);
+    assertThat(QualifiedName.of("foo.bar").getComponentCount()).isEqualTo(2);
+    assertThat(QualifiedName.of("foo.bar.baz").getComponentCount()).isEqualTo(3);
+  }
+
+  @Test
+  public void testGetComponentCount_fromNode() {
+    assertThat(IR.name("foo").getQualifiedNameObject().getComponentCount()).isEqualTo(1);
+    assertThat(qname(IR.name("foo"), "bar").getQualifiedNameObject().getComponentCount())
+        .isEqualTo(2);
+    assertThat(qname(IR.name("foo"), "bar", "baz").getQualifiedNameObject().getComponentCount())
+        .isEqualTo(3);
+  }
+
+  @Test
+  public void testGetComponentCount_fromGetprop() {
+    assertThat(QualifiedName.of("foo").getprop("bar").getComponentCount()).isEqualTo(2);
+  }
 }