private void recordTopLevelClassOrFunctionName(Node classOrFunctionNode) { Node nameNode = classOrFunctionNode.getFirstChild(); if (nameNode.isName() && !Strings.isNullOrEmpty(nameNode.getString())) { String name = nameNode.getString(); currentScript.topLevelNames.add(name); } }
private void checkNonObjectInstanceOf(NodeTraversal t, Node n) { if (n.isInstanceOf()) { reportIfNonObject( t, n.getFirstChild(), SUSPICIOUS_INSTANCEOF_LEFT_OPERAND); } }
private void processGetProp(Node getProp) { Node propNode = getProp.getSecondChild(); JSType type = getJSType(getProp.getFirstChild()); maybeMarkCandidate(propNode, type); }
private boolean isCandidateNode(Node n) { switch(n.getToken()) { case GETPROP: return n.getFirstChild().isQualifiedName(); case NAME: return !n.getString().isEmpty(); default: return false; } }
void addObjectPattern(Node n) { add("{"); for (Node child = n.getFirstChild(); child != null; child = child.getNext()) { if (child != n.getFirstChild()) { cc.listSeparator(); } add(child); } add("}"); }
Node createMemberFunctionDef(String name, Node function) { // A function used for a member function definition must have an empty name, // because the name string goes on the MEMBER_FUNCTION_DEF node. checkArgument(function.getFirstChild().getString().isEmpty(), function); Node result = IR.memberFunctionDef(name, function); if (isAddingTypes()) { // member function definition must share the type of the function that implements it result.setJSType(function.getJSType()); } return result; }
/** * @return Whether any LiveRangeChecker would be interested in the node. */ public static boolean shouldVisit(Node n) { return (n.isName() || (n.hasChildren() && n.getFirstChild().isName())); }
private void validateTemplateLitSub(Node n) { validateNodeType(Token.TEMPLATELIT_SUB, n); validateChildCount(n); validateExpression(n.getFirstChild()); }
private void validateThrow(Node n) { validateNodeType(Token.THROW, n); validateChildCount(n); validateExpression(n.getFirstChild()); }
private void validateArrayLit(Node n) { validateNodeType(Token.ARRAYLIT, n); for (Node c = n.getFirstChild(); c != null; c = c.getNext()) { // EMPTY is allowed to represent empty slots. validateOptionalExpression(c); } }
private void validateNamedType(Node n) { validateNodeType(Token.NAMED_TYPE, n); validateChildCount(n); validateName(n.getFirstChild()); }
private boolean isCandidatePropertyDefinition(Node n) { checkState(n.isGetProp(), n); Node target = n.getFirstChild(); return target.isThis() || (isConstructor(target)) || (target.isGetProp() && target.getLastChild().getString().equals("prototype")); }
private void validateEnum(Node n) { validateNodeType(Token.ENUM, n); validateName(n.getFirstChild()); validateEnumMembers(n.getLastChild()); }
private void validateCall(Node n) { validateNodeType(Token.CALL, n); validateMinimumChildCount(n, 1); for (Node c = n.getFirstChild(); c != null; c = c.getNext()) { validateExpression(c); } }
private void validateLabel(Node n) { validateNodeType(Token.LABEL, n); validateChildCount(n); validateLabelName(n.getFirstChild()); validateStatement(n.getLastChild()); }
public final boolean isCatchScope() { return getRootNode().isBlock() && getRootNode().hasOneChild() && getRootNode().getFirstChild().isCatch(); }
private void validateTaggedTemplateLit(Node n) { validateFeature(Feature.TEMPLATE_LITERALS, n); validateNodeType(Token.TAGGED_TEMPLATELIT, n); validateChildCount(n); validateExpression(n.getFirstChild()); validateTemplateLit(n.getLastChild()); }
private void validateObjectLitComputedPropKey(Node n) { validateFeature(Feature.COMPUTED_PROPERTIES, n); validateNodeType(Token.COMPUTED_PROP, n); validateChildCount(n); validateExpression(n.getFirstChild()); validateExpression(n.getLastChild()); }
private void validateForOf(Node n) { validateFeature(Feature.FOR_OF, n); validateNodeType(Token.FOR_OF, n); validateChildCount(n); validateVarOrAssignmentTarget(n.getFirstChild()); validateExpression(n.getSecondChild()); validateBlock(n.getLastChild()); }
private void validateObjectPatternComputedPropKey(Token type, Node n) { validateFeature(Feature.COMPUTED_PROPERTIES, n); validateNodeType(Token.COMPUTED_PROP, n); validateChildCount(n); validateExpression(n.getFirstChild()); if (n.getLastChild().isDefaultValue()) { validateDefaultValue(type, n.getLastChild()); } else { validateLHS(n.getLastChild().getToken(), n.getLastChild()); } }