/** * @param exprNode unused */ Node processEmptyStatement(EmptyStatementTree exprNode) { return newNode(Token.EMPTY); }
/** * @param literal unused */ Node processNullLiteral(LiteralExpressionTree literal) { return newNode(Token.NULL); }
private Node maybeInjectCastNode(ParseTree node, JSDocInfo info, Node irNode) { if (node.type == ParseTreeType.PAREN_EXPRESSION && info.hasType()) { irNode = newNode(Token.CAST, irNode); } return irNode; }
private Node transformList( Token type, ImmutableList<ParseTree> list) { Node n = newNode(type); for (ParseTree tree : list) { n.addChildToBack(transform(tree)); } return n; }
Node processBlock(BlockTree blockNode) { Node node = newNode(Token.BLOCK); for (ParseTree child : blockNode.statements) { node.addChildToBack(transform(child)); } return node; }
Node processExpressionStatement(ExpressionStatementTree statementNode) { Node node = newNode(Token.EXPR_RESULT); node.addChildToBack(transform(statementNode.expression)); return node; }
Node processArrayLiteral(ArrayLiteralExpressionTree tree) { Node node = newNode(Token.ARRAYLIT); for (ParseTree child : tree.elements) { Node c = transform(child); node.addChildToBack(c); } return node; }
Node processDoLoop(DoWhileStatementTree loopNode) { return newNode( Token.DO, transformBlock(loopNode.body), transform(loopNode.condition)); }
Node processWithStatement(WithStatementTree stmt) { return newNode( Token.WITH, transform(stmt.expression), transformBlock(stmt.body)); }
Node processTemplateLiteral(TemplateLiteralExpressionTree tree) { maybeWarnForFeature(tree, Feature.TEMPLATE_LITERALS); Node templateLitNode = newNode(Token.TEMPLATELIT); setSourceInfo(templateLitNode, tree); Node node = tree.operand == null ? templateLitNode : newNode(Token.TAGGED_TEMPLATELIT, transform(tree.operand), templateLitNode); for (ParseTree child : tree.elements) { templateLitNode.addChildToBack(transform(child)); } return node; }
Node processObjectPattern(ObjectPatternTree tree) { maybeWarnForFeature(tree, Feature.OBJECT_DESTRUCTURING); Node node = newNode(Token.OBJECT_PATTERN); for (ParseTree child : tree.fields) { Node childNode = processObjectPatternElement(child); node.addChildToBack(childNode); } return node; }
Node processContinueStatement(ContinueStatementTree statementNode) { Node node = newNode(Token.CONTINUE); if (statementNode.getLabel() != null) { Node labelName = transformLabelName(statementNode.name); node.addChildToBack(labelName); } return node; }
Node processFunctionCall(CallExpressionTree callNode) { Node node = newNode(Token.CALL, transform(callNode.operand)); for (ParseTree child : callNode.arguments.arguments) { node.addChildToBack(transform(child)); } return node; }
Node processAwait(AwaitExpressionTree tree) { maybeWarnForFeature(tree, Feature.ASYNC_FUNCTIONS); Node await = newNode(Token.AWAIT); await.addChildToBack(transform(tree.expression)); return await; }
Node processSwitchStatement(SwitchStatementTree statementNode) { Node node = newNode(Token.SWITCH, transform(statementNode.expression)); for (ParseTree child : statementNode.caseClauses) { node.addChildToBack(transform(child)); } return node; }
Node processForOf(ForOfStatementTree loopNode) { maybeWarnForFeature(loopNode, Feature.FOR_OF); Node initializer = transform(loopNode.initializer); return newNode( Token.FOR_OF, initializer, transform(loopNode.collection), transformBlock(loopNode.body)); }
Node processCallSignature(CallSignatureTree tree) { maybeWarnTypeSyntax( tree, tree.isNew ? Feature.CONSTRUCTOR_SIGNATURE : Feature.CALL_SIGNATURE); Node signature = newNode(Token.CALL_SIGNATURE, transform(tree.formalParameterList)); maybeProcessType(signature, tree.returnType); maybeProcessGenerics(signature, tree.generics); signature.putBooleanProp(Node.CONSTRUCT_SIGNATURE, tree.isNew); return signature; }
Node processVariableDeclaration(VariableDeclarationTree decl) { Node node = transformNodeWithInlineJsDoc(decl.lvalue); Node lhs = node.isDestructuringPattern() ? newNode(Token.DESTRUCTURING_LHS, node) : node; if (decl.initializer != null) { Node initializer = transform(decl.initializer); lhs.addChildToBack(initializer); setLength(lhs, decl.location.start, decl.location.end); } maybeProcessType(lhs, decl.declaredType); return lhs; }
Node processRestParameter(RestParameterTree tree) { maybeWarnForFeature(tree, Feature.REST_PARAMETERS); Node assignmentTarget = transformNodeWithInlineJsDoc(tree.assignmentTarget); if (assignmentTarget.isObjectPattern()) { maybeWarnForFeature(tree.assignmentTarget, Feature.OBJECT_DESTRUCTURING); } else if (assignmentTarget.isArrayPattern()) { maybeWarnForFeature(tree.assignmentTarget, Feature.ARRAY_DESTRUCTURING); } return newNode(Token.REST, assignmentTarget); }
Node processComputedPropertyMemberVariable(ComputedPropertyMemberVariableTree tree) { maybeWarnForFeature(tree, Feature.COMPUTED_PROPERTIES); maybeWarnTypeSyntax(tree, Feature.MEMBER_VARIABLE_IN_CLASS); Node n = newNode(Token.COMPUTED_PROP, transform(tree.property)); maybeProcessType(n, tree.declaredType); n.putBooleanProp(Node.COMPUTED_PROP_VARIABLE, true); n.putProp(Node.ACCESS_MODIFIER, tree.access); n.setStaticMember(tree.isStatic); maybeProcessAccessibilityModifier(tree, n, tree.access); return n; }