public ClassTreeImpl completeAnnotationType(InternalSyntaxToken atToken, InternalSyntaxToken interfaceToken, InternalSyntaxToken identifier, ClassTreeImpl partial) { return partial.complete( atToken, interfaceToken, new IdentifierTreeImpl(identifier)); }
@Override public int getLine() { if (simpleName == null) { return super.getLine(); } return ((IdentifierTreeImpl) simpleName).getLine(); }
@Override public String name() { return identifierToken().text(); }
private static void associateReference(IdentifierTree tree, JavaSymbol symbol) { if (symbol.kind < JavaSymbol.ERRONEOUS) { ((IdentifierTreeImpl) tree).setSymbol(symbol); symbol.addUsage(tree); } }
public TypeParameterTreeImpl completeTypeParameter(Optional<List<AnnotationTreeImpl>> annotations, AstNode identifierAstNode, Optional<TypeParameterTreeImpl> partial) { IdentifierTreeImpl identifier = new IdentifierTreeImpl(InternalSyntaxToken.create(identifierAstNode)); if (annotations.isPresent()) { identifier.prependChildren(annotations.get()); } return partial.isPresent() ? partial.get().complete(identifier) : new TypeParameterTreeImpl(identifier); }
@Override public String toString() { return name(); }
public ExpressionTree newAnnotatedParameterizedIdentifier( Optional<List<AnnotationTreeImpl>> annotations, InternalSyntaxToken identifierToken, Optional<TypeArgumentListTreeImpl> typeArguments) { List<AnnotationTree> annotationList = annotations.isPresent() ? ImmutableList.<AnnotationTree>builder().addAll(annotations.get()).build() : ImmutableList.<AnnotationTree>of(); ExpressionTree result = new IdentifierTreeImpl(identifierToken); if (typeArguments.isPresent()) { result = new ParameterizedTypeTreeImpl((TypeTree) result, typeArguments.get()).complete(annotationList); } else { result = ((IdentifierTreeImpl) result).complete(annotationList); } return result; }
public IdentifierTreeImpl(InternalSyntaxToken nameToken, List<AstNode> children) { super(Kind.IDENTIFIER, nameToken.getToken()); this.nameToken = Preconditions.checkNotNull(nameToken); for (AstNode child : children) { addChild(child); } }
private static void moveAnnotations(ExpressionTree result, ExpressionTree firstIdentifier) { List<AnnotationTree> firstIdentifierAnnotations; boolean isParameterizedType = firstIdentifier.is(Tree.Kind.PARAMETERIZED_TYPE); if (isParameterizedType) { firstIdentifierAnnotations = ((ParameterizedTypeTree) firstIdentifier).annotations(); } else { firstIdentifierAnnotations = ((IdentifierTree) firstIdentifier).annotations(); } // move the annotations from the first identifier to the member select or the parameterized type if (!firstIdentifierAnnotations.isEmpty()) { if (result.is(Tree.Kind.MEMBER_SELECT)) { ((MemberSelectExpressionTreeImpl) result).complete(firstIdentifierAnnotations); } else { ((ParameterizedTypeTreeImpl) result).complete(firstIdentifierAnnotations); } if (isParameterizedType) { ((ParameterizedTypeTreeImpl) firstIdentifier).complete(ImmutableList.<AnnotationTree>of()); } else { ((IdentifierTreeImpl) firstIdentifier).complete(ImmutableList.<AnnotationTree>of()); } } }
public void setSymbol(JavaSymbol.VariableJavaSymbol symbol) { Preconditions.checkState(this.symbol == null); this.symbol = symbol; // also set the symbol to the variable identifier, or it would remain unknown ((IdentifierTreeImpl) simpleName()).setSymbol(symbol); }
public ExpressionTree newIdentifierOrMethodInvocation(Optional<TypeArgumentListTreeImpl> typeArguments, AstNode identifierAstNode, Optional<ArgumentListTreeImpl> arguments) { InternalSyntaxToken identifierToken = InternalSyntaxToken.create(identifierAstNode); IdentifierTreeImpl identifier = new IdentifierTreeImpl(identifierToken); if (typeArguments.isPresent()) { identifier.prependChildren(typeArguments.get()); } ExpressionTree result = identifier; if (arguments.isPresent()) { result = new MethodInvocationTreeImpl(identifier, typeArguments.orNull(), arguments.get(), identifier, arguments.get()); } return result; }
@Override public String toString() { return name(); }
public IdentifierTreeImpl(InternalSyntaxToken nameToken) { super(Kind.IDENTIFIER, nameToken.getToken()); this.nameToken = Preconditions.checkNotNull(nameToken); addChild(nameToken); }
private static void completeTypeTreeWithAnnotations(TypeTree type, List<AnnotationTree> typeAnnotations) { if (type.is(Tree.Kind.IDENTIFIER)) { ((IdentifierTreeImpl) type).complete(typeAnnotations); } else if (type.is(Tree.Kind.MEMBER_SELECT)) { ((MemberSelectExpressionTreeImpl) type).complete(typeAnnotations); } else if (type.is(Tree.Kind.PARAMETERIZED_TYPE)) { ((ParameterizedTypeTreeImpl) type).complete(typeAnnotations); } else if (type.is(Kind.ARRAY_TYPE)) { ((ArrayTypeTreeImpl) type).complete(typeAnnotations); } else { ((PrimitiveTypeTreeImpl) type).complete(typeAnnotations); } } }
public VariableTreeImpl receiverParameterId(Optional<List<Tuple<InternalSyntaxToken, InternalSyntaxToken>>> optional, InternalSyntaxToken thisToken) { if(optional.isPresent()) { // FIXME qualified id of outer class for receiver type. } return new VariableTreeImpl(new IdentifierTreeImpl(thisToken), null); }
private static void associateReference(IdentifierTree tree, JavaSymbol symbol) { if (symbol.kind < JavaSymbol.ERRONEOUS) { ((IdentifierTreeImpl) tree).setSymbol(symbol); symbol.addUsage(tree); } }
@Override public int getLine() { if (simpleName == null) { return super.getLine(); } return ((IdentifierTreeImpl) simpleName).getLine(); }
public EnumConstantTreeImpl newEnumConstant( Optional<List<AnnotationTreeImpl>> annotations, AstNode identifierAstNode, Optional<ArgumentListTreeImpl> arguments, Optional<ClassTreeImpl> classBody, Optional<AstNode> semicolonTokenAstNode) { IdentifierTreeImpl identifier = new IdentifierTreeImpl(InternalSyntaxToken.create(identifierAstNode)); if (annotations.isPresent()) { identifier.prependChildren(annotations.get()); } List<AstNode> children = Lists.newArrayList(); if (arguments.isPresent()) { children.add(arguments.get()); } if (classBody.isPresent()) { children.add(classBody.get()); } NewClassTreeImpl newClass = new NewClassTreeImpl( arguments.isPresent() ? arguments.get() : Collections.emptyList(), classBody.isPresent() ? classBody.get() : null, children.toArray(new AstNode[0])); newClass.completeWithIdentifier(identifier); @SuppressWarnings("unchecked") EnumConstantTreeImpl result = new EnumConstantTreeImpl(modifiers((Optional<List<ModifierTree>>)(Optional<?>)annotations), identifier, newClass); result.addChild(identifier); result.addChild(newClass); if (semicolonTokenAstNode.isPresent()) { result.addChild(semicolonTokenAstNode.get()); } return result; }
@Override public String toString() { return name(); }
@Override public String name() { return identifierToken().text(); }