NodeUtilTest.java

/*
 * Copyright 2004 The Closure Compiler Authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.google.javascript.jscomp;

import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.base.Preconditions.checkNotNull;
import static com.google.common.base.Preconditions.checkState;
import static com.google.common.truth.Truth.assertThat;
import static com.google.common.truth.Truth.assertWithMessage;
import static com.google.javascript.jscomp.DiagnosticGroups.ES5_STRICT;
import static com.google.javascript.rhino.Token.AWAIT;
import static com.google.javascript.rhino.Token.CALL;
import static com.google.javascript.rhino.Token.CLASS;
import static com.google.javascript.rhino.Token.COMPUTED_PROP;
import static com.google.javascript.rhino.Token.DESTRUCTURING_LHS;
import static com.google.javascript.rhino.Token.FOR_AWAIT_OF;
import static com.google.javascript.rhino.Token.FOR_OF;
import static com.google.javascript.rhino.Token.FUNCTION;
import static com.google.javascript.rhino.Token.GETTER_DEF;
import static com.google.javascript.rhino.Token.MEMBER_FUNCTION_DEF;
import static com.google.javascript.rhino.Token.REST;
import static com.google.javascript.rhino.Token.SCRIPT;
import static com.google.javascript.rhino.Token.SETTER_DEF;
import static com.google.javascript.rhino.Token.SPREAD;
import static com.google.javascript.rhino.Token.THROW;
import static com.google.javascript.rhino.Token.YIELD;
import static com.google.javascript.rhino.testing.NodeSubject.assertNode;
import static java.lang.Boolean.FALSE;
import static java.lang.Boolean.TRUE;

import com.google.common.base.Joiner;
import com.google.common.base.Predicates;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import com.google.javascript.jscomp.AbstractCompiler.LifeCycleStage;
import com.google.javascript.jscomp.CompilerOptions.LanguageMode;
import com.google.javascript.jscomp.parsing.parser.FeatureSet;
import com.google.javascript.jscomp.parsing.parser.util.format.SimpleFormat;
import com.google.javascript.rhino.IR;
import com.google.javascript.rhino.JSDocInfo;
import com.google.javascript.rhino.JSTypeExpression;
import com.google.javascript.rhino.Node;
import com.google.javascript.rhino.Token;
import com.google.javascript.rhino.jstype.TernaryValue;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.function.Function;
import javax.annotation.Nullable;
import org.junit.Test;
import org.junit.experimental.runners.Enclosed;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameter;
import org.junit.runners.Parameterized.Parameters;

/**
 * Tests for NodeUtil.
 *
 * <p>IMPORTANT: Do not put {@code {@literal @}Test} methods directly in this class, they must be
 * inside an inner class or they won't be executed, because we're using the {@code Enclosed} JUnit
 * runner.
 */
@RunWith(Enclosed.class)
public final class NodeUtilTest {

  /** Provides methods for parsing and accessing the compiler used for the parsing. */
  private static class ParseHelper {
    private Compiler compiler = null;

    private Node parse(String js) {
      CompilerOptions options = new CompilerOptions();
      options.setLanguageIn(LanguageMode.ECMASCRIPT_NEXT);

      // To allow octal literals such as 0123 to be parsed.
      options.setStrictModeInput(false);
      options.setWarningLevel(ES5_STRICT, CheckLevel.OFF);

      compiler = new Compiler();
      compiler.initOptions(options);
      Node n = compiler.parseTestCode(js);
      assertThat(compiler.getErrors()).isEmpty();
      return n;
    }

    private Compiler getCompiler() {
      checkNotNull(compiler, "no parse method called yet");
      return compiler;
    }

    private Node parseFirst(Token token, String js) {
      Node rootNode = this.parse(js);
      checkState(rootNode.isScript(), rootNode);
      return token.equals(SCRIPT) ? rootNode : getNode(rootNode, token);
    }
  }

  private static Node parse(String js) {
    return new ParseHelper().parse(js);
  }

  /**
   * Parses {@code js} into an AST and then returns the first Node in pre-traversal order with the
   * given token.
   *
   * <p>TODO(nickreid): Consider an overload that takes a `Predicate` rather than a `Token`.
   */
  private static Node parseFirst(Token token, String js) {
    return new ParseHelper().parseFirst(token, js);
  }

  /** Returns the parsed expression (e.g. returns a NAME given 'a') */
  private static Node parseExpr(String js) {
    Node script = parse("(" + js + ");"); // Parens force interpretation as an expression.
    return script
        .getFirstChild() // EXPR_RESULT
        .getFirstChild(); // expr
  }

  /**
   * Performs a DFS over {@code root} searching for a descendant matching {@code token}.
   *
   * <p>The search doesn't include {@code root}.
   *
   * @return the first matching node
   * @throws AssertionError if no matching node was found.
   */
  // TODO(nickreid): Consider an overload that takes a `Predicate` rather than a `Token`.
  private static Node getNode(Node root, Token token) {
    @Nullable Node result = getNodeOrNull(root, token);
    if (result == null) {
      throw new AssertionError("No " + token + " node found in:\n " + root.toStringTree());
    }
    return result;
  }

  /**
   * Performs a DFS below {@code root} searching for a descendant matching {@code token}.
   *
   * <p>The search doesn't include {@code root}.
   *
   * @return the first matching node, or {@code null} if none match.
   */
  // TODO(nickreid): Consider an overload that takes a `Predicate` rather than a `Token`.
  @Nullable
  private static Node getNodeOrNull(Node root, Token token) {
    for (Node n : root.children()) {
      if (n.getToken() == token) {
        return n;
      }
      Node potentialMatch = getNodeOrNull(n, token);
      if (potentialMatch != null) {
        return potentialMatch;
      }
    }
    return null;
  }

  /**
   * Test the forms of getting a boolean value for a node.
   *
   * <p>The 3 forms differ based on when they decide the value is unknown. See more description on
   * the method definitions.
   *
   * <dl>
   *   <dt>pure
   *   <dd>known only for side-effect free literal(ish) values
   *   <dt>literal
   *   <dd>known for literal(ish) values regardless of side-effects
   *   <dt>impure
   *   <dd>known for literal(ish) values and some simple expressions regardless of side-effects
   * </dl>
   */
  @RunWith(Parameterized.class)
  public static final class BooleanValueTests {

    /** Snippet of JS that will be parsed as an expression. */
    @Parameter(0)
    public String jsExpression;

    /** Expected result of NodeUtil.getLiteralBooleanValue() */
    @Parameter(1)
    public TernaryValue expectedLiteralResult;

    /** Expected result of NodeUtil.getImpureBooleanValue() */
    @Parameter(2)
    public TernaryValue expectedImpureResult;

    @Parameters(name = "\"{0}\" is literal ({1}) impure ({2})")
    public static Iterable<Object[]> cases() {
      return ImmutableList.copyOf(
          new Object[][] {
            // truly literal, side-effect free values are always known
            {"true", TernaryValue.TRUE, TernaryValue.TRUE},
            {"10", TernaryValue.TRUE, TernaryValue.TRUE},
            {"'0'", TernaryValue.TRUE, TernaryValue.TRUE},
            {"/a/", TernaryValue.TRUE, TernaryValue.TRUE},
            {"{}", TernaryValue.TRUE, TernaryValue.TRUE},
            {"[]", TernaryValue.TRUE, TernaryValue.TRUE},
            {"false", TernaryValue.FALSE, TernaryValue.FALSE},
            {"null", TernaryValue.FALSE, TernaryValue.FALSE},
            {"0", TernaryValue.FALSE, TernaryValue.FALSE},
            {"''", TernaryValue.FALSE, TernaryValue.FALSE},
            {"undefined", TernaryValue.FALSE, TernaryValue.FALSE},

            // literals that have side-effects aren't pure
            {"{a:foo()}", TernaryValue.TRUE, TernaryValue.TRUE},
            {"[foo()]", TernaryValue.TRUE, TernaryValue.TRUE},

            // not really literals, but we pretend they are for our purposes
            {"void 0", TernaryValue.FALSE, TernaryValue.FALSE},
            // side-effect keeps this one from being pure
            {"void foo()", TernaryValue.FALSE, TernaryValue.FALSE},
            {"!true", TernaryValue.FALSE, TernaryValue.FALSE},
            {"!false", TernaryValue.TRUE, TernaryValue.TRUE},
            {"!''", TernaryValue.TRUE, TernaryValue.TRUE},
            {"class Klass {}", TernaryValue.TRUE, TernaryValue.TRUE},
            {"new Date()", TernaryValue.TRUE, TernaryValue.TRUE},
            {"b", TernaryValue.UNKNOWN, TernaryValue.UNKNOWN},
            {"-'0.0'", TernaryValue.UNKNOWN, TernaryValue.UNKNOWN},

            // template literals
            {"``", TernaryValue.FALSE, TernaryValue.FALSE},
            {"`definiteLength`", TernaryValue.TRUE, TernaryValue.TRUE},
            {"`${some}str`", TernaryValue.UNKNOWN, TernaryValue.UNKNOWN},

            // non-literal expressions
            {"a=true", TernaryValue.UNKNOWN, TernaryValue.TRUE},
            {"a=false", TernaryValue.UNKNOWN, TernaryValue.FALSE},
            {"a=(false,true)", TernaryValue.UNKNOWN, TernaryValue.TRUE},
            {"a=(true,false)", TernaryValue.UNKNOWN, TernaryValue.FALSE},
            {"a=(false || true)", TernaryValue.UNKNOWN, TernaryValue.TRUE},
            {"a=(true && false)", TernaryValue.UNKNOWN, TernaryValue.FALSE},
            {"a=!(true && false)", TernaryValue.UNKNOWN, TernaryValue.TRUE},
            {"a,true", TernaryValue.UNKNOWN, TernaryValue.TRUE},
            {"a,false", TernaryValue.UNKNOWN, TernaryValue.FALSE},
            {"true||false", TernaryValue.UNKNOWN, TernaryValue.TRUE},
            {"false||false", TernaryValue.UNKNOWN, TernaryValue.FALSE},
            {"true&&true", TernaryValue.UNKNOWN, TernaryValue.TRUE},
            {"true&&false", TernaryValue.UNKNOWN, TernaryValue.FALSE},

            // Assignment ops other than ASSIGN are unknown.
            {"a *= 2", TernaryValue.UNKNOWN, TernaryValue.UNKNOWN},

            // Complex expressions that contain anything other then "=", ",", or "!" are
            // unknown.
            {"2 + 2", TernaryValue.UNKNOWN, TernaryValue.UNKNOWN},

            // assignment values are the RHS
            {"a=1", TernaryValue.UNKNOWN, TernaryValue.TRUE},
            {"a=/a/", TernaryValue.UNKNOWN, TernaryValue.TRUE},
            {"a={}", TernaryValue.UNKNOWN, TernaryValue.TRUE},

            // hooks have impure boolean value if both cases have same impure boolean value
            {"a?true:true", TernaryValue.UNKNOWN, TernaryValue.TRUE},
            {"a?false:false", TernaryValue.UNKNOWN, TernaryValue.FALSE},
            {"a?true:false", TernaryValue.UNKNOWN, TernaryValue.UNKNOWN},
            {"a?true:foo()", TernaryValue.UNKNOWN, TernaryValue.UNKNOWN},
          });
    }

    @Test
    public void getLiteralBooleanValue() {
      assertThat(NodeUtil.getLiteralBooleanValue(parseExpr(jsExpression)))
          .isEqualTo(expectedLiteralResult);
    }

    @Test
    public void getImpureBooleanValue() {
      assertThat(NodeUtil.getImpureBooleanValue(parseExpr(jsExpression)))
          .isEqualTo(expectedImpureResult);
    }
  }

  /**
   * A nested class to allow the `Enclosed` runner to run these tests since it doesn't run tests in
   * the outer class.
   *
   * <p>There's no particular organization to these tests since they were written in JUnit3. Many of
   * them could benefit from being broken out into their own classes.
   */
  @RunWith(JUnit4.class)
  public static final class AssortedTests {
    @Test
    public void testGetNodeByLineCol_1() {
      Node root = parse("var x = 1;");
      assertNode(NodeUtil.getNodeByLineCol(root, 1, 0)).isNull();
      assertNode(NodeUtil.getNodeByLineCol(root, 1, 1)).hasType(Token.VAR);
      assertNode(NodeUtil.getNodeByLineCol(root, 1, 2)).hasType(Token.VAR);
      assertNode(NodeUtil.getNodeByLineCol(root, 1, 5)).hasType(Token.NAME);
      assertNode(NodeUtil.getNodeByLineCol(root, 1, 9)).hasType(Token.NUMBER);
      assertNode(NodeUtil.getNodeByLineCol(root, 1, 11)).hasType(Token.VAR);
    }

    @Test
    public void testGetNodeByLineCol_2() {
      Node root = parse(Joiner.on("\n").join("var x = {};", "x.prop = 123;"));
      assertNode(NodeUtil.getNodeByLineCol(root, 2, 1)).hasType(Token.NAME);
      assertNode(NodeUtil.getNodeByLineCol(root, 2, 2)).hasType(Token.NAME);
      assertNode(NodeUtil.getNodeByLineCol(root, 2, 3)).hasType(Token.STRING);
      assertNode(NodeUtil.getNodeByLineCol(root, 2, 8)).hasType(Token.ASSIGN);
      assertNode(NodeUtil.getNodeByLineCol(root, 2, 11)).hasType(Token.NUMBER);
      assertNode(NodeUtil.getNodeByLineCol(root, 2, 13)).hasType(Token.NUMBER);
      assertNode(NodeUtil.getNodeByLineCol(root, 2, 14)).hasType(Token.EXPR_RESULT);
    }

    @Test
    public void testGetNodeByLineCol_preferLiterals() {
      Node root;

      root = parse("x-5;");
      assertNode(NodeUtil.getNodeByLineCol(root, 1, 2)).hasType(Token.NAME);
      assertNode(NodeUtil.getNodeByLineCol(root, 1, 3)).hasType(Token.NUMBER);

      root = parse(Joiner.on("\n").join("function f(x) {", "  return x||null;", "}"));
      assertNode(NodeUtil.getNodeByLineCol(root, 2, 11)).hasType(Token.NAME);
      assertNode(NodeUtil.getNodeByLineCol(root, 2, 12)).hasType(Token.OR);
      assertNode(NodeUtil.getNodeByLineCol(root, 2, 13)).hasType(Token.NULL);
    }

    @Test
    public void testIsLiteralOrConstValue() {
      assertLiteralAndImmutable(parseExpr("10"));
      assertLiteralAndImmutable(parseExpr("-10"));
      assertLiteralButNotImmutable(parseExpr("[10, 20]"));
      assertLiteralButNotImmutable(parseExpr("{'a': 20}"));
      assertLiteralButNotImmutable(parseExpr("[10, , 1.0, [undefined], 'a']"));
      assertLiteralButNotImmutable(parseExpr("/abc/"));
      assertLiteralAndImmutable(parseExpr("\"string\""));
      assertLiteralAndImmutable(parseExpr("'aaa'"));
      assertLiteralAndImmutable(parseExpr("null"));
      assertLiteralAndImmutable(parseExpr("undefined"));
      assertLiteralAndImmutable(parseExpr("void 0"));
      assertNotLiteral(parseExpr("abc"));
      assertNotLiteral(parseExpr("[10, foo(), 20]"));
      assertNotLiteral(parseExpr("foo()"));
      assertNotLiteral(parseExpr("c + d"));
      assertNotLiteral(parseExpr("{'a': foo()}"));
      assertNotLiteral(parseExpr("void foo()"));
    }

    @Test
    public void testObjectLiteralIsLiteralValue() {
      assertThat(isLiteralValue("{a: 20}")).isTrue();
      assertThat(isLiteralValue("{'a': 20}")).isTrue();
      assertThat(isLiteralValue("{a: function() {}}")).isTrue();
      assertThat(isLiteralValueExcludingFunctions("{a: function() {}}")).isFalse();
      assertThat(isLiteralValue("{a() {}}")).isTrue();
      assertThat(isLiteralValueExcludingFunctions("{a() {}}")).isFalse();
      assertThat(isLiteralValue("{'a'() {}}")).isTrue();
      assertThat(isLiteralValueExcludingFunctions("{'a'() {}}")).isFalse();

      assertThat(isLiteralValue("{['a']: 20}")).isTrue();
      assertThat(isLiteralValue("{[b]: 20}")).isFalse();
      assertThat(isLiteralValue("{['a']() {}}")).isTrue();
      assertThat(isLiteralValue("{[b]() {}}")).isFalse();
      assertThat(isLiteralValueExcludingFunctions("{['a']() {}}")).isFalse();

      assertThat(isLiteralValue("{ get a() { return 0; } }")).isTrue();
      assertThat(isLiteralValue("{ get 'a'() { return 0; } }")).isTrue();
      assertThat(isLiteralValue("{ get ['a']() { return 0; } }")).isTrue();
      assertThat(isLiteralValue("{ get 123() { return 0; } }")).isTrue();
      assertThat(isLiteralValue("{ get [123]() { return 0; } }")).isTrue();
      assertThat(isLiteralValue("{ get [b]() { return 0; } }")).isFalse();
      assertThat(isLiteralValue("{ set a(x) { } }")).isTrue();
      assertThat(isLiteralValue("{ set 'a'(x) { } }")).isTrue();
      assertThat(isLiteralValue("{ set ['a'](x) { } }")).isTrue();
      assertThat(isLiteralValue("{ set 123(x) { } }")).isTrue();
      assertThat(isLiteralValue("{ set [123](x) { } }")).isTrue();
      assertThat(isLiteralValue("{ set [b](x) { } }")).isFalse();
    }

    private boolean isLiteralValueExcludingFunctions(String code) {
      return NodeUtil.isLiteralValue(parseExpr(code), /* includeFunctions */ false);
    }

    private boolean isLiteralValue(String code) {
      return NodeUtil.isLiteralValue(parseExpr(code), /* includeFunctions */ true);
    }

    private void assertLiteralAndImmutable(Node n) {
      assertThat(NodeUtil.isLiteralValue(n, true)).isTrue();
      assertThat(NodeUtil.isLiteralValue(n, false)).isTrue();
      assertThat(NodeUtil.isImmutableValue(n)).isTrue();
    }

    private void assertLiteralButNotImmutable(Node n) {
      assertThat(NodeUtil.isLiteralValue(n, true)).isTrue();
      assertThat(NodeUtil.isLiteralValue(n, false)).isTrue();
      assertThat(NodeUtil.isImmutableValue(n)).isFalse();
    }

    private void assertNotLiteral(Node n) {
      assertThat(NodeUtil.isLiteralValue(n, true)).isFalse();
      assertThat(NodeUtil.isLiteralValue(n, false)).isFalse();
      assertThat(NodeUtil.isImmutableValue(n)).isFalse();
    }

    @Test
    public void testIsStringLiteralStringLiteral() {
      assertThat(NodeUtil.isSomeCompileTimeConstStringValue(parseExpr("'b'"))).isTrue(); // String
    }

    @Test
    public void testIsStringLiteralTemplateNoSubst() {
      assertThat(NodeUtil.isSomeCompileTimeConstStringValue(parseExpr("`b`"))).isTrue(); // Template
    }

    @Test
    public void testIsStringLiteralTemplateWithSubstitution() {
      // Template with substitution
      assertThat(NodeUtil.isSomeCompileTimeConstStringValue(parseExpr("`foo${bar}`"))).isFalse();
    }

    @Test
    public void testIsStringLiteralVariable() {
      assertThat(NodeUtil.isSomeCompileTimeConstStringValue(parseExpr("b"))).isFalse(); // Variable
    }

    @Test
    public void testIsStringLiteralConcatLiterals() {
      assertThat(NodeUtil.isSomeCompileTimeConstStringValue(parseExpr("'b' + 'c'")))
          .isTrue(); // String concatenation
    }

    @Test
    public void testIsStringLiteralConcatLiteralVariable() {
      assertThat(NodeUtil.isSomeCompileTimeConstStringValue(parseExpr("b + 'c'"))).isFalse();
      assertThat(NodeUtil.isSomeCompileTimeConstStringValue(parseExpr("'b' + c"))).isFalse();
    }

    @Test
    public void testIsStringLiteralTernary() {
      assertThat(NodeUtil.isSomeCompileTimeConstStringValue(parseExpr("a ? 'b' : 'c'"))).isTrue();
      assertThat(NodeUtil.isSomeCompileTimeConstStringValue(parseExpr("a ? b : 'c'"))).isFalse();
      assertThat(NodeUtil.isSomeCompileTimeConstStringValue(parseExpr("a ? 'b' : c"))).isFalse();
      assertThat(NodeUtil.isSomeCompileTimeConstStringValue(parseExpr("a ? b : c"))).isFalse();
    }

    @Test
    public void testGetStringValue() {
      assertThat(NodeUtil.getStringValue(parseExpr("true"))).isEqualTo("true");
      assertThat(NodeUtil.getStringValue(parseExpr("10"))).isEqualTo("10");
      assertThat(NodeUtil.getStringValue(parseExpr("1.0"))).isEqualTo("1");

      /* See https://github.com/google/closure-compiler/issues/1262 */
      assertThat(NodeUtil.getStringValue(parseExpr("1.2323919403474454e+21")))
          .isEqualTo("1.2323919403474454e+21");

      assertThat(NodeUtil.getStringValue(parseExpr("'0'"))).isEqualTo("0");
      assertThat(NodeUtil.getStringValue(parseExpr("/a/"))).isNull();
      assertThat(NodeUtil.getStringValue(parseExpr("{}"))).isEqualTo("[object Object]");
      assertThat(NodeUtil.getStringValue(parseExpr("[]"))).isEmpty();
      assertThat(NodeUtil.getStringValue(parseExpr("false"))).isEqualTo("false");
      assertThat(NodeUtil.getStringValue(parseExpr("null"))).isEqualTo("null");
      assertThat(NodeUtil.getStringValue(parseExpr("0"))).isEqualTo("0");
      assertThat(NodeUtil.getStringValue(parseExpr("''"))).isEmpty();
      assertThat(NodeUtil.getStringValue(parseExpr("undefined"))).isEqualTo("undefined");
      assertThat(NodeUtil.getStringValue(parseExpr("void 0"))).isEqualTo("undefined");
      assertThat(NodeUtil.getStringValue(parseExpr("void foo()"))).isEqualTo("undefined");

      assertThat(NodeUtil.getStringValue(parseExpr("NaN"))).isEqualTo("NaN");
      assertThat(NodeUtil.getStringValue(parseExpr("Infinity"))).isEqualTo("Infinity");
      assertThat(NodeUtil.getStringValue(parseExpr("x"))).isNull();

      assertThat(NodeUtil.getStringValue(parseExpr("`Hello`"))).isEqualTo("Hello");
      assertThat(NodeUtil.getStringValue(parseExpr("`Hello ${'foo'}`"))).isEqualTo("Hello foo");
      assertThat(NodeUtil.getStringValue(parseExpr("`Hello ${name}`"))).isNull();
      assertThat(NodeUtil.getStringValue(parseExpr("`${4} bananas`"))).isEqualTo("4 bananas");
      assertThat(NodeUtil.getStringValue(parseExpr("`This is ${true}.`")))
          .isEqualTo("This is true.");
      assertThat(NodeUtil.getStringValue(parseExpr("`${'hello'} ${name}`"))).isNull();
    }

    @Test
    public void testGetArrayStringValue() {
      assertThat(NodeUtil.getStringValue(parseExpr("[]"))).isEmpty();
      assertThat(NodeUtil.getStringValue(parseExpr("['']"))).isEmpty();
      assertThat(NodeUtil.getStringValue(parseExpr("[null]"))).isEmpty();
      assertThat(NodeUtil.getStringValue(parseExpr("[undefined]"))).isEmpty();
      assertThat(NodeUtil.getStringValue(parseExpr("[void 0]"))).isEmpty();
      assertThat(NodeUtil.getStringValue(parseExpr("[NaN]"))).isEqualTo("NaN");
      assertThat(NodeUtil.getStringValue(parseExpr("[,'']"))).isEqualTo(",");
      assertThat(NodeUtil.getStringValue(parseExpr("[[''],[''],['']]"))).isEqualTo(",,");
      assertThat(NodeUtil.getStringValue(parseExpr("[[1.0],[2.0]]"))).isEqualTo("1,2");
      assertThat(NodeUtil.getStringValue(parseExpr("[a]"))).isNull();
      assertThat(NodeUtil.getStringValue(parseExpr("[1,a]"))).isNull();
    }

    @Test
    public void testMayBeObjectLitKey() {
      assertMayBeObjectLitKey(parseExpr("({})"), false);
      assertMayBeObjectLitKey(parseExpr("a"), false);
      assertMayBeObjectLitKey(parseExpr("'a'"), false);
      assertMayBeObjectLitKey(parseExpr("1"), false);
      assertMayBeObjectLitKey(parseExpr("({a: 1})").getFirstChild(), true);
      assertMayBeObjectLitKey(parseExpr("({1: 1})").getFirstChild(), true);
      assertMayBeObjectLitKey(parseExpr("({get a(){}})").getFirstChild(), true);
      assertMayBeObjectLitKey(parseExpr("({set a(b){}})").getFirstChild(), true);
      // returns false for computed properties (b/111621528)
      assertMayBeObjectLitKey(parseExpr("({['a']: 1})").getFirstChild(), false);
      // returns true for non-object-literal keys
      assertMayBeObjectLitKey(parseExpr("({a} = {})").getFirstFirstChild(), true);
      assertMayBeObjectLitKey(parseExpr("(class { a() {} })").getLastChild().getFirstChild(), true);
    }

