From 3c460737c84bd6f750ae21637f67d03cbdc7516f Mon Sep 17 00:00:00 2001
From: nnaze <nnaze@google.com>
Date: Wed, 10 Jul 2019 17:28:40 -0700
Subject: [PATCH] eliminate more allocations using null logic instead of
 Optional<Node>

-------------
Created by MOE: https://github.com/google/moe
MOE_MIGRATED_REVID=257516547
---
 .../google/javascript/jscomp/NodeUtil.java    | 21 ++++++++++---------
 1 file changed, 11 insertions(+), 10 deletions(-)

diff --git a/src/com/google/javascript/jscomp/NodeUtil.java b/src/com/google/javascript/jscomp/NodeUtil.java
index ae52f0bc478..fa0124572d3 100644
--- a/src/com/google/javascript/jscomp/NodeUtil.java
+++ b/src/com/google/javascript/jscomp/NodeUtil.java
@@ -56,7 +56,6 @@
 import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
-import java.util.Optional;
 import java.util.Set;
 import javax.annotation.Nullable;
 
@@ -4357,33 +4356,35 @@ public static Iterable<Node> preOrderIterable(Node root) {
   private static final class PreOrderIterator extends AbstractIterator<Node> {
 
     private final Predicate<Node> traverseNodePredicate;
-    private Optional<Node> current;
+
+    @Nullable private Node current;
 
     public PreOrderIterator(Node root, Predicate<Node> traverseNodePredicate) {
+      Preconditions.checkNotNull(root);
       this.traverseNodePredicate = traverseNodePredicate;
-      this.current = Optional.of(root);
+      this.current = root;
     }
 
     @Override
     protected Node computeNext() {
-      if (!current.isPresent()) {
+      if (current == null) {
         return endOfData();
       }
 
-      Node returnValue = current.get();
+      Node returnValue = current;
       current = calculateNextNode(returnValue);
       return returnValue;
     }
 
-    private Optional<Node> calculateNextNode(Node currentNode) {
+    @Nullable
+    private Node calculateNextNode(Node currentNode) {
       Preconditions.checkNotNull(currentNode);
 
       // If node does not match the predicate, do not descend into it.
       if (traverseNodePredicate.apply(currentNode)) {
-
         // In prefix order, the next node is the leftmost child.
         if (currentNode.hasChildren()) {
-          return Optional.of(currentNode.getFirstChild());
+          return currentNode.getFirstChild();
         }
       }
 
@@ -4396,13 +4397,13 @@ private Optional<Node> calculateNextNode(Node currentNode) {
       while (currentNode != null) {
         Node next = currentNode.getNext();
         if (next != null) {
-          return Optional.of(next);
+          return next;
         }
 
         currentNode = currentNode.getParent();
       }
 
-      return Optional.empty();
+      return null;
     }
   }