Improve NodeUtil support for optional chains

* Rename some methods to clarify the difference between a chain segment and the
  entire chain.
* Add a method to detect the end of an entire optional chain.

PiperOrigin-RevId: 321683430

Author: brad4d

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

@@ -337,7 +337,7 @@ private static Node findNonconditionalParent(Node subExpression, Node expression
       // result is currently `x?.y.z(subExpression)`, but we want it to be the full sub-chain
       // containing subExpression
       // `x?.y.z(subExpression).p.q`
-      result = NodeUtil.getEndOfOptChainSegment(result);
+      result = NodeUtil.getEndOfOptChain(result);
     }
 
     return result;
@@ -456,7 +456,7 @@ private void extractOptionalChain(Node optChainNode, Node injectionPoint) {
     checkState(NodeUtil.isOptChainNode(optChainNode), optChainNode);
 
     // find the start of the chain & convert it to non-optional
-    final Node optChainStart = NodeUtil.getStartOfOptChainSegment(optChainNode);
+    final Node optChainStart = NodeUtil.getStartOfOptChain(optChainNode);
     optionalToNonOptionalChain(optChainStart);
 
     // Identify or create the statement that will need to go into the if-statement body

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

@@ -1950,79 +1950,49 @@ public static boolean isOptChainNode(Node n) {
    * @param n A node in an optional chain
    * @return The start of the optional chain that `n` is part of.
    */
-  static Node getStartOfOptChainSegment(Node n) {
+  static Node getStartOfOptChain(Node n) {
     checkState(NodeUtil.isOptChainNode(n), n);
     if (n.isOptionalChainStart()) {
       return n;
     }
-    return getStartOfOptChainSegment(n.getFirstChild());
+    return getStartOfOptChain(n.getFirstChild());
   }
 
   /**
-   * Find the end of an optional chain segment.
-   *
-   * <p>Each `?.` ends one segment and starts another.
+   * Find the end of the optional chain.
    *
    * <p>Examples
    *
    * <pre>
-   *   a?.b.c.d   // end is the node with children `a?.b.c` and `d`
-   *   a?.b.c?.d  // given a?.b end is the node with children `a?.b` and `c`
-   *   a?.b.c?.d  // given a?.b.c end is the node with children `a?.b.c` and `d`
-   *   (a?.b.c).d // given a?.b end is the node with children `a?.b` and `c`
+   *   a?.b.c.d   // end is b.c
+   *   a?.b.c?.d  // given a?.b end is b.c
+   *   (a?.b.c).d // given a?.b end is b.c
    * </pre>
    *
    * @param n A node in an optional chain
    * @return The end of the optional chain that `n` is part of.
    */
-  static Node getEndOfOptChainSegment(Node n) {
+  static Node getEndOfOptChain(Node n) {
     checkState(NodeUtil.isOptChainNode(n), n);
-    if (isEndOfOptChainSegment(n)) {
+    if (isEndOfOptChain(n)) {
       return n;
     } else {
-      return getEndOfOptChainSegment(n.getParent());
+      return getEndOfOptChain(n.getParent());
     }
   }
 
-  /**
-   * Is this node the final node of a full optional chain?
-   *
-   * <p>e.g. for `a?.b.c?.d` this method returns true only for the Node with children `a?.b.c` and
-   * `d`. That node is the end of the whole chain, and also represents the whole chain in the AST.
-   */
-  static boolean isEndOfFullOptChain(Node n) {
+  static boolean isEndOfOptChain(Node n) {
     if (NodeUtil.isOptChainNode(n)) {
       Node parent = n.getParent();
-      // the chain continues if this is the first child of another optional chain node
-      return !(NodeUtil.isOptChainNode(parent) && n.isFirstChildOf(parent));
+      return parent == null
+          || !NodeUtil.isOptChainNode(parent)
+          || parent.isOptionalChainStart()
+          // if an optional chain node `n` is also a call's arg or an index into a GETELEM, it will
+          // be the end of its chain
+          // e.g. In `a?.(x?.y.z)`or `a?.[x?.y.z]`, the `x?.y.z` is the end node
+          || !n.isFirstChildOf(parent);
     } else {
-      // not even an optional chain node
-      return false;
-    }
-  }
-
-  /**
-   * Is this node the end of an optional chain segment?
-   *
-   * <p>Each `?.` begins a new segment and ends the previous one, if any. The end of the whole chain
-   * is also the end of its final segment.
-   */
-  static boolean isEndOfOptChainSegment(Node n) {
-    if (!NodeUtil.isOptChainNode(n)) {
       return false;
-    } else {
-      Node parent = n.getParent();
-      // Check for null so this method will work for a disconnected Node.
-      if (parent != null && n.isFirstChildOf(parent) && NodeUtil.isOptChainNode(parent)) {
-        // The parent is a continuation of this optional chain.
-        // If it starts a new segment, then this node is the end of a segment
-        return parent.isOptionalChainStart();
-      } else {
-        // The parent doesn't continue this node's optional chain, though it might be part of a
-        // different one.
-        // e.g. in `a?.(x?.y.z)` the parent of `x?.y.z` is part of a different optional chain.
-        return true;
-      }
     }
   }
 

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

@@ -2336,9 +2336,9 @@ private static class OptChainInfo {
   private FlowScope traverseOptChain(Node n, FlowScope scope) {
     checkArgument(NodeUtil.isOptChainNode(n));
 
-    if (NodeUtil.isEndOfOptChainSegment(n)) {
+    if (NodeUtil.isEndOfOptChain(n)) {
       // Create new optional chain tracking object and push it onto the stack.
-      final Node startOfChain = NodeUtil.getStartOfOptChainSegment(n);
+      final Node startOfChain = NodeUtil.getStartOfOptChain(n);
       OptChainInfo optChainInfo = new OptChainInfo(n, startOfChain);
       optChainArrayDeque.addFirst(optChainInfo);
     }
@@ -2370,10 +2370,10 @@ private FlowScope traverseOptChain(Node n, FlowScope scope) {
       n.setJSType(unknownType);
     }
 
-    if (NodeUtil.isEndOfOptChainSegment(n)) {
+    if (NodeUtil.isEndOfOptChain(n)) {
       // Use the startNode's type to selectively join the executed scope with the unexecuted scope,
       // and update the type assigned to `n` in `setXAfterChildrenTraversed()`
-      final Node startOfChain = NodeUtil.getStartOfOptChainSegment(n);
+      final Node startOfChain = NodeUtil.getStartOfOptChain(n);
 
       // Pop the stack to obtain the current chain.
       OptChainInfo currentChain = optChainArrayDeque.removeFirst();

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

@@ -3729,7 +3729,7 @@ public void isStartOfChain() {
       // `expr?.prop`
       Node optChainGet = IR.startOptChainGetprop(IR.name("expr"), IR.string("prop"));
 
-      assertThat(NodeUtil.getStartOfOptChainSegment(optChainGet)).isEqualTo(optChainGet);
+      assertThat(NodeUtil.getStartOfOptChain(optChainGet)).isEqualTo(optChainGet);
     }
 
     @Test
@@ -3738,7 +3738,7 @@ public void shortChain() {
       Node innerGetProp = IR.startOptChainGetprop(IR.name("expr"), IR.string("pro1"));
       Node outterGetProp = IR.continueOptChainGetprop(innerGetProp, IR.string("prop2"));
 
-      assertThat(NodeUtil.getStartOfOptChainSegment(outterGetProp)).isEqualTo(innerGetProp);
+      assertThat(NodeUtil.getStartOfOptChain(outterGetProp)).isEqualTo(innerGetProp);
     }
 
     @Test
@@ -3750,8 +3750,8 @@ public void mixedChain() {
       Node optCall = IR.continueOptChainCall(optGetProp);
       Node optGetElem = IR.continueOptChainGetelem(optCall, IR.name("prop3"));
 
-      assertThat(NodeUtil.getStartOfOptChainSegment(optGetElem)).isEqualTo(optGetProp);
-      assertThat(NodeUtil.getStartOfOptChainSegment(optCall)).isEqualTo(optGetProp);
+      assertThat(NodeUtil.getStartOfOptChain(optGetElem)).isEqualTo(optGetProp);
+      assertThat(NodeUtil.getStartOfOptChain(optCall)).isEqualTo(optGetProp);
     }
   }
 
@@ -3763,7 +3763,7 @@ public void isEndOfChain() {
       // `expr?.prop`
       Node optChainGet = IR.startOptChainGetprop(IR.name("expr"), IR.string("prop"));
 
-      assertThat(NodeUtil.getEndOfOptChainSegment(optChainGet)).isEqualTo(optChainGet);
+      assertThat(NodeUtil.getEndOfOptChain(optChainGet)).isEqualTo(optChainGet);
     }
 
     @Test
@@ -3775,32 +3775,27 @@ public void isEndOfChain_call_innerChain() {
       Node innerOptChain = optChainCall.getLastChild(); // `x?.y`
       assertThat(innerOptChain.isOptChainGetProp()).isTrue();
       assertThat(innerOptChain.isOptionalChainStart()).isTrue();
-      assertThat(NodeUtil.isEndOfOptChainSegment(innerOptChain)).isTrue();
-      assertThat(NodeUtil.isEndOfFullOptChain(innerOptChain)).isTrue();
+      assertThat(NodeUtil.isEndOfOptChain(innerOptChain)).isTrue();
     }
 
     @Test
     public void isEndOfChain_getProp_innerChain() {
       Node optChainGetProp = parseExpr("a?.b.x?.y");
       assertThat(optChainGetProp.isOptChainGetProp()).isTrue();
       assertThat(optChainGetProp.isOptionalChainStart()).isTrue();
-      assertThat(NodeUtil.isEndOfOptChainSegment(optChainGetProp)).isTrue();
-      assertThat(NodeUtil.isEndOfFullOptChain(optChainGetProp)).isTrue();
+      assertThat(NodeUtil.isEndOfOptChain(optChainGetProp)).isTrue();
 
-      // Check that `a?.b.x` is not the start of the optional chain, but it ends the segment that
-      // starts with `a?.b`.
+      // Check that `a?.b.x` is not the start of optChain, but it ends the chain `a?.b`.
       Node innerOptChain = optChainGetProp.getFirstChild(); // `a?.b.x`
       assertThat(innerOptChain.isOptChainGetProp()).isTrue();
       assertThat(innerOptChain.isOptionalChainStart()).isFalse();
-      assertThat(NodeUtil.isEndOfOptChainSegment(innerOptChain)).isTrue();
-      assertThat(NodeUtil.isEndOfFullOptChain(innerOptChain)).isFalse();
+      assertThat(NodeUtil.isEndOfOptChain(innerOptChain)).isTrue();
 
       // Check that `a?.b` is the start of optChain but not the end
       Node innerMostOptChain = innerOptChain.getFirstChild(); // `a?.b`
       assertThat(innerMostOptChain.isOptChainGetProp()).isTrue();
       assertThat(innerMostOptChain.isOptionalChainStart()).isTrue();
-      assertThat(NodeUtil.isEndOfOptChainSegment(innerMostOptChain)).isFalse();
-      assertThat(NodeUtil.isEndOfFullOptChain(innerMostOptChain)).isFalse();
+      assertThat(NodeUtil.isEndOfOptChain(innerMostOptChain)).isFalse();
     }
 
     @Test
@@ -3813,8 +3808,7 @@ public void isEndOfChain_call_innerChain2() {
       Node innerOptChain = optChainCall.getLastChild();
       assertThat(innerOptChain.isOptChainGetProp()).isTrue();
       assertThat(innerOptChain.isOptionalChainStart()).isTrue();
-      assertThat(NodeUtil.isEndOfOptChainSegment(innerOptChain)).isTrue();
-      assertThat(NodeUtil.isEndOfFullOptChain(innerOptChain)).isTrue();
+      assertThat(NodeUtil.isEndOfOptChain(innerOptChain)).isTrue();
     }
 
     @Test
@@ -3827,15 +3821,13 @@ public void isEndOfChain_callAndGetProp_innerChain() {
       Node optChainCall = optChainGetProp.getFirstChild();
       assertThat(optChainCall.isOptChainCall()).isTrue();
       assertThat(optChainCall.isOptionalChainStart()).isFalse();
-      assertThat(NodeUtil.isEndOfOptChainSegment(optChainCall)).isFalse();
-      assertThat(NodeUtil.isEndOfFullOptChain(optChainCall)).isFalse();
+      assertThat(NodeUtil.isEndOfOptChain(optChainCall)).isFalse();
 
       // Check that `x?.y` is the start and end of the chain
       Node innerOptChain = optChainCall.getLastChild();
       assertThat(innerOptChain.isOptChainGetProp()).isTrue();
       assertThat(innerOptChain.isOptionalChainStart()).isTrue();
-      assertThat(NodeUtil.isEndOfOptChainSegment(innerOptChain)).isTrue();
-      assertThat(NodeUtil.isEndOfFullOptChain(innerOptChain)).isTrue();
+      assertThat(NodeUtil.isEndOfOptChain(innerOptChain)).isTrue();
     }
 
     @Test
@@ -3848,15 +3840,13 @@ public void isEndOfChain_callAndGetProp_innerChain_multipleInnerArgs() {
       Node optChainCall = optChainGetProp.getFirstChild();
       assertThat(optChainCall.isOptChainCall()).isTrue();
       assertThat(optChainCall.isOptionalChainStart()).isFalse();
-      assertThat(NodeUtil.isEndOfOptChainSegment(optChainCall)).isFalse();
-      assertThat(NodeUtil.isEndOfFullOptChain(optChainCall)).isFalse();
+      assertThat(NodeUtil.isEndOfOptChain(optChainCall)).isFalse();
 
       // Check that `x?.y` is the start and end of its chain
       Node innerOptChain = optChainCall.getSecondChild();
       assertThat(innerOptChain.isOptChainGetProp()).isTrue();
       assertThat(innerOptChain.isOptionalChainStart()).isTrue();
-      assertThat(NodeUtil.isEndOfOptChainSegment(innerOptChain)).isTrue();
-      assertThat(NodeUtil.isEndOfFullOptChain(innerOptChain)).isTrue();
+      assertThat(NodeUtil.isEndOfOptChain(innerOptChain)).isTrue();
     }
 
     @Test
@@ -3865,7 +3855,7 @@ public void shortChain() {
       Node innerGetProp = IR.startOptChainGetprop(IR.name("expr"), IR.string("pro1"));
       Node outerGetProp = IR.continueOptChainGetprop(innerGetProp, IR.string("prop2"));
 
-      assertThat(NodeUtil.getEndOfOptChainSegment(innerGetProp)).isEqualTo(outerGetProp);
+      assertThat(NodeUtil.getEndOfOptChain(innerGetProp)).isEqualTo(outerGetProp);
     }
 
     @Test
@@ -3877,7 +3867,7 @@ public void twoChains() {
       Node optCall = IR.continueOptChainCall(optGetProp);
       IR.startOptChainGetelem(optCall, IR.name("prop3"));
 
-      assertThat(NodeUtil.getEndOfOptChainSegment(startOptGetProp)).isEqualTo(optCall);
+      assertThat(NodeUtil.getEndOfOptChain(startOptGetProp)).isEqualTo(optCall);
     }
 
     @Test
@@ -3887,7 +3877,7 @@ public void breakingOutOfOptChain() {
       Node optGetProp = IR.continueOptChainGetprop(startOptGetProp, IR.string("prop2"));
       IR.getprop(optGetProp, IR.string("prop3"));
 
-      assertThat(NodeUtil.getEndOfOptChainSegment(startOptGetProp)).isEqualTo(optGetProp);
+      assertThat(NodeUtil.getEndOfOptChain(startOptGetProp)).isEqualTo(optGetProp);
     }
   }