    @Test
    public void testIsObjectLitKey() {
      assertIsObjectLitKey(parseExpr("({a: 1})").getFirstChild(), true);
      // returns false for computed properties (b/111621528)
      assertMayBeObjectLitKey(parseExpr("({['a']: 1})").getFirstChild(), false);
      // returns false for object patterns
      assertIsObjectLitKey(parseExpr("({a} = {})").getFirstFirstChild(), false);
      assertIsObjectLitKey(parseExpr("(class { a() {} })").getLastChild().getFirstChild(), false);
    }

    private void assertMayBeObjectLitKey(Node node, boolean expected) {
      assertThat(NodeUtil.mayBeObjectLitKey(node)).isEqualTo(expected);
    }

    private void assertIsObjectLitKey(Node node, boolean expected) {
      assertThat(NodeUtil.isObjectLitKey(node)).isEqualTo(expected);
    }

    @Test
    public void testGetFunctionName1() {
      Node parent = parse("function name(){}");
      assertGetNameResult(parent.getFirstChild(), "name");
    }

    @Test
    public void testGetFunctionName2() {
      Node parent = parse("var name = function(){}").getFirstFirstChild();

      assertGetNameResult(parent.getFirstChild(), "name");
    }

    @Test
    public void testGetFunctionName3() {
      Node parent = parse("qualified.name = function(){}").getFirstFirstChild();

      assertGetNameResult(parent.getLastChild(), "qualified.name");
    }

    @Test
    public void testGetFunctionName4() {
      Node parent = parse("var name2 = function name1(){}").getFirstFirstChild();

      assertGetNameResult(parent.getFirstChild(), "name2");
    }

    @Test
    public void testGetFunctionName5() {
      Node n = parse("qualified.name2 = function name1(){}");
      Node parent = n.getFirstFirstChild();

      assertGetNameResult(parent.getLastChild(), "qualified.name2");
    }

    @Test
    public void testGetBestFunctionName1() {
      Node parent = parse("function func(){}");

      assertThat(NodeUtil.getNearestFunctionName(parent.getFirstChild())).isEqualTo("func");
    }

    @Test
    public void testGetBestFunctionName2() {
      Node parent = parse("var obj = {memFunc(){}}").getFirstFirstChild().getFirstFirstChild();

      assertThat(NodeUtil.getNearestFunctionName(parent.getLastChild())).isEqualTo("memFunc");
    }

    @Test
    public void testConstKeywordNamespace() {
      Node decl = parse("const ns = {};").getFirstChild();
      checkState(decl.isConst(), decl);

      Node nameNode = decl.getFirstChild();
      checkState(nameNode.isName(), nameNode);

      assertThat(NodeUtil.isNamespaceDecl(nameNode)).isTrue();
    }

    private void assertGetNameResult(Node function, String name) {
      assertNode(function).hasToken(Token.FUNCTION);
      assertThat(NodeUtil.getName(function)).isEqualTo(name);
    }

    @Test
    public void testContainsFunctionDeclaration() {
      assertThat(NodeUtil.containsFunction(parseExpr("function foo(){}"))).isTrue();
      assertThat(NodeUtil.containsFunction(parseExpr("(b?function(){}:null)"))).isTrue();

      assertThat(NodeUtil.containsFunction(parseExpr("(b?foo():null)"))).isFalse();
      assertThat(NodeUtil.containsFunction(parseExpr("foo()"))).isFalse();
    }

    @Test
    public void testIsFunctionDeclaration() {
      assertThat(NodeUtil.isFunctionDeclaration(parseFirst(FUNCTION, "function foo(){}"))).isTrue();
      assertThat(
              NodeUtil.isFunctionDeclaration(parseFirst(FUNCTION, "class C { constructor() {} }")))
          .isFalse();
      assertThat(NodeUtil.isFunctionDeclaration(parseFirst(FUNCTION, "({ foo() {} })"))).isFalse();
      assertThat(NodeUtil.isFunctionDeclaration(parseFirst(FUNCTION, "var x = function(){}")))
          .isFalse();
      assertThat(NodeUtil.isFunctionDeclaration(parseFirst(FUNCTION, "export function f() {}")))
          .isTrue();
      assertThat(
              NodeUtil.isFunctionDeclaration(parseFirst(FUNCTION, "export default function() {}")))
          .isFalse();
      assertThat(
              NodeUtil.isFunctionDeclaration(
                  parseFirst(FUNCTION, "export default function foo() {}")))
          .isTrue();
      assertThat(
              NodeUtil.isFunctionDeclaration(
                  parseFirst(FUNCTION, "export default (foo) => { alert(foo); }")))
          .isFalse();
    }

    @Test
    public void testIsMethodDeclaration() {
      assertThat(NodeUtil.isMethodDeclaration(parseFirst(FUNCTION, "class C { constructor() {} }")))
          .isTrue();
      assertThat(NodeUtil.isMethodDeclaration(parseFirst(FUNCTION, "class C { a() {} }"))).isTrue();
      assertThat(NodeUtil.isMethodDeclaration(parseFirst(FUNCTION, "class C { static a() {} }")))
          .isTrue();
      assertThat(NodeUtil.isMethodDeclaration(parseFirst(FUNCTION, "({ set foo(v) {} })")))
          .isTrue();
      assertThat(NodeUtil.isMethodDeclaration(parseFirst(FUNCTION, "({ get foo() {} })"))).isTrue();
      assertThat(NodeUtil.isMethodDeclaration(parseFirst(FUNCTION, "({ [foo]() {} })"))).isTrue();
    }

    @Test
    public void testIsClassDeclaration() {
      assertThat(NodeUtil.isClassDeclaration(parseFirst(CLASS, "class Foo {}"))).isTrue();
      assertThat(NodeUtil.isClassDeclaration(parseFirst(CLASS, "var Foo = class {}"))).isFalse();
      assertThat(NodeUtil.isClassDeclaration(parseFirst(CLASS, "var Foo = class Foo{}"))).isFalse();
      assertThat(NodeUtil.isClassDeclaration(parseFirst(CLASS, "export default class Foo {}")))
          .isTrue();
      assertThat(NodeUtil.isClassDeclaration(parseFirst(CLASS, "export class Foo {}"))).isTrue();
      assertThat(NodeUtil.isClassDeclaration(parseFirst(CLASS, "export default class {}")))
          .isFalse();
    }

    private void assertSideEffect(boolean se, String js) {
      ParseHelper helper = new ParseHelper();

      Node n = helper.parse(js);
      assertThat(NodeUtil.mayHaveSideEffects(n.getFirstChild(), helper.getCompiler()))
          .isEqualTo(se);
    }

    private void assertNodeHasSideEffect(boolean se, Token token, String js) {
      ParseHelper helper = new ParseHelper();

      Node node = helper.parseFirst(token, js);
      assertThat(NodeUtil.mayHaveSideEffects(node, helper.getCompiler())).isEqualTo(se);
    }

    private void assertSideEffect(boolean se, String js, boolean globalRegExp) {
      Node n = parse(js);
      Compiler compiler = new Compiler();
      compiler.initCompilerOptionsIfTesting();
      compiler.setHasRegExpGlobalReferences(globalRegExp);
      assertThat(NodeUtil.mayHaveSideEffects(n.getFirstChild(), compiler)).isEqualTo(se);
    }

    @Test
    public void testMayHaveSideEffects_undifferentiatedCases() {
      assertSideEffect(false, "[1]");
      assertSideEffect(false, "[1, 2]");
      assertSideEffect(true, "i++");
      assertSideEffect(true, "[b, [a, i++]]");
      assertSideEffect(true, "i=3");
      assertSideEffect(true, "[0, i=3]");
      assertSideEffect(true, "b()");
      assertSideEffect(true, "[1, b()]");
      assertSideEffect(true, "b.b=4");
      assertSideEffect(true, "b.b--");
      assertSideEffect(true, "i--");
      assertSideEffect(true, "a[0][i=4]");
      assertSideEffect(true, "a += 3");
      assertSideEffect(true, "a, b, z += 4");
      assertSideEffect(true, "a ? c : d++");
      assertSideEffect(true, "a + c++");
      assertSideEffect(true, "a + c - d()");
      assertSideEffect(true, "a + c - d()");

      assertSideEffect(true, "function foo() {}");
      assertSideEffect(true, "class Foo {}");
      assertSideEffect(true, "while(true);");
      assertSideEffect(true, "if(true){a()}");

      assertSideEffect(false, "if(true){a}");
      assertSideEffect(false, "(function() { })");
      assertSideEffect(false, "(function() { i++ })");
      assertSideEffect(false, "[function a(){}]");
      assertSideEffect(false, "(class { })");
      assertSideEffect(false, "(class { method() { i++ } })");
      assertSideEffect(true, "(class { [computedName()]() {} })");
      assertSideEffect(false, "(class { [computedName]() {} })");
      assertSideEffect(false, "(class Foo extends Bar { })");
      assertSideEffect(true, "(class extends foo() { })");

      assertSideEffect(false, "a");
      assertSideEffect(false, "a.b");
      assertSideEffect(false, "a.b.c");
      assertSideEffect(false, "[b, c [d, [e]]]");
      assertSideEffect(false, "({a: x, b: y, c: z})");
      assertSideEffect(false, "({a, b, c})");
      assertSideEffect(false, "/abc/gi");
      assertSideEffect(false, "'a'");
      assertSideEffect(false, "0");
      assertSideEffect(false, "a + c");
      assertSideEffect(false, "'c' + a[0]");
      assertSideEffect(false, "a[0][1]");
      assertSideEffect(false, "'a' + c");
      assertSideEffect(false, "'a' + a.name");
      assertSideEffect(false, "1, 2, 3");
      assertSideEffect(false, "a, b, 3");
      assertSideEffect(false, "(function(a, b) {  })");
      assertSideEffect(false, "a ? c : d");
      assertSideEffect(false, "'1' + navigator.userAgent");

      assertSideEffect(false, "`template`");
      assertSideEffect(false, "`template${name}`");
      assertSideEffect(false, "`${name}template`");
      assertSideEffect(true, "`${naming()}template`");
      assertSideEffect(true, "templateFunction`template`");
      assertSideEffect(true, "st = `${name}template`");
      assertSideEffect(true, "tempFunc = templateFunction`template`");

      assertSideEffect(false, "new RegExp('foobar', 'i')");
      assertSideEffect(true, "new RegExp(SomethingWacky(), 'i')");
      assertSideEffect(false, "new Array()");
      assertSideEffect(false, "new Array");
      assertSideEffect(false, "new Array(4)");
      assertSideEffect(false, "new Array('a', 'b', 'c')");
      assertSideEffect(true, "new SomeClassINeverHeardOf()");
      assertSideEffect(true, "new SomeClassINeverHeardOf()");

      assertSideEffect(false, "({}).foo = 4");
      assertSideEffect(false, "([]).foo = 4");
      assertSideEffect(false, "(function() {}).foo = 4");

      assertSideEffect(true, "this.foo = 4");
      assertSideEffect(true, "a.foo = 4");
      assertSideEffect(true, "(function() { return n; })().foo = 4");
      assertSideEffect(true, "([]).foo = bar()");

      assertSideEffect(false, "undefined");
      assertSideEffect(false, "void 0");
      assertSideEffect(true, "void foo()");
      assertSideEffect(false, "-Infinity");
      assertSideEffect(false, "Infinity");
      assertSideEffect(false, "NaN");

      assertSideEffect(false, "({}||[]).foo = 2;");
      assertSideEffect(false, "(true ? {} : []).foo = 2;");
      assertSideEffect(false, "({},[]).foo = 2;");

      assertSideEffect(true, "delete a.b");

      assertSideEffect(false, "Math.random();");
      assertSideEffect(true, "Math.random(seed);");
      assertSideEffect(false, "[1, 1].foo;");

      assertSideEffect(true, "export var x = 0;");
      assertSideEffect(true, "export let x = 0;");
      assertSideEffect(true, "export const x = 0;");
      assertSideEffect(true, "export class X {};");
      assertSideEffect(true, "export function x() {};");
      assertSideEffect(true, "export {x};");
    }

    @Test
    public void testMayHaveSideEffects_iterableSpread() {
      // ARRAYLIT-SPREAD
      assertSideEffect(false, "[...[]]");
      assertSideEffect(false, "[...[1]]");
      assertSideEffect(true, "[...[i++]]");
      assertSideEffect(false, "[...'string']");
      assertSideEffect(false, "[...`templatelit`]");
      assertSideEffect(false, "[...`templatelit ${safe}`]");
      assertSideEffect(true, "[...`templatelit ${unsafe()}`]");
      assertSideEffect(true, "[...f()]");
      assertSideEffect(true, "[...5]");
      assertSideEffect(true, "[...null]");
      assertSideEffect(true, "[...true]");

      // CALL-SPREAD
      assertSideEffect(false, "Math.sin(...[])");
      assertSideEffect(false, "Math.sin(...[1])");
      assertSideEffect(true, "Math.sin(...[i++])");
      assertSideEffect(false, "Math.sin(...'string')");
      assertSideEffect(false, "Math.sin(...`templatelit`)");
      assertSideEffect(false, "Math.sin(...`templatelit ${safe}`)");
      assertSideEffect(true, "Math.sin(...`templatelit ${unsafe()}`)");
      assertSideEffect(true, "Math.sin(...f())");
      assertSideEffect(true, "Math.sin(...5)");
      assertSideEffect(true, "Math.sin(...null)");
      assertSideEffect(true, "Math.sin(...true)");

      // NEW-SPREAD
      assertSideEffect(false, "new Object(...[])");
      assertSideEffect(false, "new Object(...[1])");
      assertSideEffect(true, "new Object(...[i++])");
      assertSideEffect(false, "new Object(...'string')");
      assertSideEffect(false, "new Object(...`templatelit`)");
      assertSideEffect(false, "new Object(...`templatelit ${safe}`)");
      assertSideEffect(true, "new Object(...`templatelit ${unsafe()}`)");
      assertSideEffect(true, "new Object(...f())");
      assertSideEffect(true, "new Object(...5)");
      assertSideEffect(true, "new Object(...null)");
      assertSideEffect(true, "new Object(...true)");
    }

    @Test
    public void testMayHaveSideEffects_objectSpread() {
      // OBJECT-SPREAD
      assertSideEffect(false, "({...x})");
      assertSideEffect(false, "({...{}})");
      assertSideEffect(false, "({...{a:1}})");
      assertSideEffect(true, "({...{a:i++}})");
      assertSideEffect(true, "({...{a:f()}})");
      assertSideEffect(true, "({...f()})");
    }

    @Test
    public void testMayHaveSideEffects_rest() {
      // REST
      assertNodeHasSideEffect(false, REST, "({...x} = something)");
      // We currently assume all iterable-rests are side-effectful.
      assertNodeHasSideEffect(true, REST, "([...x] = 'safe')");
      assertNodeHasSideEffect(false, REST, "(function(...x) { })");
    }

    @Test
    public void testMayHaveSideEffects_contextSwitch() {
      assertNodeHasSideEffect(true, AWAIT, "async function f() { await 0; }");
      assertNodeHasSideEffect(true, FOR_AWAIT_OF, "(async()=>{ for await (let x of []) {} })");
      assertNodeHasSideEffect(true, THROW, "function f() { throw 'something'; }");
      assertNodeHasSideEffect(true, YIELD, "function* f() { yield 'something'; }");
      assertNodeHasSideEffect(true, YIELD, "function* f() { yield* 'something'; }");
    }

    @Test
    public void testMayHaveSideEffects_enhancedForLoop() {
      // These edge cases are actually side-effect free. We include them to confirm we just give up
      // on enhanced for loops.
      assertSideEffect(true, "for (const x in []) { }");
      assertSideEffect(true, "for (const x of []) { }");
    }

    @Test
    public void testMayHaveSideEffects_computedProp() {
      assertNodeHasSideEffect(false, COMPUTED_PROP, "({[a]: x})");
      assertNodeHasSideEffect(true, COMPUTED_PROP, "({[a()]: x})");
      assertNodeHasSideEffect(true, COMPUTED_PROP, "({[a]: x()})");

      // computed property getters and setters are modeled as COMPUTED_PROP with an
      // annotation to indicate getter or setter.
      assertNodeHasSideEffect(false, COMPUTED_PROP, "({ get [a]() {} })");
      assertNodeHasSideEffect(true, COMPUTED_PROP, "({ get [a()]() {} })");

      assertNodeHasSideEffect(false, COMPUTED_PROP, "({ set [a](x) {} })");
      assertNodeHasSideEffect(true, COMPUTED_PROP, "({ set [a()](x) {} })");
    }

    @Test
    public void testMayHaveSideEffects_classComputedProp() {
      assertNodeHasSideEffect(false, COMPUTED_PROP, "class C { [a]() {} }");
      assertNodeHasSideEffect(true, COMPUTED_PROP, "class C { [a()]() {} }");

      // computed property getters and setters are modeled as COMPUTED_PROP with an
      // annotation to indicate getter or setter.
      assertNodeHasSideEffect(false, COMPUTED_PROP, "class C { get [a]() {} }");
      assertNodeHasSideEffect(true, COMPUTED_PROP, "class C { get [a()]() {} }");

      assertNodeHasSideEffect(false, COMPUTED_PROP, "class C { set [a](x) {} }");
      assertNodeHasSideEffect(true, COMPUTED_PROP, "class C { set [a()](x) {} }");
    }

    @Test
    public void testMayHaveSideEffects_getter() {
      assertNodeHasSideEffect(false, GETTER_DEF, "({ get a() {} })");
      assertNodeHasSideEffect(false, GETTER_DEF, "class C { get a() {} }");
    }

    @Test
    public void testMayHaveSideEffects_setter() {
      assertNodeHasSideEffect(false, SETTER_DEF, "({ set a(x) {} })");
      assertNodeHasSideEffect(false, SETTER_DEF, "class C { set a(x) {} }");
    }

    @Test
    public void testMayHaveSideEffects_method() {
      assertNodeHasSideEffect(false, MEMBER_FUNCTION_DEF, "({ a(x) {} })");
      assertNodeHasSideEffect(false, MEMBER_FUNCTION_DEF, "class C { a(x) {} }");
    }

    @Test
    public void testMayHaveSideEffects_objectMethod() {
      // "toString" and "valueOf" are assumed to be side-effect free
      assertSideEffect(false, "o.toString()");
      assertSideEffect(false, "o.valueOf()");

      // other methods depend on the extern definitions
      assertSideEffect(true, "o.watch()");
    }

    @Test
    public void testMayHaveSideEffects_regExp() {
      // A RegExp Object by itself doesn't have any side-effects
      assertSideEffect(false, "/abc/gi", true);
      assertSideEffect(false, "/abc/gi", false);

      // RegExp instance methods have global side-effects, so whether they are
      // considered side-effect free depends on whether the global properties
      // are referenced.
      assertSideEffect(true, "(/abc/gi).test('')", true);
      assertSideEffect(false, "(/abc/gi).test('')", false);
      assertSideEffect(true, "(/abc/gi).test(a)", true);
      assertSideEffect(false, "(/abc/gi).test(b)", false);

      assertSideEffect(true, "(/abc/gi).exec('')", true);
      assertSideEffect(false, "(/abc/gi).exec('')", false);

      // Some RegExp object method that may have side-effects.
      assertSideEffect(true, "(/abc/gi).foo('')", true);
      assertSideEffect(true, "(/abc/gi).foo('')", false);

      // Try the string RegExp ops.
      assertSideEffect(true, "''.match('a')", true);
      assertSideEffect(false, "''.match('a')", false);
      assertSideEffect(true, "''.match(/(a)/)", true);
      assertSideEffect(false, "''.match(/(a)/)", false);

      assertSideEffect(true, "''.replace('a')", true);
      assertSideEffect(false, "''.replace('a')", false);

      assertSideEffect(true, "''.search('a')", true);
      assertSideEffect(false, "''.search('a')", false);

      assertSideEffect(true, "''.split('a')", true);
      assertSideEffect(false, "''.split('a')", false);

      // Some non-RegExp string op that may have side-effects.
      assertSideEffect(true, "''.foo('a')", true);
      assertSideEffect(true, "''.foo('a')", false);

      // 'a' might be a RegExp object with the 'g' flag, in which case
      // the state might change by running any of the string ops.
      // Specifically, using these methods resets the "lastIndex" if used
      // in combination with a RegExp instance "exec" method.
      assertSideEffect(true, "''.match(a)", true);
      assertSideEffect(true, "''.match(a)", false);

      assertSideEffect(true, "'a'.replace(/a/, function (s) {alert(s)})", false);
      assertSideEffect(false, "'a'.replace(/a/, 'x')", false);
    }

    @Test
    public void testIsFunctionExpression() {
      assertContainsAnonFunc(true, "(function(){})");
      assertContainsAnonFunc(true, "[function a(){}]");
      assertContainsAnonFunc(true, "({x: function a(){}})");
      assertContainsAnonFunc(true, "({[0]: function a() {}})");
      assertContainsAnonFunc(true, "(function a(){})()");
      assertContainsAnonFunc(true, "x = function a(){};");
      assertContainsAnonFunc(true, "var x = function a(){};");
      assertContainsAnonFunc(true, "if (function a(){});");
      assertContainsAnonFunc(true, "while (function a(){});");
      assertContainsAnonFunc(true, "do; while (function a(){});");
      assertContainsAnonFunc(true, "for (function a(){};;);");
      assertContainsAnonFunc(true, "for (;function a(){};);");
      assertContainsAnonFunc(true, "for (;;function a(){});");
      assertContainsAnonFunc(true, "for (p in function a(){});");
      assertContainsAnonFunc(true, "with (function a(){}) {}");
      assertContainsAnonFunc(false, "function a(){}");
      assertContainsAnonFunc(false, "if (x) function a(){};");
      assertContainsAnonFunc(false, "if (x) { function a(){} }");
      assertContainsAnonFunc(false, "if (x); else function a(){};");
      assertContainsAnonFunc(false, "while (x) function a(){};");
      assertContainsAnonFunc(false, "do function a(){} while (0);");
      assertContainsAnonFunc(false, "for (;;) function a(){}");
      assertContainsAnonFunc(false, "for (p in o) function a(){};");
      assertContainsAnonFunc(false, "with (x) function a(){}");
      assertContainsAnonFunc(true, "export default function() {};");
      assertContainsAnonFunc(false, "export default function a() {};");
      assertContainsAnonFunc(false, "export function a() {};");
      assertContainsAnonFunc(false, "class C { a() {} }");
      assertContainsAnonFunc(false, "class C { static a() {} }");
      assertContainsAnonFunc(false, "x = { a() {} }");
      assertContainsAnonFunc(false, "({[0]() {}})");
      assertContainsAnonFunc(false, "({get [0]() {}})");
      assertContainsAnonFunc(false, "({set [0](x) {}})");
    }

    private void assertContainsAnonFunc(boolean expected, String js) {
      Node funcParent = findParentOfFuncOrClassDescendant(parse(js), Token.FUNCTION);
      assertWithMessage("Expected function node in parse tree of: %s", js)
          .that(funcParent)
          .isNotNull();

      Node funcNode = getFuncOrClassChild(funcParent, Token.FUNCTION);
      assertThat(NodeUtil.isFunctionExpression(funcNode)).isEqualTo(expected);
    }

    @Test
    public void testIsClassExpression() {
      assertContainsAnonClass(true, "(class {})");
      assertContainsAnonClass(true, "[class Clazz {}]");
      assertContainsAnonClass(true, "({x: class Clazz {}})");
      assertContainsAnonClass(true, "x = class Clazz {};");
      assertContainsAnonClass(true, "var x = class Clazz {};");
      assertContainsAnonClass(true, "if (class Clazz {});");
      assertContainsAnonClass(true, "while (class Clazz {});");
      assertContainsAnonClass(true, "do; while (class Clazz {});");
      assertContainsAnonClass(true, "for (class Clazz {};;);");
      assertContainsAnonClass(true, "for (;class Clazz {};);");
      assertContainsAnonClass(true, "for (;;class Clazz {});");
      assertContainsAnonClass(true, "for (p in class Clazz {});");
      assertContainsAnonClass(true, "with (class Clazz {}) {}");
      assertContainsAnonClass(false, "class Clazz {}");
      assertContainsAnonClass(false, "if (x) class Clazz {};");
      assertContainsAnonClass(false, "if (x) { class Clazz {} }");
      assertContainsAnonClass(false, "if (x); else class Clazz {};");
      assertContainsAnonClass(false, "while (x) class Clazz {};");
      assertContainsAnonClass(false, "do class Clazz {} while (0);");
      assertContainsAnonClass(false, "for (;;) class Clazz {}");
      assertContainsAnonClass(false, "for (p in o) class Clazz {};");
      assertContainsAnonClass(false, "with (x) class Clazz {}");
      assertContainsAnonClass(true, "export default class {};");
      assertContainsAnonClass(false, "export default class Clazz {};");
      assertContainsAnonClass(false, "export class Clazz {};");
    }

    private void assertContainsAnonClass(boolean expected, String js) {
      Node classParent = findParentOfFuncOrClassDescendant(parse(js), Token.CLASS);
      assertWithMessage("Expected class node in parse tree of: %s", js)
          .that(classParent)
          .isNotNull();
      Node classNode = getFuncOrClassChild(classParent, Token.CLASS);
      assertThat(NodeUtil.isClassExpression(classNode)).isEqualTo(expected);
    }

    private Node findParentOfFuncOrClassDescendant(Node n, Token token) {
      checkArgument(token.equals(Token.CLASS) || token.equals(Token.FUNCTION));
      for (Node c = n.getFirstChild(); c != null; c = c.getNext()) {
        if (c.getToken().equals(token)) {
          return n;
        }
        Node result = findParentOfFuncOrClassDescendant(c, token);
        if (result != null) {
          return result;
        }
      }
      return null;
    }

    private Node getFuncOrClassChild(Node n, Token token) {
      checkArgument(token.equals(Token.CLASS) || token.equals(Token.FUNCTION));
      for (Node c = n.getFirstChild(); c != null; c = c.getNext()) {
        if (c.getToken().equals(token)) {
          return c;
        }
      }
      return null;
    }

