Fix how JSCompiler parses TTL expressions and modifies their lineno/charno

#### How does JSCompiler currently parse TTL expressions?
JSDocInfoParser envokes a TTL parser which adjusts all the lineno/charno within JSDocs to the lineno/charno that the TTL should have within the source JS file.

This doesn't work because the TTL parser is using the lineno/charno of the "@" in the "@template" JSDoc annotation and trying to add this lineno/charno to all nodes within the TTL ast.

If the TTL spans multiple lines, the charno of the "@" is not the right number to add/adjust by. Also in some cases we need to use a 0-indexed lineno and other cases a 1-indexed lineno within the JSDoc to get things working.

Currently, we set wrong lineno/charno to TTL ast nodes, and things work without errors by luck. When we need to print an error/warning message pointing to something in the TTL expression, there is a good chance the lineno/charno are inaccurate and the compiler crashes with a `String index out of bounds exception`

#### What does this change do?
Any time an error occurs within a TTL expression, show the error message with an error location pointing to the @template. This means every node in the TTL ast will have the same line/charno as that of the “@” and a length of 9 (length of “@template”). This means error messages within a TTL expression will be logged as:

#### How will error messages look now?
The `@template` will be underlined with `^` when an error occurs in the TTL expression. E.g:
```
WARNING: test.js:3:3: WARNING - [TYPENAME_UNDEFINED] Reference to an unknown type name q
  3|  * @template Q := cond(isUnknown(T), 'q', T) =:
        ^^^^^^^^^
```
PiperOrigin-RevId: 500274723

Author: rahul-kamat

src/com/google/javascript/jscomp/parsing/TypeTransformationParser.java

@@ -41,6 +41,9 @@ public final class TypeTransformationParser {
   private final int templateCharno;
 
   private static final int VAR_ARGS = Integer.MAX_VALUE;
+  // Set the length of every TTL node as the length of "@template" (which is 9).
+  // This is used for error message logging where we underline the error location with ^^^^^^^^^.
+  private static final int TTL_NODE_LENGTH = "@template".length();
 
   /** The classification of the keywords */
   public static enum OperationKind {
@@ -275,16 +278,31 @@ public boolean parseTypeTransformation() {
       // No need to add a new warning because the validation does it
       return false;
     }
-    fixLineNumbers(expr);
+    fixTTLNodeLineNoCharNoAndLength(expr);
     // Store the result if the AST is valid
     typeTransformationAst = expr;
     return true;
   }
 
-  private void fixLineNumbers(Node expr) {
-    expr.setLinenoCharno(expr.getLineno() + templateLineno, expr.getCharno() + templateCharno);
+  /**
+   * Set the lineno/charno of the TTL node to the lineno/charno of the "@" in the JSDoc's template
+   * annotation. This lineno/charno of the "@" is initialized by JsDocInfoParser when parsing TTLs.
+   *
+   * <p>The TTL AST currently has lineno/charno relative to its position within the JSDoc, and
+   * `fixTTLNodeLineNoCharNoAndLength` changes this to be relative to its position in the source JS
+   * file.
+   *
+   * <p>We are using the lineno/charno of "@" because adjusting the TTL AST node's lineno/charno to
+   * be more accurate is tricky, especially for handling multiline TTL expressions. If we set an
+   * inaccurate lineno/charno, the compiler may crash with an "index out of bounds" error when
+   * logging errors that occur in the TTL expression. Instead, we will use the lineno/charno of "@"
+   * to safely highlight which JSDoc annotation an error occurs in.
+   */
+  private void fixTTLNodeLineNoCharNoAndLength(Node expr) {
+    expr.setLinenoCharno(templateLineno, templateCharno);
+    expr.setLength(TTL_NODE_LENGTH);
     for (Node child = expr.getFirstChild(); child != null; child = child.getNext()) {
-      fixLineNumbers(child);
+      fixTTLNodeLineNoCharNoAndLength(child);
     }
   }
 

test/com/google/javascript/jscomp/parsing/JsDocInfoParserTest.java

@@ -3910,14 +3910,31 @@ public void testBug16129690() {
   }
 
   @Test
-  public void testTTLLineNumber() {
+  public void testTTLLineNoCharNo() {
     JSDocInfo info =
         parse(
             LINE_JOINER.join(
-                "Some text on line 1", "More text! This is line 2", "@template T := foo =:*/"));
+                "Some text on line 0", "More text! This is line 1", "@template T := foo =:*/"));
     assertThat(info.getTypeTransformations()).hasSize(1);
     Node n = info.getTypeTransformations().get("T");
-    assertNode(n).hasLineno(3);
+    assertNode(n).hasLineno(2); // lineno of "@" in "@template"
+    assertNode(n).hasCharno(0); // charno of "@" in "@template"
+  }
+
+  @Test
+  public void testMultilineTTLLineNoCharNo() {
+    JSDocInfo info =
+        parse(
+            LINE_JOINER.join(
+                "Some text on line 0",
+                "More text! This is line 1",
+                "@template T :=",
+                "  foo",
+                "=:*/"));
+    assertThat(info.getTypeTransformations()).hasSize(1);
+    Node n = info.getTypeTransformations().get("T");
+    assertNode(n).hasLineno(2); // lineno of "@" in "@template"
+    assertNode(n).hasCharno(0); // charno of "@" in "@template"
   }
 
   @Test