public BlockStatementListTreeImpl blockStatements(Optional<List<BlockStatementListTreeImpl>> blockStatements) { ImmutableList.Builder<StatementTree> builder = ImmutableList.builder(); if (blockStatements.isPresent()) { for (BlockStatementListTreeImpl blockStatement : blockStatements.get()) { builder.addAll(blockStatement); } } return new BlockStatementListTreeImpl(builder.build()); }
public BoundListTreeImpl newBounds(TypeTree classType, Optional<List<Tuple<InternalSyntaxToken, Tree>>> rests) { ImmutableList.Builder<Tree> classTypes = ImmutableList.builder(); ImmutableList.Builder<SyntaxToken> separators = ImmutableList.builder(); classTypes.add(classType); if (rests.isPresent()) { for (Tuple<InternalSyntaxToken, Tree> rest : rests.get()) { separators.add(rest.first()); classTypes.add(rest.second()); } } return new BoundListTreeImpl(classTypes.build(), separators.build()); }
public ArgumentListTreeImpl newNormalAnnotation(AssignmentExpressionTreeImpl elementValuePair, Optional<List<Tuple<InternalSyntaxToken, AssignmentExpressionTreeImpl>>> rests) { ImmutableList.Builder<ExpressionTree> expressions = ImmutableList.builder(); expressions.add(elementValuePair); ImmutableList.Builder<SyntaxToken> separators = ImmutableList.builder(); if (rests.isPresent()) { for (Tuple<InternalSyntaxToken, AssignmentExpressionTreeImpl> rest : rests.get()) { separators.add(rest.first()); expressions.add(rest.second()); } } return new ArgumentListTreeImpl(expressions.build(), separators.build()); }
public ArgumentListTreeImpl newArguments(ExpressionTree expression, Optional<List<Tuple<InternalSyntaxToken, ExpressionTree>>> rests) { ImmutableList.Builder<ExpressionTree> expressions = ImmutableList.builder(); expressions.add(expression); ImmutableList.Builder<SyntaxToken> separators = ImmutableList.builder(); if (rests.isPresent()) { for (Tuple<InternalSyntaxToken, ExpressionTree> rest : rests.get()) { separators.add(rest.first()); expressions.add(rest.second()); } } return new ArgumentListTreeImpl(expressions.build(), separators.build()); }
public ModuleNameListTreeImpl newModuleNameListTreeImpl(ModuleNameTree firstModuleName, Optional<List<Tuple<InternalSyntaxToken, ModuleNameTree>>> rest) { List<ModuleNameTree> moduleNames = new ArrayList<>(); List<SyntaxToken> separators = new ArrayList<>(); moduleNames.add(firstModuleName); if (rest.isPresent()) { for(Tuple<InternalSyntaxToken, ModuleNameTree> tuple : rest.get()) { separators.add(tuple.first()); moduleNames.add(tuple.second()); } } return new ModuleNameListTreeImpl(Collections.unmodifiableList(moduleNames), Collections.unmodifiableList(separators)); }
public ExpressionTree newPostfixExpression(ExpressionTree expression, Optional<InternalSyntaxToken> postfixOperator) { ExpressionTree result = expression; if (postfixOperator.isPresent()) { InternalSyntaxToken postfixOperatorToken = postfixOperator.get(); result = new InternalPostfixUnaryExpression(kindMaps.getPostfixOperator((JavaPunctuator) postfixOperator.get().getGrammarRuleKey()), result, postfixOperatorToken); } return result; }
public NewArrayTreeImpl completeArrayCreator(Optional<List<AnnotationTreeImpl>> annotations, NewArrayTreeImpl partial) { if (annotations.isPresent()) { partial.completeFirstDimension(annotations.get()); } return partial; }
public ResourceListTreeImpl newResources(List<Tuple<Tree, Optional<InternalSyntaxToken>>> rests) { ImmutableList.Builder<Tree> resources = ImmutableList.builder(); ImmutableList.Builder<SyntaxToken> separators = ImmutableList.builder(); for (Tuple<Tree, Optional<InternalSyntaxToken>> rest : rests) { if (rest.second().isPresent()) { separators.add(rest.second().get()); } resources.add(rest.first()); } return new ResourceListTreeImpl(resources.build(), separators.build()); }
public StatementExpressionListTreeImpl newStatementExpressions(ExpressionTree expression, Optional<List<Tuple<InternalSyntaxToken, ExpressionTree>>> rests) { ImmutableList.Builder<StatementTree> statements = ImmutableList.builder(); statements.add(new ExpressionStatementTreeImpl(expression, null)); ImmutableList.Builder<SyntaxToken> separators = ImmutableList.builder(); if (rests.isPresent()) { for (Tuple<InternalSyntaxToken, ExpressionTree> rest : rests.get()) { separators.add(rest.first()); statements.add(new ExpressionStatementTreeImpl(rest.second(), null)); } } return new StatementExpressionListTreeImpl(statements.build(), separators.build()); }
public MethodTreeImpl newAnnotationTypeMethod(InternalSyntaxToken openParenToken, InternalSyntaxToken closeParenToken, Optional<Tuple<InternalSyntaxToken, ExpressionTree>> defaultValue) { FormalParametersListTreeImpl parameters = new FormalParametersListTreeImpl(openParenToken, closeParenToken); InternalSyntaxToken defaultToken = null; ExpressionTree defaultExpression = null; if (defaultValue.isPresent()) { defaultToken = defaultValue.get().first(); defaultExpression = defaultValue.get().second(); } return new MethodTreeImpl(parameters, defaultToken, defaultExpression); }
public TypeCastExpressionTreeImpl newClassCastExpression(TypeTree type, Optional<Tuple<InternalSyntaxToken, BoundListTreeImpl>> classTypes, InternalSyntaxToken closeParenToken, ExpressionTree expression) { BoundListTreeImpl bounds = BoundListTreeImpl.emptyList(); InternalSyntaxToken andToken = null; if (classTypes.isPresent()) { andToken = classTypes.get().first(); bounds = classTypes.get().second(); } return new TypeCastExpressionTreeImpl(type, andToken, bounds, closeParenToken, expression); }
public TryStatementTreeImpl newTryCatch(Optional<List<CatchTreeImpl>> catches, Optional<TryStatementTreeImpl> finallyBlock) { List<CatchTreeImpl> catchTrees = catches.or(ImmutableList.<CatchTreeImpl>of()); if (finallyBlock.isPresent()) { return finallyBlock.get().completeWithCatches(catchTrees); } else { return new TryStatementTreeImpl(catchTrees, null, null); } }
public BreakStatementTreeImpl breakStatement(InternalSyntaxToken breakToken, Optional<InternalSyntaxToken> identifierToken, InternalSyntaxToken semicolonSyntaxToken) { IdentifierTreeImpl identifier = null; if (identifierToken.isPresent()) { identifier = new IdentifierTreeImpl(identifierToken.get()); } return new BreakStatementTreeImpl(breakToken, identifier, semicolonSyntaxToken); }
public ContinueStatementTreeImpl continueStatement(InternalSyntaxToken continueToken, Optional<InternalSyntaxToken> identifierToken, InternalSyntaxToken semicolonToken) { IdentifierTreeImpl identifier = null; if (identifierToken.isPresent()) { identifier = new IdentifierTreeImpl(identifierToken.get()); } return new ContinueStatementTreeImpl(continueToken, identifier, semicolonToken); }
public ExpressionTree newAnnotatedParameterizedIdentifier( Optional<List<AnnotationTreeImpl>> annotations, InternalSyntaxToken identifierToken, Optional<TypeArgumentListTreeImpl> typeArguments) { List<AnnotationTree> annotationList = ImmutableList.copyOf(annotations.or(ImmutableList.of())); ExpressionTree result = new IdentifierTreeImpl(identifierToken); if (typeArguments.isPresent()) { result = new ParameterizedTypeTreeImpl((TypeTree) result, typeArguments.get()); } ((JavaTree.AnnotatedTypeTree) result).complete(annotationList); return result; }
public ModifiersTreeImpl modifiers(Optional<List<ModifierTree>> modifierNodes) { if (!modifierNodes.isPresent()) { return ModifiersTreeImpl.emptyModifiers(); } return new ModifiersTreeImpl(modifierNodes.get()); }
public ArgumentListTreeImpl completeNormalAnnotation(InternalSyntaxToken openParenToken, Optional<ArgumentListTreeImpl> partial, InternalSyntaxToken closeParenToken) { if (!partial.isPresent()) { return new ArgumentListTreeImpl(openParenToken, closeParenToken); } ArgumentListTreeImpl elementValuePairs = partial.get(); elementValuePairs.complete(openParenToken, closeParenToken); return elementValuePairs; }
public ImportTreeImpl newImportDeclaration(InternalSyntaxToken importToken, Optional<InternalSyntaxToken> staticToken, ExpressionTree qualifiedIdentifier, Optional<Tuple<InternalSyntaxToken, InternalSyntaxToken>> dotStar, InternalSyntaxToken semicolonToken) { ExpressionTree target = qualifiedIdentifier; if (dotStar.isPresent()) { IdentifierTreeImpl identifier = new IdentifierTreeImpl(dotStar.get().second()); InternalSyntaxToken dotToken = dotStar.get().first(); target = new MemberSelectExpressionTreeImpl(qualifiedIdentifier, dotToken, identifier); } InternalSyntaxToken staticKeyword = staticToken.orNull(); return new ImportTreeImpl(importToken, staticKeyword, target, semicolonToken); }
public ModuleDirectiveTree newOpensModuleDirective(InternalSyntaxToken opensKeyword, ExpressionTree packageName, Optional<Tuple<InternalSyntaxToken, ListTreeImpl<ModuleNameTree>>> moduleNames, InternalSyntaxToken semicolonToken) { InternalSyntaxToken toKeyword = null; ListTreeImpl<ModuleNameTree> otherModuleNames = ModuleNameListTreeImpl.emptyList(); if (moduleNames.isPresent()) { Tuple<InternalSyntaxToken, ListTreeImpl<ModuleNameTree>> toModuleNames = moduleNames.get(); toKeyword = toModuleNames.first(); otherModuleNames = toModuleNames.second(); } return new OpensDirectiveTreeImpl(opensKeyword, packageName, toKeyword, otherModuleNames, semicolonToken); }
public BlockTreeImpl newInitializerMember(Optional<InternalSyntaxToken> staticToken, BlockTreeImpl block) { if (staticToken.isPresent()) { return new StaticInitializerTreeImpl(staticToken.get(), (InternalSyntaxToken) block.openBraceToken(), block.body(), (InternalSyntaxToken) block.closeBraceToken()); } else { return new BlockTreeImpl(Kind.INITIALIZER, (InternalSyntaxToken) block.openBraceToken(), block.body(), (InternalSyntaxToken) block.closeBraceToken()); } }