    @Test
    public void testContainsType() {
      assertThat(NodeUtil.containsType(parse("this"), Token.THIS)).isTrue();
      assertThat(NodeUtil.containsType(parse("function foo(){}(this)"), Token.THIS)).isTrue();
      assertThat(NodeUtil.containsType(parse("b?this:null"), Token.THIS)).isTrue();

      assertThat(NodeUtil.containsType(parse("a"), Token.THIS)).isFalse();
      assertThat(NodeUtil.containsType(parse("function foo(){}"), Token.THIS)).isFalse();
      assertThat(NodeUtil.containsType(parse("(b?foo():null)"), Token.THIS)).isFalse();
    }

    @Test
    public void testGetNodeTypeReferenceCount() {
      assertThat(
              NodeUtil.getNodeTypeReferenceCount(
                  parse("function foo(){}"), Token.THIS, Predicates.<Node>alwaysTrue()))
          .isEqualTo(0);
      assertThat(
              NodeUtil.getNodeTypeReferenceCount(
                  parse("this"), Token.THIS, Predicates.<Node>alwaysTrue()))
          .isEqualTo(1);
      assertThat(
              NodeUtil.getNodeTypeReferenceCount(
                  parse("this;function foo(){}(this)"), Token.THIS, Predicates.<Node>alwaysTrue()))
          .isEqualTo(2);
    }

    @Test
    public void testIsNameReferenceCount() {
      assertThat(NodeUtil.isNameReferenced(parse("function foo(){}"), "foo")).isTrue();
      assertThat(NodeUtil.isNameReferenced(parse("var foo = function(){}"), "foo")).isTrue();
      assertThat(NodeUtil.isNameReferenced(parse("function foo(){}"), "undefined")).isFalse();
      assertThat(NodeUtil.isNameReferenced(parse("undefined"), "undefined")).isTrue();
      assertThat(
              NodeUtil.isNameReferenced(
                  parse("undefined;function foo(){}(undefined)"), "undefined"))
          .isTrue();

      assertThat(NodeUtil.isNameReferenced(parse("goo.foo"), "goo")).isTrue();
      assertThat(NodeUtil.isNameReferenced(parse("goo.foo"), "foo")).isFalse();
    }

    @Test
    public void testGetNameReferenceCount() {
      assertThat(NodeUtil.getNameReferenceCount(parse("function foo(){}"), "undefined"))
          .isEqualTo(0);
      assertThat(NodeUtil.getNameReferenceCount(parse("undefined"), "undefined")).isEqualTo(1);
      assertThat(
              NodeUtil.getNameReferenceCount(
                  parse("undefined;function foo(){}(undefined)"), "undefined"))
          .isEqualTo(2);

      assertThat(NodeUtil.getNameReferenceCount(parse("goo.foo"), "goo")).isEqualTo(1);
      assertThat(NodeUtil.getNameReferenceCount(parse("goo.foo"), "foo")).isEqualTo(0);
      assertThat(NodeUtil.getNameReferenceCount(parse("function foo(){}"), "foo")).isEqualTo(1);
      assertThat(NodeUtil.getNameReferenceCount(parse("var foo = function(){}"), "foo"))
          .isEqualTo(1);
    }

    @Test
    public void testGetVarsDeclaredInBranch() {
      assertNodeNames(ImmutableSet.of("foo"), NodeUtil.getVarsDeclaredInBranch(parse("var foo;")));
      assertNodeNames(
          ImmutableSet.of("foo", "goo"), NodeUtil.getVarsDeclaredInBranch(parse("var foo,goo;")));
      assertNodeNames(ImmutableSet.<String>of(), NodeUtil.getVarsDeclaredInBranch(parse("foo();")));
      assertNodeNames(
          ImmutableSet.<String>of(),
          NodeUtil.getVarsDeclaredInBranch(parse("function f(){var foo;}")));
      assertNodeNames(
          ImmutableSet.of("goo"),
          NodeUtil.getVarsDeclaredInBranch(parse("var goo;function f(){var foo;}")));
    }

    private void assertNodeNames(Set<String> nodeNames, Collection<Node> nodes) {
      Set<String> actualNames = new HashSet<>();
      for (Node node : nodes) {
        actualNames.add(node.getString());
      }
      assertThat(actualNames).isEqualTo(nodeNames);
    }

    @Test
    public void testIsNonlocalModuleExportNameOnExports1() {
      Node root = parse("export {localName as exportName};");
      Node moduleBody = root.getFirstChild();
      Node exportNode = moduleBody.getFirstChild();
      Node exportSpecs = exportNode.getFirstChild();
      Node exportSpec = exportSpecs.getFirstChild();

      Node localName = exportSpec.getFirstChild();
      Node exportName = exportSpec.getSecondChild();

      assertThat(NodeUtil.isNonlocalModuleExportName(localName)).isFalse();
      assertThat(NodeUtil.isNonlocalModuleExportName(exportName)).isTrue();
    }

    @Test
    public void testIsNonlocalModuleExportNameOnExports2() {
      Node root = parse("let bar; export {bar};");
      Node moduleBody = root.getFirstChild();
      Node exportNode = moduleBody.getSecondChild();
      Node exportSpecs = exportNode.getFirstChild();
      Node exportSpec = exportSpecs.getFirstChild();

      Node name = exportSpec.getFirstChild();

      // bar is defined locally, so isNonlocalModuleExportName is false.
      assertThat(NodeUtil.isNonlocalModuleExportName(name)).isFalse();
    }

    @Test
    public void testIsNonlocalModuleExportNameOnExportFrom() {
      Node root = parse("export {bar as baz} from './foo.js';");
      Node moduleBody = root.getFirstChild();
      Node exportNode = moduleBody.getFirstChild();
      Node exportSpecs = exportNode.getFirstChild();
      Node exportSpec = exportSpecs.getFirstChild();

      Node bar = exportSpec.getFirstChild();
      Node baz = exportSpec.getSecondChild();

      // Neither identifier is defined locally.
      assertThat(NodeUtil.isNonlocalModuleExportName(bar)).isTrue();
      assertThat(NodeUtil.isNonlocalModuleExportName(baz)).isTrue();
    }

    @Test
    public void testIsNonlocalModuleExportNameOnImports1() {
      Node root = parse("import {exportName as localName} from './foo.js';");
      Node moduleBody = root.getFirstChild();
      Node importNode = moduleBody.getFirstChild();
      Node importSpecs = importNode.getSecondChild();
      Node importSpec = importSpecs.getFirstChild();

      Node exportName = importSpec.getFirstChild();
      Node localName = importSpec.getSecondChild();

      assertThat(NodeUtil.isNonlocalModuleExportName(exportName)).isTrue();
      assertThat(NodeUtil.isNonlocalModuleExportName(localName)).isFalse();
    }

    @Test
    public void testIsNonlocalModuleExportNameOnImports2() {
      Node root = parse("import {bar} from './foo.js';");
      Node moduleBody = root.getFirstChild();
      Node importNode = moduleBody.getFirstChild();
      Node importSpecs = importNode.getSecondChild();
      Node importSpec = importSpecs.getFirstChild();

      Node name = importSpec.getSecondChild();

      // bar is defined locally so isNonlocalModuleExportName is false
      assertThat(NodeUtil.isNonlocalModuleExportName(name)).isFalse();
    }

    @Test
    public void testIsControlStructureCodeBlock() {
      Node root = parse("if (x) foo(); else boo();");
      Node ifNode = root.getFirstChild();

      Node ifCondition = ifNode.getFirstChild();
      Node ifCase = ifNode.getSecondChild();
      Node elseCase = ifNode.getLastChild();

      assertThat(NodeUtil.isControlStructureCodeBlock(ifNode, ifCondition)).isFalse();
      assertThat(NodeUtil.isControlStructureCodeBlock(ifNode, ifCase)).isTrue();
      assertThat(NodeUtil.isControlStructureCodeBlock(ifNode, elseCase)).isTrue();
    }

    @Test
    public void testIsFunctionExpression1() {
      Node root = parse("(function foo() {})");
      Node statementNode = root.getFirstChild();
      assertThat(statementNode.isExprResult()).isTrue();
      Node functionNode = statementNode.getFirstChild();
      assertThat(functionNode.isFunction()).isTrue();
      assertThat(NodeUtil.isFunctionExpression(functionNode)).isTrue();
    }

    @Test
    public void testIsFunctionExpression2() {
      Node root = parse("function foo() {}");
      Node functionNode = root.getFirstChild();
      assertThat(functionNode.isFunction()).isTrue();
      assertThat(NodeUtil.isFunctionExpression(functionNode)).isFalse();
    }

    @Test
    public void testRemoveChildBlock() {
      // Test removing the inner block.
      Node actual = parse("{{x()}}");

      Node outerBlockNode = actual.getFirstChild();
      Node innerBlockNode = outerBlockNode.getFirstChild();

      NodeUtil.removeChild(outerBlockNode, innerBlockNode);
      String expected = "{{}}";
      assertNode(parse(expected)).isEqualTo(actual);
    }

    @Test
    public void testRemoveTryChild1() {
      // Test removing the finally clause.
      Node actual = parse("try {foo()} catch(e) {} finally {}");

      Node tryNode = actual.getFirstChild();
      Node finallyBlock = tryNode.getLastChild();

      NodeUtil.removeChild(tryNode, finallyBlock);
      String expected = "try {foo()} catch(e) {}";
      assertNode(parse(expected)).isEqualTo(actual);
    }

    @Test
    public void testRemoveTryChild2() {
      // Test removing the try clause.
      Node actual = parse("try {foo()} catch(e) {} finally {}");

      Node tryNode = actual.getFirstChild();
      Node tryBlock = tryNode.getFirstChild();

      NodeUtil.removeChild(tryNode, tryBlock);
      String expected = "try {} catch(e) {} finally {}";
      assertNode(parse(expected)).isEqualTo(actual);
    }

    @Test
    public void testRemoveTryChild3() {
      // Test removing the catch clause.
      Node actual = parse("try {foo()} catch(e) {} finally {}");

      Node tryNode = actual.getFirstChild();
      Node catchBlocks = tryNode.getSecondChild();
      Node catchBlock = catchBlocks.getFirstChild();

      NodeUtil.removeChild(catchBlocks, catchBlock);
      String expected = "try {foo()} finally {}";
      assertNode(parse(expected)).isEqualTo(actual);
    }

    @Test
    public void testRemoveTryChild4() {
      // Test removing the block that contains the catch clause.
      Node actual = parse("try {foo()} catch(e) {} finally {}");

      Node tryNode = actual.getFirstChild();
      Node catchBlocks = tryNode.getSecondChild();

      NodeUtil.removeChild(tryNode, catchBlocks);
      String expected = "try {foo()} finally {}";
      assertNode(parse(expected)).isEqualTo(actual);
    }

    @Test
    public void testRemoveFromImport() {
      // Remove imported function
      Node actual = parse("import foo from './foo';");
      Node moduleBody = actual.getFirstChild();
      Node importNode = moduleBody.getFirstChild();
      Node functionFoo = importNode.getFirstChild();

      NodeUtil.removeChild(importNode, functionFoo);
      String expected = "import './foo';";
      assertNode(parse(expected)).isEqualTo(actual);
    }

    @Test
    public void testRemoveParamChild1() {
      // Remove traditional parameter
      Node actual = parse("function f(p1) {}");
      Node functionNode = actual.getFirstChild();
      Node paramList = functionNode.getFirstChild().getNext();
      Node p1 = paramList.getFirstChild();

      NodeUtil.removeChild(paramList, p1);
      String expected = "function f() {}";
      assertNode(parse(expected)).isEqualTo(actual);
    }

    @Test
    public void testRemoveParamChild2() {
      // Remove default parameter
      Node actual = parse("function f(p1 = 0, p2) {}");
      Node functionNode = actual.getFirstChild();
      Node paramList = functionNode.getFirstChild().getNext();
      Node p1 = paramList.getFirstChild();

      NodeUtil.removeChild(paramList, p1);
      String expected = "function f(p2) {}";
      assertNode(parse(expected)).isEqualTo(actual);
    }

    @Test
    public void testRemoveVarChild() {
      // Test removing the first child.
      Node actual = parse("var foo, goo, hoo");

      Node varNode = actual.getFirstChild();
      Node nameNode = varNode.getFirstChild();

      NodeUtil.removeChild(varNode, nameNode);
      String expected = "var goo, hoo";
      assertNode(parse(expected)).isEqualTo(actual);

      // Test removing the second child.
      actual = parse("var foo, goo, hoo");

      varNode = actual.getFirstChild();
      nameNode = varNode.getSecondChild();

      NodeUtil.removeChild(varNode, nameNode);
      expected = "var foo, hoo";
      assertNode(parse(expected)).isEqualTo(actual);

      // Test removing the last child of several children.
      actual = parse("var foo, hoo");

      varNode = actual.getFirstChild();
      nameNode = varNode.getSecondChild();

      NodeUtil.removeChild(varNode, nameNode);
      expected = "var foo";
      assertNode(parse(expected)).isEqualTo(actual);

      // Test removing the last.
      actual = parse("var hoo");

      varNode = actual.getFirstChild();
      nameNode = varNode.getFirstChild();

      NodeUtil.removeChild(varNode, nameNode);
      expected = "";
      assertNode(parse(expected)).isEqualTo(actual);
    }

    @Test
    public void testRemoveLetChild() {
      // Test removing the first child.
      Node actual = parse("let foo, goo, hoo");

      Node letNode = actual.getFirstChild();
      Node nameNode = letNode.getFirstChild();

      NodeUtil.removeChild(letNode, nameNode);
      String expected = "let goo, hoo";
      assertNode(parse(expected)).isEqualTo(actual);

      // Test removing the second child.
      actual = parse("let foo, goo, hoo");

      letNode = actual.getFirstChild();
      nameNode = letNode.getSecondChild();

      NodeUtil.removeChild(letNode, nameNode);
      expected = "let foo, hoo";
      assertNode(parse(expected)).isEqualTo(actual);

      // Test removing the last child of several children.
      actual = parse("let foo, hoo");

      letNode = actual.getFirstChild();
      nameNode = letNode.getSecondChild();

      NodeUtil.removeChild(letNode, nameNode);
      expected = "let foo";
      assertNode(parse(expected)).isEqualTo(actual);

      // Test removing the last.
      actual = parse("let hoo");

      letNode = actual.getFirstChild();
      nameNode = letNode.getFirstChild();

      NodeUtil.removeChild(letNode, nameNode);
      expected = "";
      assertNode(parse(expected)).isEqualTo(actual);
    }

    @Test
    public void testRemoveLabelChild1() {
      // Test removing the first child.
      Node actual = parse("foo: goo()");

      Node labelNode = actual.getFirstChild();
      Node callExpressNode = labelNode.getLastChild();

      NodeUtil.removeChild(labelNode, callExpressNode);
      String expected = "";
      assertNode(parse(expected)).isEqualTo(actual);
    }

    @Test
    public void testRemoveLabelChild2() {
      // Test removing the first child.
      Node actual = parse("achoo: foo: goo()");

      Node labelNode = actual.getFirstChild();
      Node callExpressNode = labelNode.getLastChild();

      NodeUtil.removeChild(labelNode, callExpressNode);
      String expected = "";
      assertNode(parse(expected)).isEqualTo(actual);
    }

    @Test
    public void testRemovePatternChild() {
      // remove variable declaration from object pattern
      Node actual = parse("var {a, b, c} = {a:1, b:2, c:3}");
      Node varNode = actual.getFirstChild();
      Node destructure = varNode.getFirstChild();
      Node pattern = destructure.getFirstChild();
      Node a = pattern.getFirstChild();
      Node b = a.getNext();
      Node c = b.getNext();

      NodeUtil.removeChild(pattern, a);
      String expected = "var {b, c} = {a:1, b:2, c:3};";
      assertNode(parse(expected)).isEqualTo(actual);

      // Remove all entries in object pattern
      NodeUtil.removeChild(pattern, b);
      NodeUtil.removeChild(pattern, c);
      expected = "var { } = {a:1, b:2, c:3};";
      assertNode(parse(expected)).isEqualTo(actual);

      // remove variable declaration from array pattern
      actual = parse("var [a, b] = [1, 2]");
      varNode = actual.getFirstChild();
      destructure = varNode.getFirstChild();
      pattern = destructure.getFirstChild();
      a = pattern.getFirstChild();

      NodeUtil.removeChild(pattern, a);
      expected = "var [ , b] = [1, 2];";
      assertNode(parse(expected)).isEqualTo(actual);
    }

    @Test
    public void testRemoveForChild() {
      // Test removing the initializer.
      Node actual = parse("for(var a=0;a<0;a++)foo()");

      Node forNode = actual.getFirstChild();
      Node child = forNode.getFirstChild();

      NodeUtil.removeChild(forNode, child);
      String expected = "for(;a<0;a++)foo()";
      assertNode(parse(expected)).isEqualTo(actual);

      // Test removing the condition.
      actual = parse("for(var a=0;a<0;a++)foo()");

      forNode = actual.getFirstChild();
      child = forNode.getSecondChild();

      NodeUtil.removeChild(forNode, child);
      expected = "for(var a=0;;a++)foo()";
      assertNode(parse(expected)).isEqualTo(actual);

      // Test removing the increment.
      actual = parse("for(var a=0;a<0;a++)foo()");

      forNode = actual.getFirstChild();
      child = forNode.getSecondChild().getNext();

      NodeUtil.removeChild(forNode, child);
      expected = "for(var a=0;a<0;)foo()";
      assertNode(parse(expected)).isEqualTo(actual);

      // Test removing the body.
      actual = parse("for(var a=0;a<0;a++)foo()");

      forNode = actual.getFirstChild();
      child = forNode.getLastChild();

      NodeUtil.removeChild(forNode, child);
      expected = "for(var a=0;a<0;a++);";
      assertNode(parse(expected)).isEqualTo(actual);

      // Test removing the body.
      actual = parse("for(a in ack)foo();");

      forNode = actual.getFirstChild();
      child = forNode.getLastChild();

      NodeUtil.removeChild(forNode, child);
      expected = "for(a in ack);";
      assertNode(parse(expected)).isEqualTo(actual);
    }

    private static void replaceDeclChild(String js, int declarationChild, String expected) {
      Node actual = parse(js);
      Node declarationNode = actual.getFirstChild();
      Node nameNode = declarationNode.getChildAtIndex(declarationChild);

      NodeUtil.replaceDeclarationChild(nameNode, IR.block());
      assertNode(parse(expected)).isEqualTo(actual);
    }

    @Test
    public void testReplaceDeclarationName() {
      replaceDeclChild("var x;", 0, "{}");
      replaceDeclChild("var x, y;", 0, "{} var y;");
      replaceDeclChild("var x, y;", 1, "var x; {}");
      replaceDeclChild("let x, y, z;", 0, "{} let y, z;");
      replaceDeclChild("let x, y, z;", 1, "let x; {} let z;");
      replaceDeclChild("let x, y, z;", 2, "let x, y; {}");
      replaceDeclChild("const x = 1, y = 2, z = 3;", 1, "const x = 1; {} const z = 3;");
      replaceDeclChild(
          "const x =1, y = 2, z = 3, w = 4;", 1, "const x = 1; {} const z = 3, w = 4;");
    }

    @Test
    public void testTryMergeBlock1() {
      // Test removing the initializer.
      Node actual = parse("{{a();b();}}");

      Node parentBlock = actual.getFirstChild();
      Node childBlock = parentBlock.getFirstChild();

      assertThat(NodeUtil.tryMergeBlock(childBlock, false)).isTrue();
      String expected = "{a();b();}";
      assertNode(parse(expected)).isEqualTo(actual);
    }

    @Test
    public void testTryMergeBlock2() {
      // Test removing the initializer.
      Node actual = parse("foo:{a();}");

      Node parentLabel = actual.getFirstChild();
      Node childBlock = parentLabel.getLastChild();

      assertThat(NodeUtil.tryMergeBlock(childBlock, false)).isFalse();
    }

    @Test
    public void testTryMergeBlock3() {
      // Test removing the initializer.
      String code = "foo:{a();boo()}";
      Node actual = parse("foo:{a();boo()}");

      Node parentLabel = actual.getFirstChild();
      Node childBlock = parentLabel.getLastChild();

      assertThat(NodeUtil.tryMergeBlock(childBlock, false)).isFalse();
      String expected = code;
      assertNode(parse(expected)).isEqualTo(actual);
    }

    @Test
    public void testTryMergeBlock4() {
      Node actual = parse("{const module$exports$Foo=class{}}");
      String expected = "const module$exports$Foo=class{}";

      Node block = actual.getFirstChild();

      assertThat(NodeUtil.tryMergeBlock(block, true)).isTrue();
      assertNode(parse(expected)).isEqualTo(actual);
    }

    @Test
    public void testCanMergeBlock1() {
      Node actual = parse("{a(); let x;}");

      Node block = actual.getFirstChild();

      assertThat(NodeUtil.canMergeBlock(block)).isFalse();
    }

    @Test
    public void testCanMergeBlock2() {
      Node actual = parse("{a(); f(); var x; {const y = 2;}}");

      Node parentBlock = actual.getFirstChild();
      Node childBlock = parentBlock.getLastChild();

      assertThat(NodeUtil.canMergeBlock(parentBlock)).isTrue();
      assertThat(NodeUtil.canMergeBlock(childBlock)).isFalse();
    }

    @Test
    public void testGetSourceName() {
      Node n = new Node(Token.BLOCK);
      Node parent = new Node(Token.BLOCK, n);
      parent.setSourceFileForTesting("foo");

      assertThat(NodeUtil.getSourceName(n)).isEqualTo("foo");
    }

