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 processTypedParameter(TypedParameterTree typeAnnotation) { Node param = transform(typeAnnotation.param); maybeProcessType(param, typeAnnotation.typeAnnotation); return param; }
Node processIfStatement(IfStatementTree statementNode) { Node node = newNode(Token.IF); node.addChildToBack(transform(statementNode.condition)); node.addChildToBack(transformBlock(statementNode.ifClause)); if (statementNode.elseClause != null) { node.addChildToBack(transformBlock(statementNode.elseClause)); } return node; }
Node processParameterizedType(ParameterizedTypeTree tree) { ImmutableList.Builder<TypeDeclarationNode> arguments = ImmutableList.builder(); for (ParseTree arg : tree.typeArguments) { arguments.add((TypeDeclarationNode) transform(arg)); } TypeDeclarationNode typeName = (TypeDeclarationNode) transform(tree.typeName); return cloneProps(parameterizedType(typeName, arguments.build())); }
Node processParameterizedType(ParameterizedTypeTree tree) { ImmutableList.Builder<TypeDeclarationNode> arguments = ImmutableList.builder(); for (ParseTree arg : tree.typeArguments) { arguments.add((TypeDeclarationNode) transform(arg)); } TypeDeclarationNode typeName = (TypeDeclarationNode) transform(tree.typeName); return cloneProps(parameterizedType(typeName, arguments.build())); }
Node processUnionType(UnionTypeTree tree) { ImmutableList.Builder<TypeDeclarationNode> options = ImmutableList.builder(); for (ParseTree option : tree.types) { options.add((TypeDeclarationNode) transform(option)); } return cloneProps(unionType(options.build())); }
private void maybeProcessGenerics(Node n, GenericTypeListTree generics) { if (generics != null) { maybeWarnTypeSyntax(generics, Feature.GENERICS); n.putProp(Node.GENERIC_TYPE_LIST, transform(generics)); } }
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 transformOrEmpty(ParseTree tree, ParseTree parent) { if (tree == null) { Node n = newNode(Token.EMPTY); setSourceInfo(n, parent); return n; } return transform(tree); }
Node processLabeledStatement(LabelledStatementTree labelTree) { return newNode(Token.LABEL, transformLabelName(labelTree.name), transform(labelTree.statement)); }
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 processTemplateLiteral(TemplateLiteralExpressionTree tree) { maybeWarnEs6Feature(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 processAwait(AwaitExpressionTree tree) { maybeWarnForFeature(tree, Feature.ASYNC_FUNCTIONS); Node await = newNode(Token.AWAIT); await.addChildToBack(transform(tree.expression)); return await; }
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; }