GlobalFunction(Node nameNode, Var var, JSModule module) { Node parent = nameNode.getParent(); Preconditions.checkState( parent.isVar() || NodeUtil.isFunctionDeclaration(parent)); this.nameNode = nameNode; this.var = var; this.module = module; }
/** * Is this node the name of a variable being declared? * * @param n The node * @return True if {@code n} is NAME and {@code parent} is VAR */ static boolean isVarDeclaration(Node n) { // There is no need to verify that parent != null because a NAME node // always has a parent in a valid parse tree. return n.isName() && n.getParent().isVar(); }
/** * Is this node a name declaration? * * @param n The node * @return True if {@code n} is VAR, LET or CONST */ public static boolean isNameDeclaration(Node n) { return n.isVar() || n.isLet() || n.isConst(); }
/** * Is this node a name declaration? * * @param n The node * @return True if {@code n} is VAR, LET or CONST */ public static boolean isNameDeclaration(Node n) { return n != null && (n.isVar() || n.isLet() || n.isConst()); }
public static Node forIn(Node target, Node cond, Node body) { checkState(target.isVar() || mayBeExpression(target)); checkState(mayBeExpression(cond)); checkState(body.isBlock()); return new Node(Token.FOR_IN, target, cond, body); }
@Override public void visit(Node n) { if (n.isName()) { Node parent = n.getParent(); if (parent != null && parent.isVar()) { String name = n.getString(); vars.putIfAbsent(name, n); } } } }
private static Node getName(Node n) { if (n.isVar()) { return n.getFirstChild(); } else if (NodeUtil.isExprAssign(n)) { return n.getFirstFirstChild(); } throw new IllegalStateException(); }
/** * Gets the parent node of the value for any assignment to a Name. * For example, in the assignment * {@code var x = 3;} * the parent would be the NAME node. */ private static Node getValueParent(Ref ref) { // there are two types of declarations: VARs and ASSIGNs return ref.node.getParent() != null && ref.node.getParent().isVar() ? ref.node : ref.node.getParent(); }
private static Node getValue(Node n) { if (n.isVar()) { return n.getFirstFirstChild(); } else if (NodeUtil.isExprAssign(n)) { return n.getFirstChild().getLastChild(); } throw new IllegalStateException(); }
public static Node forNode(Node init, Node cond, Node incr, Node body) { checkState(init.isVar() || init.isLet() || init.isConst() || mayBeExpressionOrEmpty(init)); checkState(mayBeExpressionOrEmpty(cond)); checkState(mayBeExpressionOrEmpty(incr)); checkState(body.isBlock()); return new Node(Token.FOR, init, cond, incr, body); }
@Override public boolean apply(TypedVar var) { return var.getParentNode() != null && var.getType() == null && var.getParentNode().isVar() && !var.isExtern(); } };
private boolean isDeclarativelyUnboundVarWithoutType(TypedVar var) { return var.getParentNode() != null && var.getType() == null // TODO(bradfordcsmith): update this for destructuring && var.getParentNode().isVar() // NOTE: explicitly excludes let/const && !var.isExtern(); }
private boolean isVarOrAssignExprLhs(Node n) { Node parent = n.getParent(); return parent.isVar() || (parent.isAssign() && parent.getFirstChild() == n && parent.getParent().isExprResult()); }
/** Determines whether the variable is initialized at the declaration. */ public boolean isInitializingDeclaration() { // VAR and LET are the only types of variable declarations that may not initialize // their variables. Catch blocks, named functions, and parameters all do. return (isDeclaration() && !getParent().isVar() && !getParent().isLet()) || nameNode.hasChildren(); }
/** * Matches literal value declarations {@code var foo = 3;} or stub declarations like * {@code var bar;}. */ private static boolean isClassFieldDeclaration(Node node) { return node.getParent().isScript() && node.isVar() && (!node.getFirstChild().hasChildren() || (node.getFirstFirstChild() != null && NodeUtil.isLiteralValue( node.getFirstFirstChild(), false /* includeFunctions */))); }
/** Matches destructing from a variable ie `const {foo, bar: baz} = quux;` */ protected static boolean isVariableDestructuringAssignment(Node statement) { if (!(statement.isConst() || statement.isVar() || statement.isLet())) { return false; } if (!statement.getFirstChild().isDestructuringLhs()) { return false; } Node destructuringAssignment = statement.getFirstChild(); Node rightHandSide = destructuringAssignment.getChildAtIndex(1); return rightHandSide.isName(); }
private void maybeSplitMultiVar(Node rhsNode) { Node statementNode = rhsNode.getGrandparent(); if (!statementNode.isVar() || !statementNode.hasMoreThanOneChild()) { return; } Node nameNode = rhsNode.getParent(); nameNode.detach(); rhsNode.detach(); statementNode.getParent().addChildBefore(IR.var(nameNode, rhsNode), statementNode); }
private void maybeSplitMultiVar(Node rhsNode) { Node statementNode = rhsNode.getParent().getParent(); if (!statementNode.isVar() || !statementNode.hasMoreThanOneChild()) { return; } Node nameNode = rhsNode.getParent(); nameNode.detachFromParent(); rhsNode.detachFromParent(); statementNode.getParent().addChildBefore(IR.var(nameNode, rhsNode), statementNode); }