    @Test
    public void testLocalValue1() {
      // Names are not known to be local.
      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("x"))).isFalse();
      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("x()"))).isFalse();
      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("this"))).isFalse();
      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("arguments"))).isFalse();

      // We can't know if new objects are local unless we know
      // that they don't alias themselves.
      // TODO(tdeegan): Revisit this.
      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("new x()"))).isFalse();

      // property references are assumed to be non-local
      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("(new x()).y"))).isFalse();
      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("(new x())['y']"))).isFalse();

      // Primitive values are local
      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("null"))).isTrue();
      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("undefined"))).isTrue();
      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("Infinity"))).isTrue();
      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("NaN"))).isTrue();
      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("1"))).isTrue();
      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("'a'"))).isTrue();
      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("true"))).isTrue();
      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("false"))).isTrue();
      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("[]"))).isTrue();
      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("{}"))).isTrue();

      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("[x]"))).isTrue();
      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("{'a':x}"))).isTrue();
      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("{'a': {'b': 2}}"))).isTrue();
      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("{'a': {'b': global}}"))).isTrue();
      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("{get someGetter() { return 1; }}")))
          .isTrue();
      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("{get someGetter() { return global; }}")))
          .isTrue();
      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("{set someSetter(value) {}}"))).isTrue();
      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("{[someComputedProperty]: {}}")))
          .isTrue();
      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("{[someComputedProperty]: global}")))
          .isTrue();
      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("{[someComputedProperty]: {'a':x}}")))
          .isTrue();
      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("{[someComputedProperty]: {'a':1}}")))
          .isTrue();

      // increment/decrement results in primitive number, the previous value is
      // always coersed to a number (even in the post.
      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("++x"))).isTrue();
      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("--x"))).isTrue();
      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("x++"))).isTrue();
      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("x--"))).isTrue();

      // The left side of an only assign matters if it is an alias or mutable.
      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("x=1"))).isTrue();
      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("x=[]"))).isFalse();
      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("x=y"))).isFalse();
      // The right hand side of assignment opts don't matter, as they force
      // a local result.
      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("x+=y"))).isTrue();
      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("x*=y"))).isTrue();
      // Comparisons always result in locals, as they force a local boolean
      // result.
      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("x==y"))).isTrue();
      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("x!=y"))).isTrue();
      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("x>y"))).isTrue();
      // Only the right side of a comma matters
      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("(1,2)"))).isTrue();
      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("(x,1)"))).isTrue();
      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("(x,y)"))).isFalse();

      // Both the operands of OR matter
      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("1||2"))).isTrue();
      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("x||1"))).isFalse();
      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("x||y"))).isFalse();
      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("1||y"))).isFalse();

      // Both the operands of AND matter
      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("1&&2"))).isTrue();
      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("x&&1"))).isFalse();
      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("x&&y"))).isFalse();
      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("1&&y"))).isFalse();

      // Only the results of HOOK matter
      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("x?1:2"))).isTrue();
      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("x?x:2"))).isFalse();
      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("x?1:x"))).isFalse();
      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("x?x:y"))).isFalse();

      // Results of ops are local values
      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("!y"))).isTrue();
      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("~y"))).isTrue();
      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("y + 1"))).isTrue();
      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("y + z"))).isTrue();
      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("y * z"))).isTrue();

      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("'a' in x"))).isTrue();
      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("typeof x"))).isTrue();
      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("x instanceof y"))).isTrue();

      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("void x"))).isTrue();
      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("void 0"))).isTrue();

      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("{}.x"))).isFalse();

      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("{}.toString()"))).isTrue();
      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("o.toString()"))).isTrue();

      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("o.valueOf()"))).isFalse();

      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("delete a.b"))).isTrue();
    }

    @Test
    public void testLocalValueTemplateLit() {
      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("`hello`"))).isTrue();
      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("`hello ${name}`"))).isTrue();
      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("`${'name'}`"))).isTrue();
      assertThat(NodeUtil.isLiteralValue(parseExpr("`${'name'}`"), false)).isTrue();
      assertThat(NodeUtil.isImmutableValue(parseExpr("`${'name'}`"))).isTrue();
    }

    @Test
    public void testLocalValueTaggedTemplateLit1() {
      Node n = parseExpr("tag`simple string`");
      assertThat(NodeUtil.evaluatesToLocalValue(n)).isFalse();

      // Set 'tag' function as producing a local result
      Node.SideEffectFlags flags = new Node.SideEffectFlags();
      flags.clearAllFlags();
      n.setSideEffectFlags(flags);

      assertThat(NodeUtil.evaluatesToLocalValue(n)).isTrue();
    }

    @Test
    public void testLocalValueTaggedTemplateLit2() {
      // Here, replacement() may have side effects.
      Node n = parseExpr("tag`string with ${replacement()}`");
      assertThat(NodeUtil.evaluatesToLocalValue(n)).isFalse();

      // Set 'tag' function as producing a local result
      Node.SideEffectFlags flags = new Node.SideEffectFlags();
      flags.clearAllFlags();
      n.setSideEffectFlags(flags);

      assertThat(NodeUtil.evaluatesToLocalValue(n)).isTrue();
    }

    @Test
    public void testLocalValueNewExpr() {
      Node newExpr = parseExpr("new x()");
      assertThat(NodeUtil.evaluatesToLocalValue(newExpr)).isFalse();

      checkState(newExpr.isNew());
      Node.SideEffectFlags flags = new Node.SideEffectFlags();

      flags.clearAllFlags();
      newExpr.setSideEffectFlags(flags);

      assertThat(NodeUtil.evaluatesToLocalValue(newExpr)).isTrue();

      flags.clearAllFlags();
      flags.setMutatesThis();
      newExpr.setSideEffectFlags(flags);

      assertThat(NodeUtil.evaluatesToLocalValue(newExpr)).isTrue();

      flags.clearAllFlags();
      flags.setReturnsTainted();
      newExpr.setSideEffectFlags(flags);

      assertThat(NodeUtil.evaluatesToLocalValue(newExpr)).isTrue();

      flags.clearAllFlags();
      flags.setThrows();
      newExpr.setSideEffectFlags(flags);

      assertThat(NodeUtil.evaluatesToLocalValue(newExpr)).isFalse();

      flags.clearAllFlags();
      flags.setMutatesArguments();
      newExpr.setSideEffectFlags(flags);

      assertThat(NodeUtil.evaluatesToLocalValue(newExpr)).isFalse();

      flags.clearAllFlags();
      flags.setMutatesGlobalState();
      newExpr.setSideEffectFlags(flags);

      assertThat(NodeUtil.evaluatesToLocalValue(newExpr)).isFalse();
    }

    @Test
    public void testLocalValueSpread() {
      // Array literals are always known local values.
      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("[...x]"))).isTrue();
      assertThat(NodeUtil.isLiteralValue(parseExpr("[...x]"), false)).isFalse();
      assertThat(NodeUtil.isImmutableValue(parseExpr("[...x]"))).isFalse();

      assertThat(NodeUtil.evaluatesToLocalValue(parseExpr("{...x}"))).isTrue();
      assertThat(NodeUtil.isLiteralValue(parseExpr("{...x}"), false)).isFalse();
      assertThat(NodeUtil.isImmutableValue(parseExpr("{...x}"))).isFalse();
    }

    @Test
    public void testLocalValueAwait() {
      Node expr;
      expr = parseFirst(AWAIT, "async function f() { await someAsyncAction(); }");
      assertThat(NodeUtil.evaluatesToLocalValue(expr)).isFalse();

      expr = parseFirst(AWAIT, "async function f() { await {then:function() { return p }}; }");
      assertThat(NodeUtil.evaluatesToLocalValue(expr)).isFalse();

      // it isn't clear why someone would want to wait on a non-thenable value...
      expr = parseFirst(AWAIT, "async function f() { await 5; }");
      assertThat(NodeUtil.evaluatesToLocalValue(expr)).isFalse();
    }

    @Test
    public void testLocalValueYield() {
      Node expr;
      expr = parseFirst(YIELD, "function *f() { yield; }");
      assertThat(NodeUtil.evaluatesToLocalValue(expr)).isFalse();

      expr = parseFirst(YIELD, "function *f() { yield 'something'; }");
      assertThat(NodeUtil.evaluatesToLocalValue(expr)).isFalse();
    }

    @Test
    public void testCallSideEffects() {
      ParseHelper helper = new ParseHelper();

      // Parens force interpretation as an expression.
      Node newXDotMethodCall = helper.parseFirst(CALL, "(new x().method());");
      Compiler compiler = helper.getCompiler();
      assertThat(NodeUtil.functionCallHasSideEffects(newXDotMethodCall)).isTrue();

      Node newExpr = newXDotMethodCall.getFirstFirstChild();
      checkState(newExpr.isNew());
      Node.SideEffectFlags flags = new Node.SideEffectFlags();

      // No side effects, local result
      flags.clearAllFlags();
      newExpr.setSideEffectFlags(flags);
      flags.clearAllFlags();
      newXDotMethodCall.setSideEffectFlags(flags);

      assertThat(NodeUtil.evaluatesToLocalValue(newXDotMethodCall)).isTrue();
      assertThat(NodeUtil.functionCallHasSideEffects(newXDotMethodCall)).isFalse();
      assertThat(NodeUtil.mayHaveSideEffects(newXDotMethodCall, compiler)).isFalse();

      // Modifies this, local result
      flags.clearAllFlags();
      newExpr.setSideEffectFlags(flags);
      flags.clearAllFlags();
      flags.setMutatesThis();
      newXDotMethodCall.setSideEffectFlags(flags);

      assertThat(NodeUtil.evaluatesToLocalValue(newXDotMethodCall)).isTrue();
      assertThat(NodeUtil.functionCallHasSideEffects(newXDotMethodCall)).isFalse();
      assertThat(NodeUtil.mayHaveSideEffects(newXDotMethodCall, compiler)).isFalse();

      // Modifies this, non-local result
      flags.clearAllFlags();
      newExpr.setSideEffectFlags(flags);
      flags.clearAllFlags();
      flags.setMutatesThis();
      flags.setReturnsTainted();
      newXDotMethodCall.setSideEffectFlags(flags);

      assertThat(NodeUtil.evaluatesToLocalValue(newXDotMethodCall)).isFalse();
      assertThat(NodeUtil.functionCallHasSideEffects(newXDotMethodCall)).isFalse();
      assertThat(NodeUtil.mayHaveSideEffects(newXDotMethodCall, compiler)).isFalse();

      // No modifications, non-local result
      flags.clearAllFlags();
      newExpr.setSideEffectFlags(flags);
      flags.clearAllFlags();
      flags.setReturnsTainted();
      newXDotMethodCall.setSideEffectFlags(flags);

      assertThat(NodeUtil.evaluatesToLocalValue(newXDotMethodCall)).isFalse();
      assertThat(NodeUtil.functionCallHasSideEffects(newXDotMethodCall)).isFalse();
      assertThat(NodeUtil.mayHaveSideEffects(newXDotMethodCall, compiler)).isFalse();

      // The new modifies global state, no side-effect call, non-local result
      // This call could be removed, but not the new.
      flags.clearAllFlags();
      flags.setMutatesGlobalState();
      newExpr.setSideEffectFlags(flags);
      flags.clearAllFlags();
      newXDotMethodCall.setSideEffectFlags(flags);

      assertThat(NodeUtil.evaluatesToLocalValue(newXDotMethodCall)).isTrue();
      assertThat(NodeUtil.functionCallHasSideEffects(newXDotMethodCall)).isFalse();
      assertThat(NodeUtil.mayHaveSideEffects(newXDotMethodCall, compiler)).isTrue();
    }

    @Test
    public void testGetOctalNumberValue() {
      assertThat(NodeUtil.getNumberValue(parseExpr("022"))).isEqualTo(18.0);
    }

    @SuppressWarnings("JUnit3FloatingPointComparisonWithoutDelta")
    @Test
    public void testGetNumberValue() {
      // Strings
      assertThat(NodeUtil.getNumberValue(parseExpr("'\\uFEFF1'"))).isEqualTo(1.0);
      assertThat(NodeUtil.getNumberValue(parseExpr("''"))).isEqualTo(0.0);
      assertThat(NodeUtil.getNumberValue(parseExpr("' '"))).isEqualTo(0.0);
      assertThat(NodeUtil.getNumberValue(parseExpr("' \\t'"))).isEqualTo(0.0);
      assertThat(NodeUtil.getNumberValue(parseExpr("'+0'"))).isEqualTo(0.0);
      assertThat(NodeUtil.getNumberValue(parseExpr("'-0'"))).isEqualTo(-0.0);
      assertThat(NodeUtil.getNumberValue(parseExpr("'+2'"))).isEqualTo(2.0);
      assertThat(NodeUtil.getNumberValue(parseExpr("'-1.6'"))).isEqualTo(-1.6);
      assertThat(NodeUtil.getNumberValue(parseExpr("'16'"))).isEqualTo(16.0);
      assertThat(NodeUtil.getNumberValue(parseExpr("' 16 '"))).isEqualTo(16.0);
      assertThat(NodeUtil.getNumberValue(parseExpr("' 16 '"))).isEqualTo(16.0);
      assertThat(NodeUtil.getNumberValue(parseExpr("'123e2'"))).isEqualTo(12300.0);
      assertThat(NodeUtil.getNumberValue(parseExpr("'123E2'"))).isEqualTo(12300.0);
      assertThat(NodeUtil.getNumberValue(parseExpr("'123e-2'"))).isEqualTo(1.23);
      assertThat(NodeUtil.getNumberValue(parseExpr("'123E-2'"))).isEqualTo(1.23);
      assertThat(NodeUtil.getNumberValue(parseExpr("'-123e-2'"))).isEqualTo(-1.23);
      assertThat(NodeUtil.getNumberValue(parseExpr("'-123E-2'"))).isEqualTo(-1.23);
      assertThat(NodeUtil.getNumberValue(parseExpr("'+123e-2'"))).isEqualTo(1.23);
      assertThat(NodeUtil.getNumberValue(parseExpr("'+123E-2'"))).isEqualTo(1.23);
      assertThat(NodeUtil.getNumberValue(parseExpr("'+123e+2'"))).isEqualTo(12300.0);
      assertThat(NodeUtil.getNumberValue(parseExpr("'+123E+2'"))).isEqualTo(12300.0);

      assertThat(NodeUtil.getNumberValue(parseExpr("'0xf'"))).isEqualTo(15.0);
      assertThat(NodeUtil.getNumberValue(parseExpr("'0xF'"))).isEqualTo(15.0);

      // Chrome and rhino behavior differently from FF and IE. FF and IE
      // consider a negative hex number to be invalid
      assertThat(NodeUtil.getNumberValue(parseExpr("'-0xf'"))).isNull();
      assertThat(NodeUtil.getNumberValue(parseExpr("'-0xF'"))).isNull();
      assertThat(NodeUtil.getNumberValue(parseExpr("'+0xf'"))).isNull();
      assertThat(NodeUtil.getNumberValue(parseExpr("'+0xF'"))).isNull();

      assertThat(NodeUtil.getNumberValue(parseExpr("'0X10'"))).isEqualTo(16.0);
      assertThat(NodeUtil.getNumberValue(parseExpr("'0X10.8'"))).isNaN();
      assertThat(NodeUtil.getNumberValue(parseExpr("'077'"))).isEqualTo(77.0);
      assertThat(NodeUtil.getNumberValue(parseExpr("'-077'"))).isEqualTo(-77.0);
      assertThat(NodeUtil.getNumberValue(parseExpr("'-077.5'"))).isEqualTo(-77.5);
      assertThat(NodeUtil.getNumberValue(parseExpr("'-Infinity'"))).isNegativeInfinity();
      assertThat(NodeUtil.getNumberValue(parseExpr("'Infinity'"))).isPositiveInfinity();
      assertThat(NodeUtil.getNumberValue(parseExpr("'+Infinity'"))).isPositiveInfinity();
      // Firefox treats "infinity" as "Infinity", IE treats it as NaN
      assertThat(NodeUtil.getNumberValue(parseExpr("'-infinity'"))).isNull();
      assertThat(NodeUtil.getNumberValue(parseExpr("'infinity'"))).isNull();
      assertThat(NodeUtil.getNumberValue(parseExpr("'+infinity'"))).isNull();

      assertThat(NodeUtil.getNumberValue(parseExpr("'NaN'"))).isNaN();
      assertThat(NodeUtil.getNumberValue(parseExpr("'some unknown string'"))).isNaN();
      assertThat(NodeUtil.getNumberValue(parseExpr("'123 blah'"))).isNaN();

      // Literals
      assertThat(NodeUtil.getNumberValue(parseExpr("1"))).isEqualTo(1.0);
      // "-1" is parsed as a literal
      assertThat(NodeUtil.getNumberValue(parseExpr("-1"))).isEqualTo(-1.0);
      // "+1" is parse as an op + literal
      assertThat(NodeUtil.getNumberValue(parseExpr("+1"))).isNull();
      assertThat(NodeUtil.getNumberValue(parseExpr("22"))).isEqualTo(22.0);
      assertThat(NodeUtil.getNumberValue(parseExpr("022"))).isEqualTo(18.0);
      assertThat(NodeUtil.getNumberValue(parseExpr("0x22"))).isEqualTo(34.0);

      assertThat(NodeUtil.getNumberValue(parseExpr("true"))).isEqualTo(1.0);
      assertThat(NodeUtil.getNumberValue(parseExpr("false"))).isEqualTo(0.0);
      assertThat(NodeUtil.getNumberValue(parseExpr("null"))).isEqualTo(0.0);
      assertThat(NodeUtil.getNumberValue(parseExpr("void 0"))).isNaN();
      assertThat(NodeUtil.getNumberValue(parseExpr("void f"))).isNaN();
      // we pay no attention to possible side effects.
      assertThat(NodeUtil.getNumberValue(parseExpr("void f()"))).isNaN();
      assertThat(NodeUtil.getNumberValue(parseExpr("NaN"))).isNaN();
      assertThat(NodeUtil.getNumberValue(parseExpr("Infinity"))).isPositiveInfinity();
      assertThat(NodeUtil.getNumberValue(parseExpr("-Infinity"))).isNegativeInfinity();

      // "infinity" is not a known name.
      assertThat(NodeUtil.getNumberValue(parseExpr("infinity"))).isNull();
      assertThat(NodeUtil.getNumberValue(parseExpr("-infinity"))).isNull();

      // getNumberValue only converts literals
      assertThat(NodeUtil.getNumberValue(parseExpr("x"))).isNull();
      assertThat(NodeUtil.getNumberValue(parseExpr("x.y"))).isNull();
      assertThat(NodeUtil.getNumberValue(parseExpr("1/2"))).isNull();
      assertThat(NodeUtil.getNumberValue(parseExpr("1-2"))).isNull();
      assertThat(NodeUtil.getNumberValue(parseExpr("+1"))).isNull();
    }

    @Test
    public void testIsNumericResult() {
      assertThat(NodeUtil.isNumericResult(parseExpr("1"))).isTrue();
      assertThat(NodeUtil.isNumericResult(parseExpr("true"))).isFalse();
      assertThat(NodeUtil.isNumericResult(parseExpr("+true"))).isTrue();
      assertThat(NodeUtil.isNumericResult(parseExpr("+1"))).isTrue();
      assertThat(NodeUtil.isNumericResult(parseExpr("-1"))).isTrue();
      assertThat(NodeUtil.isNumericResult(parseExpr("-Infinity"))).isTrue();
      assertThat(NodeUtil.isNumericResult(parseExpr("Infinity"))).isTrue();
      assertThat(NodeUtil.isNumericResult(parseExpr("NaN"))).isTrue();
      assertThat(NodeUtil.isNumericResult(parseExpr("undefined"))).isFalse();
      assertThat(NodeUtil.isNumericResult(parseExpr("void 0"))).isFalse();

      assertThat(NodeUtil.isNumericResult(parseExpr("a << b"))).isTrue();
      assertThat(NodeUtil.isNumericResult(parseExpr("a >> b"))).isTrue();
      assertThat(NodeUtil.isNumericResult(parseExpr("a >>> b"))).isTrue();

      assertThat(NodeUtil.isNumericResult(parseExpr("a == b"))).isFalse();
      assertThat(NodeUtil.isNumericResult(parseExpr("a != b"))).isFalse();
      assertThat(NodeUtil.isNumericResult(parseExpr("a === b"))).isFalse();
      assertThat(NodeUtil.isNumericResult(parseExpr("a !== b"))).isFalse();
      assertThat(NodeUtil.isNumericResult(parseExpr("a < b"))).isFalse();
      assertThat(NodeUtil.isNumericResult(parseExpr("a > b"))).isFalse();
      assertThat(NodeUtil.isNumericResult(parseExpr("a <= b"))).isFalse();
      assertThat(NodeUtil.isNumericResult(parseExpr("a >= b"))).isFalse();
      assertThat(NodeUtil.isNumericResult(parseExpr("a in b"))).isFalse();
      assertThat(NodeUtil.isNumericResult(parseExpr("a instanceof b"))).isFalse();

      assertThat(NodeUtil.isNumericResult(parseExpr("'a'"))).isFalse();
      assertThat(NodeUtil.isNumericResult(parseExpr("'a'+b"))).isFalse();
      assertThat(NodeUtil.isNumericResult(parseExpr("a+'b'"))).isFalse();
      assertThat(NodeUtil.isNumericResult(parseExpr("a+b"))).isFalse();
      assertThat(NodeUtil.isNumericResult(parseExpr("a()"))).isFalse();
      assertThat(NodeUtil.isNumericResult(parseExpr("''.a"))).isFalse();
      assertThat(NodeUtil.isNumericResult(parseExpr("a.b"))).isFalse();
      assertThat(NodeUtil.isNumericResult(parseExpr("a.b()"))).isFalse();
      assertThat(NodeUtil.isNumericResult(parseExpr("a().b()"))).isFalse();
      assertThat(NodeUtil.isNumericResult(parseExpr("new a()"))).isFalse();

      // Definitely not numeric
      assertThat(NodeUtil.isNumericResult(parseExpr("([1,2])"))).isFalse();
      assertThat(NodeUtil.isNumericResult(parseExpr("({a:1})"))).isFalse();

      // Recurse into the expression when necessary.
      assertThat(NodeUtil.isNumericResult(parseExpr("1 && 2"))).isTrue();
      assertThat(NodeUtil.isNumericResult(parseExpr("1 || 2"))).isTrue();
      assertThat(NodeUtil.isNumericResult(parseExpr("a ? 2 : 3"))).isTrue();
      assertThat(NodeUtil.isNumericResult(parseExpr("a,1"))).isTrue();
      assertThat(NodeUtil.isNumericResult(parseExpr("a=1"))).isTrue();

      assertThat(NodeUtil.isNumericResult(parseExpr("a += 1"))).isFalse();

      assertThat(NodeUtil.isNumericResult(parseExpr("a -= 1"))).isTrue();
      assertThat(NodeUtil.isNumericResult(parseExpr("a *= 1"))).isTrue();
      assertThat(NodeUtil.isNumericResult(parseExpr("--a"))).isTrue();
      assertThat(NodeUtil.isNumericResult(parseExpr("++a"))).isTrue();
      assertThat(NodeUtil.isNumericResult(parseExpr("a++"))).isTrue();
      assertThat(NodeUtil.isNumericResult(parseExpr("a--"))).isTrue();
    }

    @Test
    public void testIsBooleanResult() {
      assertThat(NodeUtil.isBooleanResult(parseExpr("1"))).isFalse();
      assertThat(NodeUtil.isBooleanResult(parseExpr("true"))).isTrue();
      assertThat(NodeUtil.isBooleanResult(parseExpr("+true"))).isFalse();
      assertThat(NodeUtil.isBooleanResult(parseExpr("+1"))).isFalse();
      assertThat(NodeUtil.isBooleanResult(parseExpr("-1"))).isFalse();
      assertThat(NodeUtil.isBooleanResult(parseExpr("-Infinity"))).isFalse();
      assertThat(NodeUtil.isBooleanResult(parseExpr("Infinity"))).isFalse();
      assertThat(NodeUtil.isBooleanResult(parseExpr("NaN"))).isFalse();
      assertThat(NodeUtil.isBooleanResult(parseExpr("undefined"))).isFalse();
      assertThat(NodeUtil.isBooleanResult(parseExpr("void 0"))).isFalse();

      assertThat(NodeUtil.isBooleanResult(parseExpr("a << b"))).isFalse();
      assertThat(NodeUtil.isBooleanResult(parseExpr("a >> b"))).isFalse();
      assertThat(NodeUtil.isBooleanResult(parseExpr("a >>> b"))).isFalse();

      assertThat(NodeUtil.isBooleanResult(parseExpr("a == b"))).isTrue();
      assertThat(NodeUtil.isBooleanResult(parseExpr("a != b"))).isTrue();
      assertThat(NodeUtil.isBooleanResult(parseExpr("a === b"))).isTrue();
      assertThat(NodeUtil.isBooleanResult(parseExpr("a !== b"))).isTrue();
      assertThat(NodeUtil.isBooleanResult(parseExpr("a < b"))).isTrue();
      assertThat(NodeUtil.isBooleanResult(parseExpr("a > b"))).isTrue();
      assertThat(NodeUtil.isBooleanResult(parseExpr("a <= b"))).isTrue();
      assertThat(NodeUtil.isBooleanResult(parseExpr("a >= b"))).isTrue();
      assertThat(NodeUtil.isBooleanResult(parseExpr("a in b"))).isTrue();
      assertThat(NodeUtil.isBooleanResult(parseExpr("a instanceof b"))).isTrue();

      assertThat(NodeUtil.isBooleanResult(parseExpr("'a'"))).isFalse();
      assertThat(NodeUtil.isBooleanResult(parseExpr("'a'+b"))).isFalse();
      assertThat(NodeUtil.isBooleanResult(parseExpr("a+'b'"))).isFalse();
      assertThat(NodeUtil.isBooleanResult(parseExpr("a+b"))).isFalse();
      assertThat(NodeUtil.isBooleanResult(parseExpr("a()"))).isFalse();
      assertThat(NodeUtil.isBooleanResult(parseExpr("''.a"))).isFalse();
      assertThat(NodeUtil.isBooleanResult(parseExpr("a.b"))).isFalse();
      assertThat(NodeUtil.isBooleanResult(parseExpr("a.b()"))).isFalse();
      assertThat(NodeUtil.isBooleanResult(parseExpr("a().b()"))).isFalse();
      assertThat(NodeUtil.isBooleanResult(parseExpr("new a()"))).isFalse();
      assertThat(NodeUtil.isBooleanResult(parseExpr("delete a"))).isTrue();

      // Definitely not boolean
      assertThat(NodeUtil.isBooleanResult(parseExpr("([true,false])"))).isFalse();
      assertThat(NodeUtil.isBooleanResult(parseExpr("({a:true})"))).isFalse();

      // These are boolean
      assertThat(NodeUtil.isBooleanResult(parseExpr("true && false"))).isTrue();
      assertThat(NodeUtil.isBooleanResult(parseExpr("true || false"))).isTrue();
      assertThat(NodeUtil.isBooleanResult(parseExpr("a ? true : false"))).isTrue();
      assertThat(NodeUtil.isBooleanResult(parseExpr("a,true"))).isTrue();
      assertThat(NodeUtil.isBooleanResult(parseExpr("a=true"))).isTrue();
      assertThat(NodeUtil.isBooleanResult(parseExpr("a=1"))).isFalse();
    }

    @Test
    public void testMayBeString() {
      assertThat(NodeUtil.mayBeString(parseExpr("1"))).isFalse();
      assertThat(NodeUtil.mayBeString(parseExpr("true"))).isFalse();
      assertThat(NodeUtil.mayBeString(parseExpr("+true"))).isFalse();
      assertThat(NodeUtil.mayBeString(parseExpr("+1"))).isFalse();
      assertThat(NodeUtil.mayBeString(parseExpr("-1"))).isFalse();
      assertThat(NodeUtil.mayBeString(parseExpr("-Infinity"))).isFalse();
      assertThat(NodeUtil.mayBeString(parseExpr("Infinity"))).isFalse();
      assertThat(NodeUtil.mayBeString(parseExpr("NaN"))).isFalse();
      assertThat(NodeUtil.mayBeString(parseExpr("undefined"))).isFalse();
      assertThat(NodeUtil.mayBeString(parseExpr("void 0"))).isFalse();
      assertThat(NodeUtil.mayBeString(parseExpr("null"))).isFalse();

      assertThat(NodeUtil.mayBeString(parseExpr("a << b"))).isFalse();
      assertThat(NodeUtil.mayBeString(parseExpr("a >> b"))).isFalse();
      assertThat(NodeUtil.mayBeString(parseExpr("a >>> b"))).isFalse();

      assertThat(NodeUtil.mayBeString(parseExpr("a == b"))).isFalse();
      assertThat(NodeUtil.mayBeString(parseExpr("a != b"))).isFalse();
      assertThat(NodeUtil.mayBeString(parseExpr("a === b"))).isFalse();
      assertThat(NodeUtil.mayBeString(parseExpr("a !== b"))).isFalse();
      assertThat(NodeUtil.mayBeString(parseExpr("a < b"))).isFalse();
      assertThat(NodeUtil.mayBeString(parseExpr("a > b"))).isFalse();
      assertThat(NodeUtil.mayBeString(parseExpr("a <= b"))).isFalse();
      assertThat(NodeUtil.mayBeString(parseExpr("a >= b"))).isFalse();
      assertThat(NodeUtil.mayBeString(parseExpr("a in b"))).isFalse();
      assertThat(NodeUtil.mayBeString(parseExpr("a instanceof b"))).isFalse();

      assertThat(NodeUtil.mayBeString(parseExpr("'a'"))).isTrue();
      assertThat(NodeUtil.mayBeString(parseExpr("'a'+b"))).isTrue();
      assertThat(NodeUtil.mayBeString(parseExpr("a+'b'"))).isTrue();
      assertThat(NodeUtil.mayBeString(parseExpr("a+b"))).isTrue();
      assertThat(NodeUtil.mayBeString(parseExpr("a()"))).isTrue();
      assertThat(NodeUtil.mayBeString(parseExpr("''.a"))).isTrue();
      assertThat(NodeUtil.mayBeString(parseExpr("a.b"))).isTrue();
      assertThat(NodeUtil.mayBeString(parseExpr("a.b()"))).isTrue();
      assertThat(NodeUtil.mayBeString(parseExpr("a().b()"))).isTrue();
      assertThat(NodeUtil.mayBeString(parseExpr("new a()"))).isTrue();

      // These can't be strings but they aren't handled yet.
      assertThat(NodeUtil.mayBeString(parseExpr("1 && 2"))).isFalse();
      assertThat(NodeUtil.mayBeString(parseExpr("1 || 2"))).isFalse();
      assertThat(NodeUtil.mayBeString(parseExpr("1 ? 2 : 3"))).isFalse();
      assertThat(NodeUtil.mayBeString(parseExpr("1,2"))).isFalse();
      assertThat(NodeUtil.mayBeString(parseExpr("a=1"))).isFalse();
      assertThat(NodeUtil.mayBeString(parseExpr("1+1"))).isFalse();
      assertThat(NodeUtil.mayBeString(parseExpr("true+true"))).isFalse();
      assertThat(NodeUtil.mayBeString(parseExpr("null+null"))).isFalse();
      assertThat(NodeUtil.mayBeString(parseExpr("NaN+NaN"))).isFalse();

      // These are not strings but they aren't primitives either
      assertThat(NodeUtil.mayBeString(parseExpr("([1,2])"))).isTrue();
      assertThat(NodeUtil.mayBeString(parseExpr("({a:1})"))).isTrue();
      assertThat(NodeUtil.mayBeString(parseExpr("({}+1)"))).isTrue();
      assertThat(NodeUtil.mayBeString(parseExpr("(1+{})"))).isTrue();
      assertThat(NodeUtil.mayBeString(parseExpr("([]+1)"))).isTrue();
      assertThat(NodeUtil.mayBeString(parseExpr("(1+[])"))).isTrue();

      assertThat(NodeUtil.mayBeString(parseExpr("a += 'x'"))).isTrue();
      assertThat(NodeUtil.mayBeString(parseExpr("a += 1"))).isTrue();
    }

    @Test
    public void testIsStringResult() {
      assertThat(NodeUtil.isStringResult(parseExpr("1"))).isFalse();
      assertThat(NodeUtil.isStringResult(parseExpr("true"))).isFalse();
      assertThat(NodeUtil.isStringResult(parseExpr("+true"))).isFalse();
      assertThat(NodeUtil.isStringResult(parseExpr("+1"))).isFalse();
      assertThat(NodeUtil.isStringResult(parseExpr("-1"))).isFalse();
      assertThat(NodeUtil.isStringResult(parseExpr("-Infinity"))).isFalse();
      assertThat(NodeUtil.isStringResult(parseExpr("Infinity"))).isFalse();
      assertThat(NodeUtil.isStringResult(parseExpr("NaN"))).isFalse();
      assertThat(NodeUtil.isStringResult(parseExpr("undefined"))).isFalse();
      assertThat(NodeUtil.isStringResult(parseExpr("void 0"))).isFalse();
      assertThat(NodeUtil.isStringResult(parseExpr("null"))).isFalse();

      assertThat(NodeUtil.isStringResult(parseExpr("a << b"))).isFalse();
      assertThat(NodeUtil.isStringResult(parseExpr("a >> b"))).isFalse();
      assertThat(NodeUtil.isStringResult(parseExpr("a >>> b"))).isFalse();

      assertThat(NodeUtil.isStringResult(parseExpr("a == b"))).isFalse();
      assertThat(NodeUtil.isStringResult(parseExpr("a != b"))).isFalse();
      assertThat(NodeUtil.isStringResult(parseExpr("a === b"))).isFalse();
      assertThat(NodeUtil.isStringResult(parseExpr("a !== b"))).isFalse();
      assertThat(NodeUtil.isStringResult(parseExpr("a < b"))).isFalse();
      assertThat(NodeUtil.isStringResult(parseExpr("a > b"))).isFalse();
      assertThat(NodeUtil.isStringResult(parseExpr("a <= b"))).isFalse();
      assertThat(NodeUtil.isStringResult(parseExpr("a >= b"))).isFalse();
      assertThat(NodeUtil.isStringResult(parseExpr("a in b"))).isFalse();
      assertThat(NodeUtil.isStringResult(parseExpr("a instanceof b"))).isFalse();

      assertThat(NodeUtil.isStringResult(parseExpr("'a'"))).isTrue();
      assertThat(NodeUtil.isStringResult(parseExpr("'a'+b"))).isTrue();
      assertThat(NodeUtil.isStringResult(parseExpr("a+'b'"))).isTrue();
      assertThat(NodeUtil.isStringResult(parseExpr("a+b"))).isFalse();
      assertThat(NodeUtil.isStringResult(parseExpr("a()"))).isFalse();
      assertThat(NodeUtil.isStringResult(parseExpr("''.a"))).isFalse();
      assertThat(NodeUtil.isStringResult(parseExpr("a.b"))).isFalse();
      assertThat(NodeUtil.isStringResult(parseExpr("a.b()"))).isFalse();
      assertThat(NodeUtil.isStringResult(parseExpr("a().b()"))).isFalse();
      assertThat(NodeUtil.isStringResult(parseExpr("new a()"))).isFalse();

      // These can't be strings but they aren't handled yet.
      assertThat(NodeUtil.isStringResult(parseExpr("1 && 2"))).isFalse();
      assertThat(NodeUtil.isStringResult(parseExpr("1 || 2"))).isFalse();
      assertThat(NodeUtil.isStringResult(parseExpr("1 ? 2 : 3"))).isFalse();
      assertThat(NodeUtil.isStringResult(parseExpr("1,2"))).isFalse();
      assertThat(NodeUtil.isStringResult(parseExpr("a=1"))).isFalse();
      assertThat(NodeUtil.isStringResult(parseExpr("1+1"))).isFalse();
      assertThat(NodeUtil.isStringResult(parseExpr("true+true"))).isFalse();
      assertThat(NodeUtil.isStringResult(parseExpr("null+null"))).isFalse();
      assertThat(NodeUtil.isStringResult(parseExpr("NaN+NaN"))).isFalse();

      // These are not strings but they aren't primitives either
      assertThat(NodeUtil.isStringResult(parseExpr("([1,2])"))).isFalse();
      assertThat(NodeUtil.isStringResult(parseExpr("({a:1})"))).isFalse();
      assertThat(NodeUtil.isStringResult(parseExpr("({}+1)"))).isFalse();
      assertThat(NodeUtil.isStringResult(parseExpr("(1+{})"))).isFalse();
      assertThat(NodeUtil.isStringResult(parseExpr("([]+1)"))).isFalse();
      assertThat(NodeUtil.isStringResult(parseExpr("(1+[])"))).isFalse();

      assertThat(NodeUtil.isStringResult(parseExpr("a += 'x'"))).isTrue();

      // Template literals
      assertThat(NodeUtil.isStringResult(parseExpr("`x`"))).isTrue();
      assertThat(NodeUtil.isStringResult(parseExpr("`a${b}c`"))).isTrue();
    }

    @Test
    public void testIsObjectResult() {
      assertThat(NodeUtil.isObjectResult(parseExpr("1"))).isFalse();
      assertThat(NodeUtil.isObjectResult(parseExpr("true"))).isFalse();
      assertThat(NodeUtil.isObjectResult(parseExpr("+true"))).isFalse();
      assertThat(NodeUtil.isObjectResult(parseExpr("+1"))).isFalse();
      assertThat(NodeUtil.isObjectResult(parseExpr("-1"))).isFalse();
      assertThat(NodeUtil.isObjectResult(parseExpr("-Infinity"))).isFalse();
      assertThat(NodeUtil.isObjectResult(parseExpr("Infinity"))).isFalse();
      assertThat(NodeUtil.isObjectResult(parseExpr("NaN"))).isFalse();
      assertThat(NodeUtil.isObjectResult(parseExpr("undefined"))).isFalse();
      assertThat(NodeUtil.isObjectResult(parseExpr("void 0"))).isFalse();

      assertThat(NodeUtil.isObjectResult(parseExpr("a << b"))).isFalse();
      assertThat(NodeUtil.isObjectResult(parseExpr("a >> b"))).isFalse();
      assertThat(NodeUtil.isObjectResult(parseExpr("a >>> b"))).isFalse();

      assertThat(NodeUtil.isObjectResult(parseExpr("a == b"))).isFalse();
      assertThat(NodeUtil.isObjectResult(parseExpr("a != b"))).isFalse();
      assertThat(NodeUtil.isObjectResult(parseExpr("a === b"))).isFalse();
      assertThat(NodeUtil.isObjectResult(parseExpr("a !== b"))).isFalse();
      assertThat(NodeUtil.isObjectResult(parseExpr("a < b"))).isFalse();
      assertThat(NodeUtil.isObjectResult(parseExpr("a > b"))).isFalse();
      assertThat(NodeUtil.isObjectResult(parseExpr("a <= b"))).isFalse();
      assertThat(NodeUtil.isObjectResult(parseExpr("a >= b"))).isFalse();
      assertThat(NodeUtil.isObjectResult(parseExpr("a in b"))).isFalse();
      assertThat(NodeUtil.isObjectResult(parseExpr("a instanceof b"))).isFalse();

      assertThat(NodeUtil.isObjectResult(parseExpr("delete a"))).isFalse();
      assertThat(NodeUtil.isObjectResult(parseExpr("'a'"))).isFalse();
      assertThat(NodeUtil.isObjectResult(parseExpr("'a'+b"))).isFalse();
      assertThat(NodeUtil.isObjectResult(parseExpr("a+'b'"))).isFalse();
      assertThat(NodeUtil.isObjectResult(parseExpr("a+b"))).isFalse();
      assertThat(NodeUtil.isObjectResult(parseExpr("{},true"))).isFalse();

      // "false" here means "unknown"
      assertThat(NodeUtil.isObjectResult(parseExpr("a()"))).isFalse();
      assertThat(NodeUtil.isObjectResult(parseExpr("''.a"))).isFalse();
      assertThat(NodeUtil.isObjectResult(parseExpr("a.b"))).isFalse();
      assertThat(NodeUtil.isObjectResult(parseExpr("a.b()"))).isFalse();
      assertThat(NodeUtil.isObjectResult(parseExpr("a().b()"))).isFalse();
      assertThat(NodeUtil.isObjectResult(parseExpr("a ? true : {}"))).isFalse();

      // These are objects but aren't handled yet.
      assertThat(NodeUtil.isObjectResult(parseExpr("true && {}"))).isFalse();
      assertThat(NodeUtil.isObjectResult(parseExpr("true || {}"))).isFalse();

      // Definitely objects
      assertThat(NodeUtil.isObjectResult(parseExpr("new a.b()"))).isTrue();
      assertThat(NodeUtil.isObjectResult(parseExpr("([true,false])"))).isTrue();
      assertThat(NodeUtil.isObjectResult(parseExpr("({a:true})"))).isTrue();
      assertThat(NodeUtil.isObjectResult(parseExpr("a={}"))).isTrue();
      assertThat(NodeUtil.isObjectResult(parseExpr("[] && {}"))).isTrue();
      assertThat(NodeUtil.isObjectResult(parseExpr("[] || {}"))).isTrue();
      assertThat(NodeUtil.isObjectResult(parseExpr("a ? [] : {}"))).isTrue();
      assertThat(NodeUtil.isObjectResult(parseExpr("{},[]"))).isTrue();
      assertThat(NodeUtil.isObjectResult(parseExpr("/a/g"))).isTrue();
    }

    @Test
    public void testValidNames() {
      assertThat(isValidPropertyName("a")).isTrue();
      assertThat(isValidPropertyName("a3")).isTrue();
      assertThat(isValidPropertyName("3a")).isFalse();
      assertThat(isValidPropertyName("a.")).isFalse();
      assertThat(isValidPropertyName(".a")).isFalse();
      assertThat(isValidPropertyName("a.b")).isFalse();
      assertThat(isValidPropertyName("true")).isFalse();
      assertThat(isValidPropertyName("a.true")).isFalse();
      assertThat(isValidPropertyName("a..b")).isFalse();

      assertThat(NodeUtil.isValidSimpleName("a")).isTrue();
      assertThat(NodeUtil.isValidSimpleName("a3")).isTrue();
      assertThat(NodeUtil.isValidSimpleName("3a")).isFalse();
      assertThat(NodeUtil.isValidSimpleName("a.")).isFalse();
      assertThat(NodeUtil.isValidSimpleName(".a")).isFalse();
      assertThat(NodeUtil.isValidSimpleName("a.b")).isFalse();
      assertThat(NodeUtil.isValidSimpleName("true")).isFalse();
      assertThat(NodeUtil.isValidSimpleName("a.true")).isFalse();
      assertThat(NodeUtil.isValidSimpleName("a..b")).isFalse();

      assertThat(isValidQualifiedName("a")).isTrue();
      assertThat(isValidQualifiedName("a3")).isTrue();
      assertThat(isValidQualifiedName("3a")).isFalse();
      assertThat(isValidQualifiedName("a.")).isFalse();
      assertThat(isValidQualifiedName(".a")).isFalse();
      assertThat(isValidQualifiedName("a.b")).isTrue();
      assertThat(isValidQualifiedName("true")).isFalse();
      assertThat(isValidQualifiedName("a.true")).isFalse();
      assertThat(isValidQualifiedName("a..b")).isFalse();
    }

    @Test
    public void testGetNearestFunctionName() {
      testFunctionName("(function() {})()", null);
      testFunctionName("function a() {}", "a");
      testFunctionName("(function a() {})", "a");
      testFunctionName("({a:function () {}})", "a");
      testFunctionName("({get a() {}})", "a");
      testFunctionName("({set a(b) {}})", "a");
      testFunctionName("({set a(b) {}})", "a");
      testFunctionName("({1:function () {}})", "1");
      testFunctionName("var a = function a() {}", "a");
      testFunctionName("var a;a = function a() {}", "a");
      testFunctionName("var o;o.a = function a() {}", "o.a");
      testFunctionName("this.a = function a() {}", "this.a");
    }

    @Test
    public void testGetBestLValue() {
      assertThat(getFunctionLValue("var x = function() {};")).isEqualTo("x");
      assertThat(getFunctionLValue("x = function() {};")).isEqualTo("x");
      assertThat(getFunctionLValue("function x() {};")).isEqualTo("x");
      assertThat(getFunctionLValue("var x = y ? z : function() {};")).isEqualTo("x");
      assertThat(getFunctionLValue("var x = y ? function() {} : z;")).isEqualTo("x");
      assertThat(getFunctionLValue("var x = y && function() {};")).isEqualTo("x");
      assertThat(getFunctionLValue("var x = y || function() {};")).isEqualTo("x");
      assertThat(getFunctionLValue("var x = (y, function() {});")).isEqualTo("x");
    }

    @Test
    public void testGetBestLValueName() {
      Function<String, String> getBestName =
          (js) -> NodeUtil.getBestLValueName(NodeUtil.getBestLValue(parseFirst(FUNCTION, js)));
      assertThat(getBestName.apply("var x = function() {};")).isEqualTo("x");
      assertThat(getBestName.apply("x = function() {};")).isEqualTo("x");
      assertThat(getBestName.apply("function x() {};")).isEqualTo("x");
      assertThat(getBestName.apply("var x = y ? z : function() {};")).isEqualTo("x");
      assertThat(getBestName.apply("var x = y ? function() {} : z;")).isEqualTo("x");
      assertThat(getBestName.apply("var x = y && function() {};")).isEqualTo("x");
      assertThat(getBestName.apply("var x = y || function() {};")).isEqualTo("x");
      assertThat(getBestName.apply("var x = (y, function() {});")).isEqualTo("x");
      assertThat(getBestName.apply("C.prototype.d = function() {};")).isEqualTo("C.prototype.d");
      assertThat(getBestName.apply("class C { d() {} };")).isEqualTo("C.prototype.d");
      assertThat(getBestName.apply("C.d = function() {};")).isEqualTo("C.d");
      assertThat(getBestName.apply("class C { static d() {} };")).isEqualTo("C.d");
    }

    @Test
    public void testGetRValueOfLValue() {
      assertThat(functionIsRValueOfAssign("x = function() {};")).isTrue();
      assertThat(functionIsRValueOfAssign("x += function() {};")).isTrue();
      assertThat(functionIsRValueOfAssign("x -= function() {};")).isTrue();
      assertThat(functionIsRValueOfAssign("x *= function() {};")).isTrue();
      assertThat(functionIsRValueOfAssign("x /= function() {};")).isTrue();
      assertThat(functionIsRValueOfAssign("x <<= function() {};")).isTrue();
      assertThat(functionIsRValueOfAssign("x >>= function() {};")).isTrue();
      assertThat(functionIsRValueOfAssign("x >>= function() {};")).isTrue();
      assertThat(functionIsRValueOfAssign("x >>>= function() {};")).isTrue();
      assertThat(functionIsRValueOfAssign("x = y ? x : function() {};")).isFalse();
    }

    /**
     * When the left side is a destructuring pattern, generally it's not possible to identify the
     * RHS for a specific name on the LHS.
     */
    @Test
    public void testGetRValueOfLValueInDestructuringPattern() {
      assertThat(NodeUtil.getRValueOfLValue(getNameNode(parse("var [x] = rhs;"), "x"))).isNull();
      assertThat(NodeUtil.getRValueOfLValue(getNameNode(parse("var [x, y] = rhs;"), "x"))).isNull();
      assertThat(NodeUtil.getRValueOfLValue(getNameNode(parse("var [y, x] = rhs;"), "x"))).isNull();
      assertThat(NodeUtil.getRValueOfLValue(getNameNode(parse("var {x: x} = rhs;"), "x"))).isNull();
      assertThat(NodeUtil.getRValueOfLValue(getNameNode(parse("var {y: x} = rhs;"), "x"))).isNull();

      Node ast = parse("var {x} = rhs;");
      Node x =
          ast.getFirstChild() // VAR
              .getFirstChild() // DESTRUCTURING_LHS
              .getFirstChild() // OBJECT_PATTERN
              .getFirstChild(); // STRING_KEY
      checkState(x.isStringKey(), x);
      assertThat(NodeUtil.getRValueOfLValue(x)).isNull();
    }

    @Test
    public void testGetRValueOfLValueDestructuringPattern() {
      assertNode(NodeUtil.getRValueOfLValue(getPattern(parse("var [x] = 'rhs';"))))
          .hasType(Token.STRING);
      assertNode(NodeUtil.getRValueOfLValue(getPattern(parse("var [x, y] = 'rhs';"))))
          .hasType(Token.STRING);
      assertNode(NodeUtil.getRValueOfLValue(getPattern(parse("var [y, x] = 'rhs';"))))
          .hasType(Token.STRING);
      assertNode(NodeUtil.getRValueOfLValue(getPattern(parse("var {x: x} = 'rhs';"))))
          .hasType(Token.STRING);
      assertNode(NodeUtil.getRValueOfLValue(getPattern(parse("var {y: x} = 'rhs';"))))
          .hasType(Token.STRING);
      assertNode(NodeUtil.getRValueOfLValue(getPattern(parse("var {x} = 'rhs';"))))
          .hasType(Token.STRING);
    }

    @Test
    public void testGetRValueOfLValueDestructuringLhs() {
      assertNode(NodeUtil.getRValueOfLValue(parseFirst(DESTRUCTURING_LHS, "var [x] = 'rhs';")))
          .hasType(Token.STRING);
      assertNode(NodeUtil.getRValueOfLValue(parseFirst(DESTRUCTURING_LHS, "var [x, y] = 'rhs';")))
          .hasType(Token.STRING);
      assertNode(NodeUtil.getRValueOfLValue(parseFirst(DESTRUCTURING_LHS, "var [y, x] = 'rhs';")))
          .hasType(Token.STRING);
      assertNode(NodeUtil.getRValueOfLValue(parseFirst(DESTRUCTURING_LHS, "var {x: x} = 'rhs';")))
          .hasType(Token.STRING);
      assertNode(NodeUtil.getRValueOfLValue(parseFirst(DESTRUCTURING_LHS, "var {y: x} = 'rhs';")))
          .hasType(Token.STRING);
      assertNode(NodeUtil.getRValueOfLValue(parseFirst(DESTRUCTURING_LHS, "var {x} = 'rhs';")))
          .hasType(Token.STRING);
    }

    @Test
    public void testIsNaN() {
      assertThat(NodeUtil.isNaN(parseExpr("NaN"))).isTrue();
      assertThat(NodeUtil.isNaN(parseExpr("Infinity"))).isFalse();
      assertThat(NodeUtil.isNaN(parseExpr("x"))).isFalse();
      assertThat(NodeUtil.isNaN(parseExpr("0/0"))).isTrue();
      assertThat(NodeUtil.isNaN(parseExpr("1/0"))).isFalse();
      assertThat(NodeUtil.isNaN(parseExpr("0/1"))).isFalse();
      assertThat(NodeUtil.isNaN(IR.number(0.0))).isFalse();
    }

    @Test
    public void testIsExecutedExactlyOnce() {
      assertThat(executedOnceTestCase("x;")).isTrue();

      assertThat(executedOnceTestCase("x && 1;")).isTrue();
      assertThat(executedOnceTestCase("1 && x;")).isFalse();

      assertThat(executedOnceTestCase("1 && (x && 1);")).isFalse();

      assertThat(executedOnceTestCase("x || 1;")).isTrue();
      assertThat(executedOnceTestCase("1 || x;")).isFalse();

      assertThat(executedOnceTestCase("1 && (x || 1);")).isFalse();

      assertThat(executedOnceTestCase("x ? 1 : 2;")).isTrue();
      assertThat(executedOnceTestCase("1 ? 1 : x;")).isFalse();
      assertThat(executedOnceTestCase("1 ? x : 2;")).isFalse();

      assertThat(executedOnceTestCase("1 && (x ? 1 : 2);")).isFalse();

      assertThat(executedOnceTestCase("if (x) {}")).isTrue();
      assertThat(executedOnceTestCase("if (true) {x;}")).isFalse();
      assertThat(executedOnceTestCase("if (true) {} else {x;}")).isFalse();

      assertThat(executedOnceTestCase("if (1) { if (x) {} }")).isFalse();

      assertThat(executedOnceTestCase("for(x;;){}")).isTrue();
      assertThat(executedOnceTestCase("for(;x;){}")).isFalse();
      assertThat(executedOnceTestCase("for(;;x){}")).isFalse();
      assertThat(executedOnceTestCase("for(;;){x;}")).isFalse();

      assertThat(executedOnceTestCase("if (1) { for(x;;){} }")).isFalse();

      assertThat(executedOnceTestCase("for(x in {}){}")).isFalse();
      assertThat(executedOnceTestCase("for({}.a in x){}")).isTrue();
      assertThat(executedOnceTestCase("for({}.a in {}){x}")).isFalse();

      assertThat(executedOnceTestCase("if (1) { for(x in {}){} }")).isFalse();

      assertThat(executedOnceTestCase("switch (x) {}")).isTrue();
      assertThat(executedOnceTestCase("switch (1) {case x:}")).isFalse();
      assertThat(executedOnceTestCase("switch (1) {case 1: x}")).isFalse();
      assertThat(executedOnceTestCase("switch (1) {default: x}")).isFalse();

      assertThat(executedOnceTestCase("if (1) { switch (x) {} }")).isFalse();

      assertThat(executedOnceTestCase("while (x) {}")).isFalse();
      assertThat(executedOnceTestCase("while (1) {x}")).isFalse();

      assertThat(executedOnceTestCase("do {} while (x)")).isFalse();
      assertThat(executedOnceTestCase("do {x} while (1)")).isFalse();

      assertThat(executedOnceTestCase("try {x} catch (e) {}")).isFalse();
      assertThat(executedOnceTestCase("try {} catch (e) {x}")).isFalse();
      assertThat(executedOnceTestCase("try {} finally {x}")).isTrue();

      assertThat(executedOnceTestCase("if (1) { try {} finally {x} }")).isFalse();
    }

    private void assertLValueNamedX(Node n) {
      assertThat(n.getString()).isEqualTo("x");
      assertThat(NodeUtil.isLValue(n)).isTrue();
    }

    @Test
    public void testIsLValue() {
      assertLValueNamedX(parse("var x;").getFirstFirstChild());
      assertLValueNamedX(parse("var w, x;").getFirstChild().getLastChild());
      assertLValueNamedX(
          parse("var [...x] = y;").getFirstFirstChild().getFirstFirstChild().getFirstChild());
      assertLValueNamedX(parse("var x = y;").getFirstFirstChild());
      assertLValueNamedX(parse("x++;").getFirstFirstChild().getFirstChild());
      assertLValueNamedX(
          NodeUtil.getFunctionParameters(parse("function f(x) {}").getFirstChild())
              .getFirstChild());

      Node x =
          NodeUtil.getFunctionParameters(parse("function f(x = 3) {}").getFirstChild())
              .getFirstChild() // x = 3
              .getFirstChild(); // x
      assertLValueNamedX(x);

      assertLValueNamedX(
          parse("({x} = obj)").getFirstFirstChild().getFirstFirstChild().getFirstChild());
      assertLValueNamedX(parse("([x] = obj)").getFirstFirstChild().getFirstFirstChild());
      assertLValueNamedX(
          parse("function foo (...x) {}").getFirstChild().getSecondChild().getFirstFirstChild());
      assertLValueNamedX(
          parse("({[0]: x} = obj)").getFirstFirstChild().getFirstFirstChild().getSecondChild());
    }

    private void assertNotLValueNamedX(Node n) {
      assertThat(n.getString()).isEqualTo("x");
      assertThat(NodeUtil.isLValue(n)).isFalse();
    }

    @Test
    public void testIsNotLValue() {
      assertNotLValueNamedX(parse("var a = x;").getFirstFirstChild().getFirstChild());

      Node x =
          parse("f(...x);") // script
              .getFirstChild() // expr result
              .getFirstChild() // call
              .getLastChild() // spread
              .getFirstChild(); // x
      assertNotLValueNamedX(x);

      x =
          parse("var a = [...x];") // script
              .getFirstChild() // var
              .getFirstChild() // a
              .getFirstChild() // array
              .getFirstChild() // spread
              .getFirstChild(); // x
      assertNotLValueNamedX(x);
    }

    @Test
    public void testIsConstantDeclaration() {
      assertIsConstantDeclaration(false, parse("var x = 1;").getFirstFirstChild());
      assertIsConstantDeclaration(false, parse("let x = 1;").getFirstFirstChild());
      assertIsConstantDeclaration(true, parse("const x = 1;").getFirstFirstChild());

      assertIsConstantDeclaration(true, parse("/** @const */ var x = 1;").getFirstFirstChild());
      assertIsConstantDeclaration(true, parse("var /** @const */ x = 1;").getFirstFirstChild());
      assertIsConstantDeclaration(false, parse("var x, /** @const */ y = 1;").getFirstFirstChild());

      assertIsConstantDeclaration(true, getNameNodeFrom("const [a] = [];", "a"));
      assertIsConstantDeclaration(true, getNameNodeFrom("const [[[a]]] = [];", "a"));
      assertIsConstantDeclaration(true, getNameNodeFrom("const [a = 1] = [];", "a"));
      assertIsConstantDeclaration(true, getNameNodeFrom("const [...a] = [];", "a"));

      assertIsConstantDeclaration(true, getNameNodeFrom("const {a} = {};", "a"));
      assertIsConstantDeclaration(true, getNameNodeFrom("const {a = 1} = {};", "a"));
      assertIsConstantDeclaration(true, getNameNodeFrom("const {[3]: a} = {};", "a"));
      assertIsConstantDeclaration(true, getNameNodeFrom("const {a: [a]} = {};", "a"));

      // TODO(bradfordcsmith): Add test cases for other coding conventions.
    }

    private void assertIsConstantDeclaration(boolean isConstantDeclaration, Node node) {
      CodingConvention codingConvention = new ClosureCodingConvention();
      JSDocInfo jsDocInfo = NodeUtil.getBestJSDocInfo(node);
      assertWithMessage("Is %s a constant declaration?", node)
          .that(NodeUtil.isConstantDeclaration(codingConvention, jsDocInfo, node))
          .isEqualTo(isConstantDeclaration);
    }

    @Test
    public void testIsNestedObjectPattern() {
      Node root = parse("var {a, b} = {a:1, b:2}");
      Node destructuring = root.getFirstFirstChild();
      Node objPattern = destructuring.getFirstChild();
      assertThat(NodeUtil.isNestedObjectPattern(objPattern)).isFalse();

      root = parse("var {a, b:{c}} = {a:{}, b:{c:5}};");
      destructuring = root.getFirstFirstChild();
      objPattern = destructuring.getFirstChild();
      assertThat(NodeUtil.isNestedObjectPattern(objPattern)).isTrue();
    }

    @Test
    public void testIsNestedArrayPattern() {
      Node root = parse("var [a, b] = [1, 2]");
      Node destructuring = root.getFirstFirstChild();
      Node arrayPattern = destructuring.getFirstChild();
      assertThat(NodeUtil.isNestedArrayPattern(arrayPattern)).isFalse();
    }

    @Test
    public void testDestructuring1() {
      Node root = parse("var [a, b] = obj;");
      Node varNode = root.getFirstChild();
      Node destructLhs = varNode.getFirstChild();
      checkState(destructLhs.isDestructuringLhs(), destructLhs);
      Node destructPat = destructLhs.getFirstChild();
      checkState(destructPat.isArrayPattern(), destructPat);

      Node nameNodeA = destructPat.getFirstChild();
      Node nameNodeB = nameNodeA.getNext();
      checkState(nameNodeA.getString().equals("a"), nameNodeA);
      checkState(nameNodeB.getString().equals("b"), nameNodeB);

      Node nameNodeObj = destructPat.getNext();
      checkState(nameNodeObj.getString().equals("obj"), nameNodeObj);

      assertLhsByDestructuring(nameNodeA);
      assertLhsByDestructuring(nameNodeB);
      assertNotLhsByDestructuring(nameNodeObj);

      assertThat(NodeUtil.getRootTarget(destructPat)).isSameInstanceAs(destructPat);
      assertThat(NodeUtil.getRootTarget(nameNodeA)).isSameInstanceAs(destructPat);
      assertThat(NodeUtil.getRootTarget(nameNodeB)).isSameInstanceAs(destructPat);

      assertThat(NodeUtil.getDeclaringParent(nameNodeA)).isSameInstanceAs(varNode);
      assertThat(NodeUtil.getDeclaringParent(nameNodeB)).isSameInstanceAs(varNode);
    }

    @Test
    public void testDestructuring1b() {
      Node root = parse("var {a: c, b: d} = obj;");
      Node varNode = root.getFirstChild();
      Node destructLhs = varNode.getFirstChild();
      checkState(destructLhs.isDestructuringLhs(), destructLhs);
      Node destructPat = destructLhs.getFirstChild();
      checkState(destructPat.isObjectPattern(), destructPat);

      Node strKeyNodeA = destructPat.getFirstChild();
      Node strKeyNodeB = strKeyNodeA.getNext();
      Node nameNodeC = strKeyNodeA.getFirstChild();
      Node nameNodeD = strKeyNodeB.getFirstChild();
      checkState(strKeyNodeA.getString().equals("a"), strKeyNodeA);
      checkState(strKeyNodeB.getString().equals("b"), strKeyNodeB);
      checkState(nameNodeC.getString().equals("c"), nameNodeC);
      checkState(nameNodeD.getString().equals("d"), nameNodeD);

      Node nameNodeObj = destructPat.getNext();
      checkState(nameNodeObj.getString().equals("obj"), nameNodeObj);

      assertNotLhsByDestructuring(strKeyNodeA);
      assertNotLhsByDestructuring(strKeyNodeB);
      assertLhsByDestructuring(nameNodeC);
      assertLhsByDestructuring(nameNodeD);
      assertNotLhsByDestructuring(nameNodeObj);

      assertThat(NodeUtil.getRootTarget(destructPat)).isSameInstanceAs(destructPat);
      assertThat(NodeUtil.getRootTarget(nameNodeC)).isSameInstanceAs(destructPat);
      assertThat(NodeUtil.getRootTarget(nameNodeD)).isSameInstanceAs(destructPat);

      assertThat(NodeUtil.getDeclaringParent(nameNodeC)).isSameInstanceAs(varNode);
      assertThat(NodeUtil.getDeclaringParent(nameNodeD)).isSameInstanceAs(varNode);
    }

    @Test
    public void testDestructuring1c() {
      Node root = parse("var {a, b} = obj;");
      Node varNode = root.getFirstChild();
      Node destructLhs = varNode.getFirstChild();
      checkState(destructLhs.isDestructuringLhs(), destructLhs);
      Node destructPat = destructLhs.getFirstChild();
      checkState(destructPat.isObjectPattern(), destructPat);

      Node strKeyNodeA = destructPat.getFirstChild();
      Node strKeyNodeB = strKeyNodeA.getNext();
      Node nameNodeA = strKeyNodeA.getFirstChild();
      Node nameNodeB = strKeyNodeB.getFirstChild();
      checkState(strKeyNodeA.getString().equals("a"), strKeyNodeA);
      checkState(nameNodeA.getString().equals("a"), nameNodeA);
      checkState(strKeyNodeB.getString().equals("b"), strKeyNodeB);
      checkState(nameNodeB.getString().equals("b"), nameNodeB);

      Node nameNodeObj = destructPat.getNext();
      checkState(nameNodeObj.getString().equals("obj"), nameNodeObj);

      assertNotLhsByDestructuring(strKeyNodeA);
      assertNotLhsByDestructuring(strKeyNodeB);
      assertLhsByDestructuring(nameNodeA);
      assertLhsByDestructuring(nameNodeB);
      assertNotLhsByDestructuring(nameNodeObj);

      assertThat(NodeUtil.getRootTarget(destructPat)).isSameInstanceAs(destructPat);
      assertThat(NodeUtil.getRootTarget(nameNodeA)).isSameInstanceAs(destructPat);
      assertThat(NodeUtil.getRootTarget(nameNodeB)).isSameInstanceAs(destructPat);

      assertThat(NodeUtil.getDeclaringParent(nameNodeA)).isSameInstanceAs(varNode);
      assertThat(NodeUtil.getDeclaringParent(nameNodeB)).isSameInstanceAs(varNode);
    }

    @Test
    public void testDestructuring1d() {
      Node root = parse("var {a = defaultValue} = obj;");
      Node varNode = root.getFirstChild();
      Node destructLhs = varNode.getFirstChild();
      checkState(destructLhs.isDestructuringLhs(), destructLhs);
      Node destructPat = destructLhs.getFirstChild();
      checkState(destructPat.isObjectPattern(), destructPat);

      Node strKeyNodeA = destructPat.getFirstChild();
      checkState(strKeyNodeA.isStringKey());
      checkState(strKeyNodeA.getString().equals("a"), strKeyNodeA);

      Node defaultNodeA = strKeyNodeA.getFirstChild();
      checkState(defaultNodeA.isDefaultValue(), defaultNodeA);
      Node nameNodeA = defaultNodeA.getFirstChild();
      checkState(nameNodeA.getString().equals("a"), nameNodeA);

      Node nameNodeDefault = defaultNodeA.getSecondChild();
      checkState(nameNodeDefault.getString().equals("defaultValue"), nameNodeDefault);
      Node nameNodeObj = destructPat.getNext();
      checkState(nameNodeObj.getString().equals("obj"), nameNodeObj);

      assertNotLhsByDestructuring(strKeyNodeA);
      assertNotLhsByDestructuring(defaultNodeA);
      assertLhsByDestructuring(nameNodeA);
      assertNotLhsByDestructuring(nameNodeDefault);
      assertNotLhsByDestructuring(nameNodeObj);

      assertThat(NodeUtil.getRootTarget(destructPat)).isSameInstanceAs(destructPat);
      assertThat(NodeUtil.getRootTarget(nameNodeA)).isSameInstanceAs(destructPat);

      assertThat(NodeUtil.getDeclaringParent(nameNodeA)).isSameInstanceAs(varNode);
    }

    @Test
    public void testDestructuring1e() {
      Node root = parse("var {a: b = defaultValue} = obj;");
      Node varNode = root.getFirstChild();
      Node destructLhs = varNode.getFirstChild();
      checkState(destructLhs.isDestructuringLhs(), destructLhs);
      Node destructPat = destructLhs.getFirstChild();
      checkState(destructPat.isObjectPattern(), destructPat);

      Node strKeyNodeA = destructPat.getFirstChild();
      checkState(strKeyNodeA.getString().equals("a"), strKeyNodeA);

      Node defaultNodeA = strKeyNodeA.getOnlyChild();
      checkState(defaultNodeA.isDefaultValue(), defaultNodeA);

      Node nameNodeB = defaultNodeA.getFirstChild();
      checkState(nameNodeB.getString().equals("b"), nameNodeB);

      Node nameNodeDefaultValue = defaultNodeA.getSecondChild();
      checkState(nameNodeDefaultValue.getString().equals("defaultValue"), nameNodeDefaultValue);
      Node nameNodeObj = destructPat.getNext();
      checkState(nameNodeObj.getString().equals("obj"), nameNodeObj);

      assertNotLhsByDestructuring(strKeyNodeA);
      assertLhsByDestructuring(nameNodeB);
      assertNotLhsByDestructuring(nameNodeDefaultValue);
      assertNotLhsByDestructuring(nameNodeObj);

      assertThat(NodeUtil.getRootTarget(destructPat)).isSameInstanceAs(destructPat);
      assertThat(NodeUtil.getRootTarget(nameNodeB)).isSameInstanceAs(destructPat);

      assertThat(NodeUtil.getDeclaringParent(nameNodeB)).isSameInstanceAs(varNode);
    }

    @Test
    public void testDestructuring1f() {
      Node root = parse("var [a  = defaultValue] = arr;");
      Node varNode = root.getFirstChild();
      Node destructLhs = varNode.getFirstChild();
      checkState(destructLhs.isDestructuringLhs(), destructLhs);
      Node destructPat = destructLhs.getFirstChild();
      checkState(destructPat.isArrayPattern(), destructPat);

      Node defaultNodeA = destructPat.getFirstChild();

      checkState(defaultNodeA.isDefaultValue(), defaultNodeA);

      Node nameNodeA = defaultNodeA.getFirstChild();
      checkState(nameNodeA.getString().equals("a"), nameNodeA);

      Node nameNodeDefault = defaultNodeA.getSecondChild();
      checkState(nameNodeDefault.getString().equals("defaultValue"), nameNodeDefault);
      Node nameNodeObj = destructPat.getNext();
      checkState(nameNodeObj.getString().equals("arr"), nameNodeObj);

      assertLhsByDestructuring(nameNodeA);
      assertNotLhsByDestructuring(nameNodeDefault);
      assertNotLhsByDestructuring(nameNodeObj);

      assertThat(NodeUtil.getRootTarget(destructPat)).isSameInstanceAs(destructPat);
      assertThat(NodeUtil.getRootTarget(nameNodeA)).isSameInstanceAs(destructPat);

      assertThat(NodeUtil.getDeclaringParent(nameNodeA)).isSameInstanceAs(varNode);
    }

    @Test
    public void testDestructuring2() {
      Node root = parse("var [a, [b, c]] = obj;");
      Node varNode = root.getFirstChild();
      Node destructLhs = varNode.getFirstChild();
      checkState(destructLhs.isDestructuringLhs(), destructLhs);
      Node destructPat = destructLhs.getFirstChild();
      checkState(destructPat.isArrayPattern(), destructPat);

      Node nameNodeA = destructPat.getFirstChild();
      Node innerPat = nameNodeA.getNext();
      Node nameNodeB = innerPat.getFirstChild();
      Node nameNodeC = nameNodeB.getNext();
      checkState(nameNodeA.getString().equals("a"), nameNodeA);
      checkState(nameNodeB.getString().equals("b"), nameNodeB);
      checkState(nameNodeC.getString().equals("c"), nameNodeC);

      Node nameNodeObj = destructPat.getNext();
      checkState(nameNodeObj.getString().equals("obj"), nameNodeObj);

      assertLhsByDestructuring(nameNodeA);
      assertLhsByDestructuring(nameNodeB);
      assertLhsByDestructuring(nameNodeC);
      assertNotLhsByDestructuring(nameNodeObj);

      assertThat(NodeUtil.getRootTarget(destructPat)).isSameInstanceAs(destructPat);
      assertThat(NodeUtil.getRootTarget(nameNodeA)).isSameInstanceAs(destructPat);
      assertThat(NodeUtil.getRootTarget(innerPat)).isSameInstanceAs(destructPat);
      assertThat(NodeUtil.getRootTarget(nameNodeB)).isSameInstanceAs(destructPat);
      assertThat(NodeUtil.getRootTarget(nameNodeC)).isSameInstanceAs(destructPat);

      assertThat(NodeUtil.getDeclaringParent(nameNodeA)).isSameInstanceAs(varNode);
      assertThat(NodeUtil.getDeclaringParent(nameNodeB)).isSameInstanceAs(varNode);
      assertThat(NodeUtil.getDeclaringParent(nameNodeC)).isSameInstanceAs(varNode);
    }

    @Test
    public void testDestructuring2b() {
      Node root = parse("var {a: e, b: {c: f, d: g}} = obj;");
      Node varNode = root.getFirstChild();
      Node destructLhs = varNode.getFirstChild();
      checkState(destructLhs.isDestructuringLhs(), destructLhs);
      Node destructPat = destructLhs.getFirstChild();
      checkState(destructPat.isObjectPattern(), destructPat);

      Node strKeyNodeA = destructPat.getFirstChild();
      Node strKeyNodeB = strKeyNodeA.getNext();
      Node innerPat = strKeyNodeB.getOnlyChild();
      Node strKeyNodeC = innerPat.getFirstChild();
      Node strKeyNodeD = strKeyNodeC.getNext();
      Node nameNodeE = strKeyNodeA.getFirstChild();
      Node nameNodeF = strKeyNodeC.getFirstChild();
      Node nameNodeG = strKeyNodeD.getFirstChild();
      checkState(strKeyNodeA.getString().equals("a"), strKeyNodeA);
      checkState(strKeyNodeB.getString().equals("b"), strKeyNodeB);
      checkState(strKeyNodeC.getString().equals("c"), strKeyNodeC);
      checkState(strKeyNodeD.getString().equals("d"), strKeyNodeD);
      checkState(nameNodeE.getString().equals("e"), nameNodeE);
      checkState(nameNodeF.getString().equals("f"), nameNodeF);
      checkState(nameNodeG.getString().equals("g"), nameNodeG);

      Node nameNodeObj = destructPat.getNext();
      checkState(nameNodeObj.getString().equals("obj"), nameNodeObj);

      assertNotLhsByDestructuring(strKeyNodeA);
      assertNotLhsByDestructuring(strKeyNodeB);
      assertNotLhsByDestructuring(strKeyNodeC);
      assertNotLhsByDestructuring(strKeyNodeD);
      assertLhsByDestructuring(nameNodeE);
      assertLhsByDestructuring(nameNodeF);
      assertLhsByDestructuring(nameNodeG);
      assertNotLhsByDestructuring(nameNodeObj);

      assertThat(NodeUtil.getRootTarget(destructPat)).isSameInstanceAs(destructPat);
      assertThat(NodeUtil.getRootTarget(nameNodeE)).isSameInstanceAs(destructPat);
      assertThat(NodeUtil.getRootTarget(innerPat)).isSameInstanceAs(destructPat);
      assertThat(NodeUtil.getRootTarget(nameNodeF)).isSameInstanceAs(destructPat);
      assertThat(NodeUtil.getRootTarget(nameNodeG)).isSameInstanceAs(destructPat);

      assertThat(NodeUtil.getDeclaringParent(nameNodeE)).isSameInstanceAs(varNode);
      assertThat(NodeUtil.getDeclaringParent(nameNodeF)).isSameInstanceAs(varNode);
      assertThat(NodeUtil.getDeclaringParent(nameNodeG)).isSameInstanceAs(varNode);
    }

    @Test
    public void testDestructuring3() {
      Node root = parse("var [a, b] = [c, d];");
      Node varNode = root.getFirstChild();
      Node destructLhs = varNode.getFirstChild();
      checkState(destructLhs.isDestructuringLhs(), destructLhs);
      Node destructPat = destructLhs.getFirstChild();
      checkState(destructPat.isArrayPattern(), destructPat);

      Node nameNodeA = destructPat.getFirstChild();
      Node nameNodeB = nameNodeA.getNext();
      checkState(nameNodeA.getString().equals("a"), nameNodeA);
      checkState(nameNodeB.getString().equals("b"), nameNodeB);

      Node nameNodeC = destructLhs.getLastChild().getFirstChild();
      Node nameNodeD = nameNodeC.getNext();
      checkState(nameNodeC.getString().equals("c"), nameNodeC);
      checkState(nameNodeD.getString().equals("d"), nameNodeD);

      assertLhsByDestructuring(nameNodeA);
      assertLhsByDestructuring(nameNodeB);
      assertNotLhsByDestructuring(nameNodeC);
      assertNotLhsByDestructuring(nameNodeD);

      assertThat(NodeUtil.getRootTarget(destructPat)).isSameInstanceAs(destructPat);
      assertThat(NodeUtil.getRootTarget(nameNodeA)).isSameInstanceAs(destructPat);
      assertThat(NodeUtil.getRootTarget(nameNodeB)).isSameInstanceAs(destructPat);

      assertThat(NodeUtil.getDeclaringParent(nameNodeA)).isSameInstanceAs(varNode);
      assertThat(NodeUtil.getDeclaringParent(nameNodeB)).isSameInstanceAs(varNode);
    }

    @Test
    public void testDestructuring3b() {
      Node root = parse("var {a: c, b: d} = {a: 1, b: 2};");
      Node varNode = root.getFirstChild();
      Node destructLhs = varNode.getFirstChild();
      checkState(destructLhs.isDestructuringLhs(), destructLhs);
      Node destructPat = destructLhs.getFirstChild();
      checkState(destructPat.isObjectPattern(), destructPat);

      Node strKeyNodeA = destructPat.getFirstChild();
      Node strKeyNodeB = strKeyNodeA.getNext();
      Node nameNodeC = strKeyNodeA.getFirstChild();
      Node nameNodeD = strKeyNodeB.getFirstChild();
      checkState(strKeyNodeA.getString().equals("a"), strKeyNodeA);
      checkState(strKeyNodeB.getString().equals("b"), strKeyNodeB);
      checkState(nameNodeC.getString().equals("c"), nameNodeC);
      checkState(nameNodeD.getString().equals("d"), nameNodeD);

      assertNotLhsByDestructuring(strKeyNodeA);
      assertNotLhsByDestructuring(strKeyNodeB);
      assertLhsByDestructuring(nameNodeC);
      assertLhsByDestructuring(nameNodeD);

      assertThat(NodeUtil.getRootTarget(destructPat)).isSameInstanceAs(destructPat);
      assertThat(NodeUtil.getRootTarget(nameNodeC)).isSameInstanceAs(destructPat);
      assertThat(NodeUtil.getRootTarget(nameNodeD)).isSameInstanceAs(destructPat);

      assertThat(NodeUtil.getDeclaringParent(nameNodeC)).isSameInstanceAs(varNode);
      assertThat(NodeUtil.getDeclaringParent(nameNodeD)).isSameInstanceAs(varNode);
    }

    @Test
    public void testDestructuring4() {
      Node root = parse("for ([a, b] of X){}");
      Node destructPat = root.getFirstFirstChild();
      checkState(destructPat.isArrayPattern(), destructPat);

      Node nameNodeA = destructPat.getFirstChild();
      Node nameNodeB = destructPat.getLastChild();
      checkState(nameNodeA.getString().equals("a"), nameNodeA);
      checkState(nameNodeB.getString().equals("b"), nameNodeB);

      assertLhsByDestructuring(nameNodeA);
      assertLhsByDestructuring(nameNodeB);

      assertThat(NodeUtil.getRootTarget(destructPat)).isSameInstanceAs(destructPat);
      assertThat(NodeUtil.getRootTarget(nameNodeA)).isSameInstanceAs(destructPat);
      assertThat(NodeUtil.getRootTarget(nameNodeB)).isSameInstanceAs(destructPat);
    }

    @Test
    public void testDestructuring5() {
      Node root = parse("function fn([a, b] = [c, d]){}");
      Node destructPat = root.getFirstChild().getSecondChild().getFirstFirstChild();
      checkState(destructPat.isArrayPattern(), destructPat);

      Node nameNodeA = destructPat.getFirstChild();
      Node nameNodeB = destructPat.getLastChild();
      Node nameNodeC = destructPat.getNext().getFirstChild();
      Node nameNodeD = destructPat.getNext().getLastChild();
      checkState(nameNodeA.getString().equals("a"), nameNodeA);
      checkState(nameNodeB.getString().equals("b"), nameNodeB);
      checkState(nameNodeC.getString().equals("c"), nameNodeC);
      checkState(nameNodeD.getString().equals("d"), nameNodeD);

      assertLhsByDestructuring(nameNodeA);
      assertLhsByDestructuring(nameNodeB);
      assertNotLhsByDestructuring(nameNodeC);
      assertNotLhsByDestructuring(nameNodeD);

      assertThat(NodeUtil.getRootTarget(destructPat)).isSameInstanceAs(destructPat);
      assertThat(NodeUtil.getRootTarget(nameNodeA)).isSameInstanceAs(destructPat);
      assertThat(NodeUtil.getRootTarget(nameNodeB)).isSameInstanceAs(destructPat);
    }

    @Test
    public void testRestParameter() {
      Node root = parse("function fn(a, b, ...rest){}");
      Node parameterList = root.getFirstChild().getSecondChild();

      Node nameNodeA = parameterList.getFirstChild();
      Node nameNodeB = nameNodeA.getNext();
      Node restNode = nameNodeB.getNext();
      checkState(restNode.isRest(), restNode);

      Node nameNodeRest = restNode.getFirstChild();

      checkState(nameNodeA.getString().equals("a"), nameNodeA);

      assertThat(NodeUtil.getRootTarget(nameNodeA)).isSameInstanceAs(nameNodeA);
      assertThat(NodeUtil.getRootTarget(nameNodeB)).isSameInstanceAs(nameNodeB);
      assertThat(NodeUtil.getRootTarget(nameNodeRest)).isSameInstanceAs(nameNodeRest);

      assertThat(NodeUtil.getDeclaringParent(nameNodeA)).isSameInstanceAs(parameterList);
      assertThat(NodeUtil.getDeclaringParent(nameNodeB)).isSameInstanceAs(parameterList);
      assertThat(NodeUtil.getDeclaringParent(nameNodeRest)).isSameInstanceAs(parameterList);
    }

    @Test
    public void testDestructuring6() {
      Node root = parse("for ([{a: b}] of c) {}");
      Node forOfNode = root.getFirstChild();
      Node forOfTargetPat = forOfNode.getFirstChild();
      Node innerPat = forOfTargetPat.getFirstChild();
      checkState(innerPat.isObjectPattern(), innerPat);
      checkState(forOfTargetPat.isArrayPattern(), forOfTargetPat);

      Node strKeyNodeA = innerPat.getFirstChild();
      Node nameNodeB = strKeyNodeA.getFirstChild();
      Node nameNodeC = innerPat.getParent().getNext();
      checkState(strKeyNodeA.getString().equals("a"), strKeyNodeA);
      checkState(nameNodeB.getString().equals("b"), nameNodeB);
      checkState(nameNodeC.getString().equals("c"), nameNodeC);

      assertNotLhsByDestructuring(strKeyNodeA);
      assertLhsByDestructuring(nameNodeB);
      assertNotLhsByDestructuring(nameNodeC);

      assertThat(NodeUtil.getRootTarget(forOfTargetPat)).isSameInstanceAs(forOfTargetPat);
      assertThat(NodeUtil.getRootTarget(innerPat)).isSameInstanceAs(forOfTargetPat);
      assertThat(NodeUtil.getRootTarget(nameNodeB)).isSameInstanceAs(forOfTargetPat);
    }

    @Test
    public void testDestructuring6b() {
      Node root = parse("for ([{a: b}] in c) {}");
      Node forInNode = root.getFirstChild();
      Node forInTargetPat = forInNode.getFirstChild();
      Node innerPat = forInTargetPat.getFirstChild();
      checkState(innerPat.isObjectPattern(), innerPat);
      checkState(forInTargetPat.isArrayPattern(), forInTargetPat);

      Node strKeyNodeA = innerPat.getFirstChild();
      Node nameNodeB = strKeyNodeA.getFirstChild();
      Node nameNodeC = innerPat.getParent().getNext();
      checkState(strKeyNodeA.getString().equals("a"), strKeyNodeA);
      checkState(nameNodeB.getString().equals("b"), nameNodeB);
      checkState(nameNodeC.getString().equals("c"), nameNodeC);

      assertNotLhsByDestructuring(strKeyNodeA);
      assertLhsByDestructuring(nameNodeB);
      assertNotLhsByDestructuring(nameNodeC);

      assertThat(NodeUtil.getRootTarget(forInTargetPat)).isSameInstanceAs(forInTargetPat);
      assertThat(NodeUtil.getRootTarget(innerPat)).isSameInstanceAs(forInTargetPat);
      assertThat(NodeUtil.getRootTarget(nameNodeB)).isSameInstanceAs(forInTargetPat);
    }

    @Test
    public void testDestructuring6c() {
      Node root = parse("for (var [{a: b}] = [{a: 1}];;) {}");
      Node varNode = root.getFirstFirstChild();
      Node destructArr = varNode.getFirstFirstChild();
      checkState(destructArr.isArrayPattern(), destructArr);
      Node destructPat = destructArr.getFirstChild();
      checkState(destructPat.isObjectPattern(), destructPat);

      Node strKeyNodeA = destructPat.getFirstChild();
      Node nameNodeB = strKeyNodeA.getFirstChild();
      checkState(strKeyNodeA.getString().equals("a"), strKeyNodeA);
      checkState(nameNodeB.getString().equals("b"), nameNodeB);

      assertNotLhsByDestructuring(strKeyNodeA);
      assertLhsByDestructuring(nameNodeB);

      assertThat(NodeUtil.getRootTarget(destructArr)).isSameInstanceAs(destructArr);
      assertThat(NodeUtil.getRootTarget(destructPat)).isSameInstanceAs(destructArr);
      assertThat(NodeUtil.getRootTarget(nameNodeB)).isSameInstanceAs(destructArr);

      assertThat(NodeUtil.getDeclaringParent(nameNodeB)).isSameInstanceAs(varNode);
    }

    @Test
    public void testDestructuring7() {
      Node root = parse("for ([a] of c) {}");
      Node destructPat = root.getFirstFirstChild();
      checkState(destructPat.isArrayPattern(), destructPat);

      Node nameNodeA = destructPat.getFirstChild();
      Node nameNodeC = destructPat.getNext();
      checkState(nameNodeA.getString().equals("a"), nameNodeA);
      checkState(nameNodeC.getString().equals("c"), nameNodeC);

      assertLhsByDestructuring(nameNodeA);
      assertNotLhsByDestructuring(nameNodeC);

      assertThat(NodeUtil.getRootTarget(destructPat)).isSameInstanceAs(destructPat);
      assertThat(NodeUtil.getRootTarget(nameNodeA)).isSameInstanceAs(destructPat);
    }

    @Test
    public void testDestructuring7b() {
      Node root = parse("for ([a] in c) {}");
      Node destructPat = root.getFirstFirstChild();
      checkState(destructPat.isArrayPattern(), destructPat);

      Node nameNodeA = destructPat.getFirstChild();
      Node nameNodeC = destructPat.getNext();
      checkState(nameNodeA.getString().equals("a"), nameNodeA);
      checkState(nameNodeC.getString().equals("c"), nameNodeC);

      assertLhsByDestructuring(nameNodeA);
      assertNotLhsByDestructuring(nameNodeC);

      assertThat(NodeUtil.getRootTarget(destructPat)).isSameInstanceAs(destructPat);
      assertThat(NodeUtil.getRootTarget(nameNodeA)).isSameInstanceAs(destructPat);
    }

    @Test
    public void testDestructuring7c() {
      Node root = parse("for (var [a] = [1];;) {}");
      Node varNode = root.getFirstFirstChild();
      Node destructLhs = varNode.getFirstChild();
      checkState(destructLhs.isDestructuringLhs(), destructLhs);
      Node destructPat = destructLhs.getFirstChild();
      checkState(destructPat.isArrayPattern(), destructPat);

      Node nameNodeA = destructPat.getFirstChild();
      checkState(nameNodeA.getString().equals("a"), nameNodeA);

      assertLhsByDestructuring(nameNodeA);

      assertThat(NodeUtil.getRootTarget(destructPat)).isSameInstanceAs(destructPat);
      assertThat(NodeUtil.getRootTarget(nameNodeA)).isSameInstanceAs(destructPat);

      assertThat(NodeUtil.getDeclaringParent(nameNodeA)).isSameInstanceAs(varNode);
    }

    @Test
    public void testDestructuring7d() {
      Node root = parse("for (let [a] = [1];;) {}");
      Node letNode = root.getFirstFirstChild();
      Node destructLhs = letNode.getFirstChild();
      checkState(destructLhs.isDestructuringLhs(), destructLhs);
      Node destructPat = destructLhs.getFirstChild();
      checkState(destructPat.isArrayPattern(), destructPat);

      Node nameNodeA = destructPat.getFirstChild();
      checkState(nameNodeA.getString().equals("a"), nameNodeA);

      assertLhsByDestructuring(nameNodeA);

      assertThat(NodeUtil.getRootTarget(destructPat)).isSameInstanceAs(destructPat);
      assertThat(NodeUtil.getRootTarget(nameNodeA)).isSameInstanceAs(destructPat);

      assertThat(NodeUtil.getDeclaringParent(nameNodeA)).isSameInstanceAs(letNode);
    }

    @Test
    public void testDestructuring7e() {
      Node root = parse("for (const [a] = [1];;) {}");
      Node constNode = root.getFirstFirstChild();
      Node destructLhs = constNode.getFirstChild();
      checkState(destructLhs.isDestructuringLhs(), destructLhs);
      Node destructPat = destructLhs.getFirstChild();
      checkState(destructPat.isArrayPattern(), destructPat);

      Node nameNodeA = destructPat.getFirstChild();
      checkState(nameNodeA.getString().equals("a"), nameNodeA);

      assertLhsByDestructuring(nameNodeA);

      assertThat(NodeUtil.getRootTarget(destructPat)).isSameInstanceAs(destructPat);
      assertThat(NodeUtil.getRootTarget(nameNodeA)).isSameInstanceAs(destructPat);

      assertThat(NodeUtil.getDeclaringParent(nameNodeA)).isSameInstanceAs(constNode);
    }

    @Test
    public void testDestructuring8() {
      Node root = parse("var [...a] = obj;");
      Node varNode = root.getFirstChild();
      Node destructLhs = varNode.getFirstChild();
      checkState(destructLhs.isDestructuringLhs(), destructLhs);
      Node destructPat = destructLhs.getFirstChild();
      checkState(destructPat.isArrayPattern(), destructPat);
      Node restNode = destructPat.getFirstChild();
      checkState(restNode.isRest(), restNode);

      Node nameNodeA = restNode.getFirstChild();
      checkState(nameNodeA.getString().equals("a"), nameNodeA);

      assertLhsByDestructuring(nameNodeA);

      assertThat(NodeUtil.getRootTarget(destructPat)).isSameInstanceAs(destructPat);
      assertThat(NodeUtil.getRootTarget(nameNodeA)).isSameInstanceAs(destructPat);

      assertThat(NodeUtil.getDeclaringParent(nameNodeA)).isSameInstanceAs(varNode);
    }

    @Test
    public void testDestructuring8b() {
      Node root = parse("([...this.x] = obj);");
      Node assign = root.getFirstFirstChild();
      checkState(assign.isAssign(), assign);
      Node destructPat = assign.getFirstChild();
      checkState(destructPat.isArrayPattern(), destructPat);
      Node restNode = destructPat.getFirstChild();
      checkState(restNode.isRest(), restNode);
      Node getProp = restNode.getFirstChild();
      checkState(getProp.isGetProp(), getProp);

      assertLhsByDestructuring(getProp);

      assertThat(NodeUtil.getRootTarget(destructPat)).isSameInstanceAs(destructPat);
      assertThat(NodeUtil.getRootTarget(getProp)).isSameInstanceAs(destructPat);
    }

    @Test
    public void testDestructuring9() {
      Node root = parse("var {['a']:a} = obj;");
      Node varNode = root.getFirstChild();
      Node destructLhs = varNode.getFirstChild();
      checkState(destructLhs.isDestructuringLhs(), destructLhs);
      Node destructPat = destructLhs.getFirstChild();
      checkState(destructPat.isObjectPattern(), destructPat);
      Node computedPropNode = destructPat.getFirstChild();
      checkState(computedPropNode.isComputedProp(), computedPropNode);

      Node nameNodeA = computedPropNode.getLastChild();
      checkState(nameNodeA.getString().equals("a"), nameNodeA);

      assertLhsByDestructuring(nameNodeA);

      assertThat(NodeUtil.getRootTarget(destructPat)).isSameInstanceAs(destructPat);
      assertThat(NodeUtil.getRootTarget(nameNodeA)).isSameInstanceAs(destructPat);

      assertThat(NodeUtil.getDeclaringParent(nameNodeA)).isSameInstanceAs(varNode);
    }

    @Test
    public void testDestructuringComputedPropertyWithDefault() {
      Node root = parse("var {['a']: a = 1} = obj;");
      Node varNode = root.getFirstChild();
      Node destructLhs = varNode.getFirstChild();
      checkState(destructLhs.isDestructuringLhs(), destructLhs);
      Node destructPat = destructLhs.getFirstChild();
      checkState(destructPat.isObjectPattern(), destructPat);
      Node computedPropNode = destructPat.getFirstChild();
      checkState(computedPropNode.isComputedProp(), computedPropNode);

      Node defaultValueNode = computedPropNode.getLastChild();
      Node nameNodeA = defaultValueNode.getFirstChild();
      checkState(nameNodeA.getString().equals("a"), nameNodeA);

      assertLhsByDestructuring(nameNodeA);

      assertThat(NodeUtil.getRootTarget(destructPat)).isSameInstanceAs(destructPat);
      assertThat(NodeUtil.getRootTarget(nameNodeA)).isSameInstanceAs(destructPat);

      assertThat(NodeUtil.getDeclaringParent(nameNodeA)).isSameInstanceAs(varNode);
    }

    @Test
    public void testDestructuringWithArrayPatternInCatch() {
      Node actual = parse("try {} catch([a]) {}");

      Node tryNode = actual.getFirstChild();
      Node catchBlock = tryNode.getSecondChild();
      Node catchNode = catchBlock.getFirstChild();
      assertNode(catchNode).hasType(Token.CATCH);

      Node arrayPattern = catchNode.getFirstChild();
      Node nameNodeA = arrayPattern.getOnlyChild();
      assertNode(nameNodeA).isName("a");

      assertLhsByDestructuring(nameNodeA);

      assertThat(NodeUtil.getRootTarget(arrayPattern)).isSameInstanceAs(arrayPattern);
      assertThat(NodeUtil.getRootTarget(nameNodeA)).isSameInstanceAs(arrayPattern);

      assertThat(NodeUtil.getDeclaringParent(nameNodeA)).isSameInstanceAs(catchNode);
    }

    @Test
    public void testDestructuringObjectRest() {
      Node root = parse("var {...rest} = obj;");
      Node varNode = root.getFirstChild();
      Node destructLhs = varNode.getFirstChild();
      checkState(destructLhs.isDestructuringLhs(), destructLhs);
      Node destructPat = destructLhs.getFirstChild();
      checkState(destructPat.isObjectPattern(), destructPat);

      Node restNode = destructPat.getFirstChild();
      Node nameNodeRest = restNode.getFirstChild();
      checkState(nameNodeRest.getString().equals("rest"), nameNodeRest);

      Node nameNodeObj = destructPat.getNext();
      checkState(nameNodeObj.getString().equals("obj"), nameNodeObj);

      assertNotLhsByDestructuring(restNode);
      assertLhsByDestructuring(nameNodeRest);
      assertNotLhsByDestructuring(nameNodeObj);

      assertThat(NodeUtil.getRootTarget(destructPat)).isSameInstanceAs(destructPat);
      assertThat(NodeUtil.getRootTarget(nameNodeRest)).isSameInstanceAs(destructPat);

      assertThat(NodeUtil.getDeclaringParent(nameNodeRest)).isSameInstanceAs(varNode);
    }

    private static void assertLhsByDestructuring(Node n) {
      assertThat(NodeUtil.isLhsByDestructuring(n)).isTrue();
    }

    private static void assertNotLhsByDestructuring(Node n) {
      assertThat(NodeUtil.isLhsByDestructuring(n)).isFalse();
    }

    @Test
    public void testNewQName1() {
      Compiler compiler = new Compiler();
      CompilerOptions options = new CompilerOptions();
      options.setCodingConvention(new GoogleCodingConvention());
      compiler.init(ImmutableList.<SourceFile>of(), ImmutableList.<SourceFile>of(), options);
      Node actual = NodeUtil.newQName(compiler, "ns.prop");
      Node expected = IR.getprop(IR.name("ns"), IR.string("prop"));
      assertNode(actual).isEqualTo(expected);
    }

    @Test
    public void testNewQualifiedNameNode2() {
      Compiler compiler = new Compiler();
      CompilerOptions options = new CompilerOptions();
      options.setCodingConvention(new GoogleCodingConvention());
      compiler.init(ImmutableList.<SourceFile>of(), ImmutableList.<SourceFile>of(), options);
      Node actual = NodeUtil.newQName(compiler, "this.prop");
      Node expected = IR.getprop(IR.thisNode(), IR.string("prop"));
      assertNode(actual).isEqualTo(expected);
    }

    @Test
    public void testNewQNameDeclarationWithQualifiedName() {
      assertNode(createNewQNameDeclaration("ns.prop", IR.number(0), Token.VAR))
          .isEqualTo(
              IR.exprResult(IR.assign(IR.getprop(IR.name("ns"), IR.string("prop")), IR.number(0))));
    }

    @Test
    public void testNewQNameDeclarationWithVar() {
      assertNode(createNewQNameDeclaration("x", IR.number(0), Token.VAR))
          .isEqualTo(IR.var(IR.name("x"), IR.number(0)));
    }

    @Test
    public void testNewQNameDeclarationWithLet() {
      assertNode(createNewQNameDeclaration("x", IR.number(0), Token.LET))
          .isEqualTo(IR.let(IR.name("x"), IR.number(0)));
    }

    @Test
    public void testNewQNameDeclarationWithConst() {
      assertNode(createNewQNameDeclaration("x", IR.number(0), Token.CONST))
          .isEqualTo(IR.constNode(IR.name("x"), IR.number(0)));
    }

    private Node createNewQNameDeclaration(String name, Node value, Token type) {
      Compiler compiler = new Compiler();
      CompilerOptions options = new CompilerOptions();
      options.setCodingConvention(new GoogleCodingConvention());
      compiler.init(ImmutableList.<SourceFile>of(), ImmutableList.<SourceFile>of(), options);
      return NodeUtil.newQNameDeclaration(compiler, name, value, null, type);
    }

    @Test
    public void testGetBestJsDocInfoForClasses() {
      Node classNode = parseFirst(CLASS, "/** @export */ class Foo {}");
      assertThat(NodeUtil.getBestJSDocInfo(classNode).isExport()).isTrue();

      classNode = parseFirst(CLASS, "/** @export */ var Foo = class {}");
      assertThat(NodeUtil.getBestJSDocInfo(classNode).isExport()).isTrue();

      classNode = parseFirst(CLASS, "/** @export */ var Foo = class Bar {}");
      assertThat(NodeUtil.getBestJSDocInfo(classNode).isExport()).isTrue();
    }

    @Test
    public void testGetBestJsDocInfoForMethods() {
      Node function = parseFirst(FUNCTION, "class C { /** @export */ foo() {} }");
      assertThat(NodeUtil.getBestJSDocInfo(function).isExport()).isTrue();

      function = parseFirst(FUNCTION, "class C { /** @export */ [computedMethod]() {} }");
      assertThat(NodeUtil.getBestJSDocInfo(function).isExport()).isTrue();
    }

    @Test
    public void testGetBestJsDocInfoExport() {
      Node classNode = parseFirst(CLASS, "/** @constructor */ export class Foo {}");
      assertThat(NodeUtil.getBestJSDocInfo(classNode).isConstructor()).isTrue();

      Node function = parseFirst(FUNCTION, "/** @constructor */ export function Foo() {}");
      assertThat(NodeUtil.getBestJSDocInfo(function).isConstructor()).isTrue();

      function = parseFirst(FUNCTION, "/** @constructor */ export var Foo = function() {}");
      assertThat(NodeUtil.getBestJSDocInfo(function).isConstructor()).isTrue();

      function = parseFirst(FUNCTION, "/** @constructor */ export let Foo = function() {}");
      assertThat(NodeUtil.getBestJSDocInfo(function).isConstructor()).isTrue();
    }

    @Test
    public void testGetDeclaredTypeExpression1() {
      Node ast = parse("function f(/** string */ x) {}");
      Node x = getNameNode(ast, "x");
      JSTypeExpression typeExpr = NodeUtil.getDeclaredTypeExpression(x);
      assertThat(typeExpr.getRoot().getString()).isEqualTo("string");
    }

    @Test
    public void testGetDeclaredTypeExpression2() {
      Node ast = parse("/** @param {string} x */ function f(x) {}");
      Node x = getNameNode(ast, "x");
      JSTypeExpression typeExpr = NodeUtil.getDeclaredTypeExpression(x);
      assertThat(typeExpr.getRoot().getString()).isEqualTo("string");
    }

    @Test
    public void testGetDeclaredTypeExpression3() {
      Node ast = parse("/** @param {...number} x */ function f(...x) {}");
      Node x = getNameNode(ast, "x");
      JSTypeExpression typeExpr = NodeUtil.getDeclaredTypeExpression(x);
      assertNode(typeExpr.getRoot()).hasType(Token.ELLIPSIS);
      assertThat(typeExpr.getRoot().getFirstChild().getString()).isEqualTo("number");
    }

    @Test
    public void testGetDeclaredTypeExpression4() {
      Node ast = parse("/** @param {number=} x */ function f(x = -1) {}");
      Node x = getNameNode(ast, "x");
      JSTypeExpression typeExpr = NodeUtil.getDeclaredTypeExpression(x);
      assertNode(typeExpr.getRoot()).hasType(Token.EQUALS);
      assertThat(typeExpr.getRoot().getFirstChild().getString()).isEqualTo("number");
    }

    @Test
    public void testFindLhsNodesInNodeWithNameDeclaration() {
      assertThat(findLhsNodesInNode("var x;")).hasSize(1);
      assertThat(findLhsNodesInNode("var x, y;")).hasSize(2);
      assertThat(findLhsNodesInNode("var f = function(x, y, z) {};")).hasSize(1);
    }

    @Test
    public void testFindLhsNodesInNodeWithArrayPatternDeclaration() {
      assertThat(findLhsNodesInNode("var [x=a => a, y = b=>b+1] = arr;")).hasSize(2);
      assertThat(findLhsNodesInNode("var [x=a => a, y = b=>b+1, ...z] = arr;")).hasSize(3);
      assertThat(findLhsNodesInNode("var [ , , , y = b=>b+1, ...z] = arr;")).hasSize(2);
    }

    @Test
    public void testFindLhsNodesInNodeWithObjectPatternDeclaration() {
      assertThat(findLhsNodesInNode("var {x = a=>a, y = b=>b+1} = obj;")).hasSize(2);
      assertThat(findLhsNodesInNode("var {p1: x = a=>a, p2: y = b=>b+1} = obj;")).hasSize(2);
      assertThat(findLhsNodesInNode("var {[pname]: x = a=>a, [p2name]: y} = obj;")).hasSize(2);
      assertThat(findLhsNodesInNode("var {lhs1 = a, p2: [lhs2, lhs3 = b] = [notlhs]} = obj;"))
          .hasSize(3);
    }

    @Test
    public void testFindLhsNodesInNodeWithCastOnLhs() {
      Iterable<Node> lhsNodes = findLhsNodesInNode("/** @type {*} */ (a.b) = 3;");
      assertThat(lhsNodes).hasSize(1);
      Iterator<Node> nodeIterator = lhsNodes.iterator();
      assertNode(nodeIterator.next()).matchesQualifiedName("a.b");
    }

    @Test
    public void testFindLhsNodesInNodeWithArrayPatternAssign() {
      assertThat(findLhsNodesInNode("[this.x] = rhs;")).hasSize(1);
      assertThat(findLhsNodesInNode("[this.x, y] = rhs;")).hasSize(2);
      assertThat(findLhsNodesInNode("[this.x, y, this.z] = rhs;")).hasSize(3);
      assertThat(findLhsNodesInNode("[y, this.z] = rhs;")).hasSize(2);
      assertThat(findLhsNodesInNode("[x[y]] = rhs;")).hasSize(1);
      assertThat(findLhsNodesInNode("[x.y.z] = rhs;")).hasSize(1);
      assertThat(findLhsNodesInNode("[ /** @type {*} */ (x.y.z) ] = rhs;")).hasSize(1);
    }

    @Test
    public void testFindLhsNodesInNodeWithComplexAssign() {
      assertThat(findLhsNodesInNode("x += 1;")).hasSize(1);
      assertThat(findLhsNodesInNode("x.y += 1;")).hasSize(1);
      assertThat(findLhsNodesInNode("x -= 1;")).hasSize(1);
      assertThat(findLhsNodesInNode("x.y -= 1;")).hasSize(1);
      assertThat(findLhsNodesInNode("x *= 2;")).hasSize(1);
      assertThat(findLhsNodesInNode("x.y *= 2;")).hasSize(1);
    }

    @Test
    public void testFindLhsNodesInForOfWithDeclaration() {
      Iterable<Node> lhsNodes = findLhsNodesInNode("for (const {x, y} of iterable) {}");
      assertThat(lhsNodes).hasSize(2);
      Iterator<Node> nodeIterator = lhsNodes.iterator();
      assertNode(nodeIterator.next()).isName("x");
      assertNode(nodeIterator.next()).isName("y");
    }

    @Test
    public void testFindLhsNodesInForOfWithoutDeclaration() {
      Iterable<Node> lhsNodes = findLhsNodesInNode("for ({x, y: a.b} of iterable) {}");
      assertThat(lhsNodes).hasSize(2);
      Iterator<Node> nodeIterator = lhsNodes.iterator();
      assertNode(nodeIterator.next()).isName("x");
      assertNode(nodeIterator.next()).matchesQualifiedName("a.b");
    }

    @Test
    public void testFindLhsNodesInForInWithDeclaration() {
      Iterable<Node> lhsNodes = findLhsNodesInNode("for (const x in obj) {}");
      assertThat(lhsNodes).hasSize(1);
      Iterator<Node> nodeIterator = lhsNodes.iterator();
      assertNode(nodeIterator.next()).isName("x");
    }

    @Test
    public void testFindLhsNodesInForInWithoutDeclaration() {
      Iterable<Node> lhsNodes = findLhsNodesInNode("for (a.b in iterable) {}");
      assertThat(lhsNodes).hasSize(1);
      Iterator<Node> nodeIterator = lhsNodes.iterator();
      assertNode(nodeIterator.next()).matchesQualifiedName("a.b");
    }

    @Test
    public void testIsConstructor() {
      assertThat(
              NodeUtil.isConstructor(parseFirst(FUNCTION, "/** @constructor */ function Foo() {}")))
          .isTrue();
      assertThat(
              NodeUtil.isConstructor(
                  parseFirst(FUNCTION, "/** @constructor */ var Foo = function() {}")))
          .isTrue();
      assertThat(
              NodeUtil.isConstructor(
                  parseFirst(FUNCTION, "var x = {}; /** @constructor */ x.Foo = function() {}")))
          .isTrue();
      assertThat(NodeUtil.isConstructor(parseFirst(FUNCTION, "class Foo { constructor() {} }")))
          .isTrue();
      assertThat(
              NodeUtil.isConstructor(parseFirst(FUNCTION, "class Foo { static constructor() {} }")))
          .isFalse();
      assertThat(NodeUtil.isConstructor(parseFirst(FUNCTION, "let Foo = { constructor() {} }")))
          .isFalse();

      assertThat(NodeUtil.isConstructor(parseFirst(FUNCTION, "function Foo() {}"))).isFalse();
      assertThat(NodeUtil.isConstructor(parseFirst(FUNCTION, "var Foo = function() {}"))).isFalse();
      assertThat(NodeUtil.isConstructor(parseFirst(FUNCTION, "var x = {}; x.Foo = function() {};")))
          .isFalse();
      assertThat(NodeUtil.isConstructor(parseFirst(FUNCTION, "function constructor() {}")))
          .isFalse();
      assertThat(NodeUtil.isConstructor(parseFirst(FUNCTION, "class Foo { bar() {} }"))).isFalse();
    }

    @Test
    public void testGetEs6ClassConstructorMemberFunctionDef() {
      // distinguish between static and non-static method named "constructor"
      Node constructorMemberFunctionDef =
          NodeUtil.getEs6ClassConstructorMemberFunctionDef(
              parseFirst(
                  CLASS, "class Foo { method() {} constructor() {} static constructor() {} };"));
      assertNode(constructorMemberFunctionDef).isMemberFunctionDef("constructor");
      assertThat(constructorMemberFunctionDef.isStaticMember()).isFalse();

      // static method named "constructor" will not be returned as the constructor
      constructorMemberFunctionDef =
          NodeUtil.getEs6ClassConstructorMemberFunctionDef(
              parseFirst(CLASS, "class Foo { method() {} static constructor() {} }"));
      assertThat(constructorMemberFunctionDef).isNull();
    }

    @Test
    public void testIsGetterOrSetter() {
      Node fnNode =
          parseFirst(FUNCTION, "Object.defineProperty(this, 'bar', {get: function() {}});");
      assertThat(NodeUtil.isGetterOrSetter(fnNode.getParent())).isTrue();

      fnNode = parseFirst(FUNCTION, "Object.defineProperty(this, 'bar', {set: function() {}});");
      assertThat(NodeUtil.isGetterOrSetter(fnNode.getParent())).isTrue();

      fnNode = parseFirst(FUNCTION, "Object.defineProperties(this, {bar: {get: function() {}}});");
      assertThat(NodeUtil.isGetterOrSetter(fnNode.getParent())).isTrue();

      fnNode = parseFirst(FUNCTION, "Object.defineProperties(this, {bar: {set: function() {}}});");
      assertThat(NodeUtil.isGetterOrSetter(fnNode.getParent())).isTrue();

      fnNode = parseFirst(FUNCTION, "var x = {get bar() {}};");
      assertThat(NodeUtil.isGetterOrSetter(fnNode.getParent())).isTrue();

      fnNode = parseFirst(FUNCTION, "var x = {set bar(z) {}};");
      assertThat(NodeUtil.isGetterOrSetter(fnNode.getParent())).isTrue();
    }

    @Test
    public void testIsObjectDefinePropertiesDefinition() {
      assertThat(
              NodeUtil.isObjectDefinePropertiesDefinition(
                  parseFirst(CALL, "Object.defineProperties(this, {});")))
          .isTrue();
      assertThat(
              NodeUtil.isObjectDefinePropertiesDefinition(
                  parseFirst(CALL, "Object.defineProperties(this, foo);")))
          .isTrue();
      assertThat(
              NodeUtil.isObjectDefinePropertiesDefinition(
                  parseFirst(CALL, "$jscomp.global.Object.defineProperties(this, foo);")))
          .isTrue();
      assertThat(
              NodeUtil.isObjectDefinePropertiesDefinition(
                  parseFirst(CALL, "$jscomp$global.Object.defineProperties(this, foo);")))
          .isTrue();

      assertThat(
              NodeUtil.isObjectDefinePropertiesDefinition(
                  parseFirst(CALL, "Object.defineProperties(this, {}, foo);")))
          .isFalse();
      assertThat(
              NodeUtil.isObjectDefinePropertiesDefinition(
                  parseFirst(CALL, "Object.defineProperties(this);")))
          .isFalse();
      assertThat(
              NodeUtil.isObjectDefinePropertiesDefinition(
                  parseFirst(CALL, "Object.defineProperties();")))
          .isFalse();
    }

    @Test
    public void testIsObjectDefinePropertyDefinition() {
      assertThat(
              NodeUtil.isObjectDefinePropertyDefinition(
                  parseFirst(CALL, "Object.defineProperty(this, 'foo', {});")))
          .isTrue();
      assertThat(
              NodeUtil.isObjectDefinePropertyDefinition(
                  parseFirst(CALL, "Object.defineProperty(this, 'foo', foo);")))
          .isTrue();
      assertThat(
              NodeUtil.isObjectDefinePropertyDefinition(
                  parseFirst(CALL, "$jscomp.global.Object.defineProperty(this, 'foo', foo);")))
          .isTrue();
      assertThat(
              NodeUtil.isObjectDefinePropertyDefinition(
                  parseFirst(CALL, "$jscomp$global.Object.defineProperty(this, 'foo', foo);")))
          .isTrue();

      assertThat(
              NodeUtil.isObjectDefinePropertyDefinition(
                  parseFirst(CALL, "Object.defineProperty(this, {});")))
          .isFalse();
      assertThat(
              NodeUtil.isObjectDefinePropertyDefinition(
                  parseFirst(CALL, "Object.defineProperty(this);")))
          .isFalse();
      assertThat(
              NodeUtil.isObjectDefinePropertyDefinition(
                  parseFirst(CALL, "Object.defineProperty();")))
          .isFalse();
    }

    @Test
    public void testGetAllVars1() {
      String fnString = "var h; function g(x, y) {var z; h = 2; {let a; const b = 1} let c}";
      Compiler compiler = new Compiler();
      compiler.setLifeCycleStage(LifeCycleStage.NORMALIZED);
      Es6SyntacticScopeCreator scopeCreator = new Es6SyntacticScopeCreator(compiler);

      Node ast = parse(fnString);
      Node functionNode = parseFirst(FUNCTION, fnString);

      Scope globalScope = Scope.createGlobalScope(ast);
      Scope functionScope = scopeCreator.createScope(functionNode, globalScope);

      Map<String, Var> allVariables = new HashMap<>();
      List<Var> orderedVars = new ArrayList<>();
      NodeUtil.getAllVarsDeclaredInFunction(
          allVariables, orderedVars, compiler, scopeCreator, functionScope);

      assertThat(allVariables.keySet()).containsExactly("a", "b", "c", "z", "x", "y");
    }

    @Test
    public void testGetAllVars2() {
      String fnString =
          "function g(x, y) "
              + "{var z; "
              + "{let a = (no1, no2) => { let no6, no7; }; "
              + "const b = 1} "
              + "let c} "
              + "function u(h) {let e}";

      Compiler compiler = new Compiler();
      compiler.setLifeCycleStage(LifeCycleStage.NORMALIZED);
      Es6SyntacticScopeCreator scopeCreator = new Es6SyntacticScopeCreator(compiler);

      Node ast = parse(fnString);
      Node functionNode = parseFirst(FUNCTION, fnString);

      Scope globalScope = Scope.createGlobalScope(ast);
      Scope functionScope = scopeCreator.createScope(functionNode, globalScope);

      Map<String, Var> allVariables = new HashMap<>();
      List<Var> orderedVars = new ArrayList<>();
      NodeUtil.getAllVarsDeclaredInFunction(
          allVariables, orderedVars, compiler, scopeCreator, functionScope);

      assertThat(allVariables.keySet()).containsExactly("x", "y", "z", "a", "b", "c");
    }

    @Test
    public void testIsVarArgs() {
      assertThat(
              NodeUtil.doesFunctionReferenceOwnArgumentsObject(
                  parseExpr("function() {return () => arguments}")))
          .isTrue();
      assertThat(NodeUtil.doesFunctionReferenceOwnArgumentsObject(parseExpr("() => arguments")))
          .isFalse();
    }

    /**
     * When the left side is a destructuring pattern, generally it's not possible to identify the
     * RHS for a specific name on the LHS.
     */
    @Test
    public void testIsExpressionResultUsed() {
      assertThat(NodeUtil.isExpressionResultUsed(getNameNodeFrom("for (x in y) z", "x"))).isTrue();
      assertThat(NodeUtil.isExpressionResultUsed(getNameNodeFrom("for (x in y) z", "y"))).isTrue();
      assertThat(NodeUtil.isExpressionResultUsed(getNameNodeFrom("for (x in y) z", "z"))).isFalse();

      assertThat(NodeUtil.isExpressionResultUsed(getNameNodeFrom("for (x of y) z", "x"))).isTrue();
      assertThat(NodeUtil.isExpressionResultUsed(getNameNodeFrom("for (x of y) z", "y"))).isTrue();
      assertThat(NodeUtil.isExpressionResultUsed(getNameNodeFrom("for (x of y) z", "z"))).isFalse();

      assertThat(NodeUtil.isExpressionResultUsed(getNameNodeFrom("for (x; y; z) a", "x")))
          .isFalse();
      assertThat(NodeUtil.isExpressionResultUsed(getNameNodeFrom("for (x; y; z) a", "y"))).isTrue();
      assertThat(NodeUtil.isExpressionResultUsed(getNameNodeFrom("for (x; y; z) a", "z")))
          .isFalse();

      assertThat(NodeUtil.isExpressionResultUsed(getNameNodeFrom("function f() { return y }", "y")))
          .isTrue();
      assertThat(NodeUtil.isExpressionResultUsed(getNameNodeFrom("function f() { y }", "y")))
          .isFalse();

      assertThat(NodeUtil.isExpressionResultUsed(getNameNodeFrom("var x = ()=> y", "y"))).isTrue();
      assertThat(NodeUtil.isExpressionResultUsed(getNameNodeFrom("var x = ()=>{ y }", "y")))
          .isFalse();

      assertThat(NodeUtil.isExpressionResultUsed(getNameNodeFrom("({a: x = y} = z)", "y")))
          .isTrue();
      assertThat(NodeUtil.isExpressionResultUsed(getNameNodeFrom("[x = y] = z", "y"))).isTrue();

      assertThat(NodeUtil.isExpressionResultUsed(getNameNodeFrom("({x: y})", "y"))).isTrue();
      assertThat(NodeUtil.isExpressionResultUsed(getNameNodeFrom("[y]", "y"))).isTrue();

      assertThat(NodeUtil.isExpressionResultUsed(getNameNodeFrom("y()", "y"))).isTrue();
      assertThat(NodeUtil.isExpressionResultUsed(getNameNodeFrom("y``", "y"))).isTrue();
    }

    @Test
    public void testIsSimpleOperator() {
      assertThat(NodeUtil.isSimpleOperator(parseExpr("!x"))).isTrue();
      assertThat(NodeUtil.isSimpleOperator(parseExpr("5 + x"))).isTrue();
      assertThat(NodeUtil.isSimpleOperator(parseExpr("typeof x"))).isTrue();
      assertThat(NodeUtil.isSimpleOperator(parseExpr("x instanceof y"))).isTrue();
      // short curcuits aren't simple
      assertThat(NodeUtil.isSimpleOperator(parseExpr("5 && x"))).isFalse();
      assertThat(NodeUtil.isSimpleOperator(parseExpr("5 || x"))).isFalse();
      // side-effects aren't simple
      assertThat(NodeUtil.isSimpleOperator(parseExpr("x = 5"))).isFalse();
      assertThat(NodeUtil.isSimpleOperator(parseExpr("x++"))).isFalse();
      assertThat(NodeUtil.isSimpleOperator(parseExpr("--y"))).isFalse();
      // prop access are simple
      assertThat(NodeUtil.isSimpleOperator(parseExpr("y in x"))).isTrue();
      assertThat(NodeUtil.isSimpleOperator(parseExpr("x.y"))).isTrue();
      assertThat(NodeUtil.isSimpleOperator(parseExpr("x[y]"))).isTrue();
    }

    @Test
    public void testIsCallToString() {
      assertThat(NodeUtil.isCallTo(parseFirst(CALL, "foo()"), "foo")).isTrue();
      assertThat(NodeUtil.isCallTo(parseFirst(CALL, "foo.bar()"), "foo.bar")).isTrue();

      assertThat(NodeUtil.isCallTo(IR.name("foo"), "foo")).isFalse();
      assertThat(NodeUtil.isCallTo(IR.getprop(IR.name("foo"), IR.string("bar")), "foo.bar"))
          .isFalse();
      assertThat(NodeUtil.isCallTo(parseFirst(CALL, "foo.bar()"), "foo")).isFalse();
      assertThat(NodeUtil.isCallTo(parseFirst(CALL, "foo[0]()"), "foo")).isFalse();
    }

    @Test
    public void testIsCallToNode() {
      assertThat(NodeUtil.isCallTo(parseFirst(CALL, "foo()"), IR.name("foo"))).isTrue();
      assertThat(
              NodeUtil.isCallTo(
                  parseFirst(CALL, "foo.bar()"), IR.getprop(IR.name("foo"), IR.string("bar"))))
          .isTrue();

      assertThat(NodeUtil.isCallTo(IR.name("foo"), IR.name("foo"))).isFalse();
      assertThat(
              NodeUtil.isCallTo(
                  IR.getprop(IR.name("foo"), IR.string("bar")),
                  IR.getprop(IR.name("foo"), IR.string("bar"))))
          .isFalse();
      assertThat(NodeUtil.isCallTo(parseFirst(CALL, "foo.bar()"), IR.name("foo"))).isFalse();
      assertThat(NodeUtil.isCallTo(parseFirst(CALL, "foo[0]()"), IR.name("foo"))).isFalse();
    }

    @Test
    public void testIsBundledGoogModule() {
      Node googLoadModule =
          parse("goog.loadModule(function(exports) { goog.module('a.b'); return exports; });");

      Node googName = getNameNode(googLoadModule, "goog");
      Node callNode = googName.getGrandparent();

      assertNode(callNode).hasToken(Token.CALL);
      assertThat(NodeUtil.isBundledGoogModuleCall(callNode)).isTrue();
    }

    @Test
    public void testIsBundledGoogModule_onlyIfInScript() {
      Node callNode =
          IR.call(
              IR.getprop(IR.name("goog"), IR.string("loadModule")),
              IR.string("imaginary module text here"));

      assertThat(NodeUtil.isBundledGoogModuleCall(callNode)).isFalse();

      Node exprResult = IR.exprResult(callNode);
      assertThat(NodeUtil.isBundledGoogModuleCall(callNode)).isFalse();

      IR.script(exprResult); // Call this for its side effect of modifying `exprResult`.
      assertThat(NodeUtil.isBundledGoogModuleCall(callNode)).isTrue();
    }
  }

  @RunWith(Parameterized.class)
  public static final class ReferencesThisTest {
    @Parameters(name = "{0} node in \"{1}\" referencesThis() should be {2}")
    public static Iterable<Object[]> cases() {
      ImmutableList.Builder<Object[]> builder = ImmutableList.builder();

      builder.add(
          new Object[][] {
            {SCRIPT, "this", TRUE},
            {SCRIPT, "b?this:null", TRUE},
            {SCRIPT, "a", FALSE},
            {SCRIPT, "(b?foo():null)", FALSE},
            {SCRIPT, "() => { () => alert(this); }", TRUE},
          });

      // %s represents the location to fill with an expression that may or may not refer to `this`
      ImmutableList<String> arrowFunctionTemplates =
          ImmutableList.of(
              "      (x = %s) => {}", //
              "      (      ) => %s", //
              "async (x = %s) => {}",
              "async (      ) => %s");

      for (String arrowTemplate : arrowFunctionTemplates) {
        String arrowReferencingThis = SimpleFormat.format(arrowTemplate, "this");
        String arrowWithoutThis = SimpleFormat.format(arrowTemplate, "1");
        builder.add(
            new Object[][] {
              // 'this' in a non-arrow function IS a reference to
              // the 'this' of its enclosing scope
              {SCRIPT, arrowReferencingThis, TRUE},
              {FUNCTION, arrowReferencingThis, TRUE},
              {SCRIPT, arrowWithoutThis, FALSE},
              {FUNCTION, arrowWithoutThis, FALSE},
            });
      }

      // %s represents the location to fill with an expression that may or may not refer to `this`
      ImmutableList<String> nonArrowFunctionTemplates =
          ImmutableList.of(
              "      function  f(x = %s) {     }",
              "      function *f(x = %s) {     }",
              "async function  f(x = %s) {     }",
              "async function *f(x = %s) {     }",
              "      function  f(      ) { %s; }",
              "      function *f(      ) { %s; }",
              "async function  f(      ) { %s; }",
              "async function *f(      ) { %s; }");

      for (String nonArrowTemplate : nonArrowFunctionTemplates) {
        String nonArrowReferencingThis = SimpleFormat.format(nonArrowTemplate, "this");
        String nonArrowWithoutThis = SimpleFormat.format(nonArrowTemplate, "1");
        builder.add(
            new Object[][] {
              // 'this' in a non-arrow function IS NOT a reference to
              // the 'this' of its enclosing scope
              {SCRIPT, nonArrowReferencingThis, FALSE},
              {FUNCTION, nonArrowReferencingThis, TRUE},
              {SCRIPT, nonArrowWithoutThis, FALSE},
              {FUNCTION, nonArrowWithoutThis, FALSE},
            });
      }
      return builder.build();
    }

    @Parameter(0)
    public Token token;

    @Parameter(1)
    public String js;

    @Parameter(2)
    public Boolean expectedResult;

    @Test
    public void test() {
      assertThat(NodeUtil.referencesThis(parseFirst(token, js))).isEqualTo(expectedResult);
    }
  }

  @RunWith(Parameterized.class)
  public static final class GetRValueOfLValueTest {

    @Parameters(name = "{0} in \"{1}\"")
    public static Iterable<Object[]> cases() {
      return ImmutableList.copyOf(
          new Object[][] {
            // CLASS_MEMBERS
            {MEMBER_FUNCTION_DEF, "constructor() { }"},
            {MEMBER_FUNCTION_DEF, "foo() { }"},
            {MEMBER_FUNCTION_DEF, "static foo() { }"},
            {GETTER_DEF, "get foo() { }"},
            {GETTER_DEF, "static get foo() { }"},
            {SETTER_DEF, "set foo(x) { }"},
            {SETTER_DEF, "static set foo(x) { }"},
          });
    }

    @Parameter(0)
    public Token token;

    @Parameter(1)
    public String member;

    @Test
    public void test() {
      Node node = parseFirst(token, "class F { " + member + " }");
      assertNode(NodeUtil.getRValueOfLValue(node)).hasType(Token.FUNCTION);
    }
  }

  @RunWith(Parameterized.class)
  public static final class IteratesImpureIterableTest {

    @Parameters(name = "{0} in \"{1}\"")
    public static Iterable<Object[]> cases() {
      return ImmutableList.copyOf(
          new Object[][] {
            // SPREAD < ARRAYLIT
            {SPREAD, "[...[]]", false},
            {SPREAD, "[...[danger()]]", false},
            {SPREAD, "[...'lit']", false},
            {SPREAD, "[...`template`]", false},
            {SPREAD, "[...`template ${sub}`]", false},
            {SPREAD, "[...`template ${danger()}`]", false},
            {SPREAD, "[...danger]", true},
            {SPREAD, "[...danger()]", true},
            {SPREAD, "[...5]", true},
            // SPREAD < CALL
            {SPREAD, "foo(...[])", false},
            {SPREAD, "foo(...[danger()])", false},
            {SPREAD, "foo(...'lit')", false},
            {SPREAD, "foo(...`template`)", false},
            {SPREAD, "foo(...`template ${safe}`)", false},
            {SPREAD, "foo(...`template ${danger()}`)", false},
            {SPREAD, "foo(...danger)", true},
            {SPREAD, "foo(...danger())", true},
            {SPREAD, "foo(...5)", true},
            // SPREAD < NEW
            {SPREAD, "new foo(...[])", false},
            {SPREAD, "new foo(...[danger()])", false},
            {SPREAD, "new foo(...'lit')", false},
            {SPREAD, "new foo(...`template`)", false},
            {SPREAD, "new foo(...`template ${safe}`)", false},
            {SPREAD, "new foo(...`template ${danger()}`)", false},
            {SPREAD, "new foo(...danger)", true},
            {SPREAD, "new foo(...danger())", true},
            {SPREAD, "new foo(...5)", true},
            // SPREAD < OBJECTLIT
            {SPREAD, "({...danger()})", false},
            // REST < ARRAY_PATTERN
            {REST, "const [...rest] = []", true},
            {REST, "const [...rest] = 'lit'", true},
            {REST, "const [...rest] = `template`", true},
            {REST, "const [...rest] = safe", true},
            {REST, "function f([...rest]) { }", true},
            {REST, "const [[...rest]] = safe", true},
            {REST, "const {key: [...rest]} = safe", true},
            // REST < PARAM_LIST
            {REST, "function f(...x) { }", false},
            {REST, "function f(a, ...x) { }", false},
            {REST, "async function f(...x) { }", false},
            {REST, "function* f(...x) { }", false},
            {REST, "async function* f(...x) { }", false},
            {REST, "((...x) => { })", false},
            // REST < OBJECT_PATTERN
            {REST, "const {...rest} = danger();", false},
            // FOR_OF
            {FOR_OF, "for (let x of []) {}", false},
            {FOR_OF, "for (let x of [danger()]) {}", false},
            {FOR_OF, "for (let x of 'lit') {}", false},
            {FOR_OF, "for (let x of `template`) {}", false},
            {FOR_OF, "for (let x of `template ${safe}`) {}", false},
            {FOR_OF, "for (let x of `template ${danger()}`) {}", false},
            {FOR_OF, "for (let x of danger) {}", true},
            {FOR_OF, "for (let x of danger()) {}", true},
            {FOR_OF, "for (let x of 5) {}", true},
            // FOR_AWAIT_OF
            {FOR_AWAIT_OF, "(async()=>{ for await (let x of []) {} })", false},
            {FOR_AWAIT_OF, "(async()=>{ for await (let x of [danger()]) {} })", false},
            {FOR_AWAIT_OF, "(async()=>{ for await (let x of 'literal') {} })", false},
            {FOR_AWAIT_OF, "(async()=>{ for await (let x of `template`) {} })", false},
            {FOR_AWAIT_OF, "(async()=>{ for await (let x of `t ${safe}`) {} })", false},
            {FOR_AWAIT_OF, "(async()=>{ for await (let x of `t ${dn()}`) {} })", false},
            {FOR_AWAIT_OF, "(async()=>{ for await (let x of danger) {} })", true},
            {FOR_AWAIT_OF, "(async()=>{ for await (let x of danger()) {} })", true},
            {FOR_AWAIT_OF, "(async()=>{ for await (let x of 5) {} })", true},
            // YIELD*
            {YIELD, "function* f() { yield* []; }", false},
            {YIELD, "function* f() { yield* [danger()]; }", false},
            {YIELD, "function* f() { yield* 'lit'; }", false},
            {YIELD, "function* f() { yield* `template`; }", false},
            {YIELD, "function* f() { yield* `template ${sub}`; }", false},
            {YIELD, "function* f() { yield* `template ${danger()}`; }", false},
            {YIELD, "function* f() { yield* danger; }", true},
            {YIELD, "function* f() { yield* danger(); }", true},
            {YIELD, "function* f() { yield* 5; }", true},
            // YIELD
            {YIELD, "function* f() { yield danger(); }", false},
          });
    }

    private final Token token;
    private final String source;
    private final boolean expectation;

    public IteratesImpureIterableTest(Token token, String source, boolean expectation) {
      this.token = token;
      this.source = source;
      this.expectation = expectation;
    }

    @Test
    public void test() {
      Node node = parseFirst(token, source);
      assertThat(NodeUtil.iteratesImpureIterable(node)).isEqualTo(expectation);
    }
  }

  private static Node getNameNodeFrom(String code, String name) {
    Node ast = parse(code);
    Node nameNode = getNameNode(ast, name);
    return nameNode;
  }

  private static boolean executedOnceTestCase(String code) {
    Node nameNode = getNameNodeFrom(code, "x");
    return NodeUtil.isExecutedExactlyOnce(nameNode);
  }

  private static String getFunctionLValue(String js) {
    Node lVal = NodeUtil.getBestLValue(parseFirst(FUNCTION, js));
    return lVal == null ? null : lVal.getString();
  }

  private static boolean functionIsRValueOfAssign(String js) {
    Node ast = parse(js);
    Node nameNode = getNameNode(ast, "x");
    Node funcNode = getNode(ast, FUNCTION);
    assertWithMessage("No function node to test").that(funcNode).isNotNull();
    return funcNode == NodeUtil.getRValueOfLValue(nameNode);
  }

  private static void testFunctionName(String js, String expected) {
    assertThat(NodeUtil.getNearestFunctionName(parseFirst(FUNCTION, js))).isEqualTo(expected);
  }

  /**
   * @param js JavaScript node to be passed to {@code NodeUtil.findLhsNodesInNode}. Must be either
   *     an EXPR_RESULT containing an assignment operation (e.g. =, +=, /=, etc) in which case the
   *     assignment node will be passed to {@code NodeUtil.findLhsNodesInNode}, or a VAR, LET, or
   *     CONST statement, in which case the declaration statement will be passed.
   */
  private static Iterable<Node> findLhsNodesInNode(String js) {
    Node root = parse(js);
    checkState(root.isScript(), root);
    root = root.getOnlyChild();
    if (root.isExprResult()) {
      root = root.getOnlyChild();
      checkState(NodeUtil.isAssignmentOp(root), root);
    }
    return NodeUtil.findLhsNodesInNode(root);
  }

  private static Node getNameNode(Node n, String name) {
    if (n.isName() && n.getString().equals(name)) {
      return n;
    }
    for (Node c : n.children()) {
      Node result = getNameNode(c, name);
      if (result != null) {
        return result;
      }
    }
    return null;
  }

  /** @return The first node in {@code tree} that is an array pattern or object pattern. */
  @Nullable
  private static Node getPattern(Node tree) {
    if (tree.isDestructuringPattern()) {
      return tree;
    }
    for (Node c : tree.children()) {
      Node result = getPattern(c);
      if (result != null) {
        return result;
      }
    }
    return null;
  }

  private static boolean isValidPropertyName(String s) {
    return NodeUtil.isValidPropertyName(FeatureSet.ES3, s);
  }

  private static boolean isValidQualifiedName(String s) {
    return NodeUtil.isValidQualifiedName(FeatureSet.ES3, s);
  }
}