List of usage examples for org.eclipse.jdt.core.dom AnnotatableType annotations
ASTNode.NodeList annotations
To view the source code for org.eclipse.jdt.core.dom AnnotatableType annotations.
Click Source Link
From source file:at.bestsolution.fxide.jdt.corext.dom.ASTFlattener.java
License:Open Source License
void printTypeAnnotations(AnnotatableType node) { if (node.getAST().apiLevel() >= AST.JLS8) { printAnnotationsList(node.annotations()); } }
From source file:com.google.googlejavaformat.java.JavaInputAstVisitor.java
License:Apache License
/** Before Visitor methods for {@link Type}. */ private void beforeAnnotatableType(AnnotatableType node) { if (!node.annotations().isEmpty()) { builder.open(ZERO);//from w w w . j ava 2 s . c om for (Annotation annotation : (List<Annotation>) node.annotations()) { annotation.accept(this); builder.breakOp(" "); } builder.close(); } }
From source file:org.codemucker.jmutate.ast.JAstFlattener.java
License:Open Source License
private void visitTypeAnnotations(AnnotatableType node) { if (node.getAST().apiLevel() >= AST.JLS8) { visitAnnotationsList(node.annotations()); }//from w ww. j a v a 2 s .c om }
From source file:org.decojer.cavaj.utils.Expressions.java
License:Open Source License
/** * New type.//from ww w. j a va2 s. c o m * * @param t * type * @param context * context * @return AST type */ @SuppressWarnings("deprecation") public static Type newType(@Nonnull final T t, @Nonnull final Element context) { final AST ast = context.getCu().getAst(); // handle array first because annot(array()) is special if (t.isArray()) { if (ast.apiLevel() <= AST.JLS4) { final T componentT = t.getComponentT(); assert componentT != null; return ast.newArrayType(newType(componentT, context)); } final T elementT = t.getElementT(); assert elementT != null; for (T checkT = t; checkT != null && checkT.isArray(); checkT = checkT.getComponentT()) { if (checkT.isAnnotated()) { final ArrayType arrayType = ast.newArrayType(newType(elementT, context)); final List<Dimension> dimensions = arrayType.dimensions(); dimensions.clear(); for (T componentT = t; componentT != null && componentT.isArray(); componentT = componentT.getComponentT()) { final Dimension dimension = ast.newDimension(); final List<IExtendedModifier> annotations = dimension.annotations(); assert annotations != null; if (componentT.isAnnotated()) { Annotations.decompileAnnotations(componentT, annotations, context); } dimensions.add(dimension); } return arrayType; } } return ast.newArrayType(newType(elementT, context), t.getDimensions()); } if (t.isAnnotated()) { Type type = newType(t.getRawT(), context); if (ast.apiLevel() <= AST.JLS4) { log.warn("Cannot decompile type annotations for type '" + t + "' in Eclipse AST JLS4!"); return type; } // parameterized type is not directly annotateable in Eclipse; but DecoJer thinks the // whole type is meant, not just the generic type, hence translate here AnnotatableType annotatableType = (AnnotatableType) (type instanceof ParameterizedType ? ((ParameterizedType) type).getType() : type); qualified: if (annotatableType instanceof SimpleType) { // direct annotation of qualified types adds the annotations as first element, // strange Java spec doesn't allow "@A package.Name" but wants "package.@A Name" final Name typeName = ((SimpleType) annotatableType).getName(); if (!(typeName instanceof QualifiedName)) { break qualified; } final Name qualifier = ((QualifiedName) typeName).getQualifier(); final SimpleName name = ((QualifiedName) typeName).getName(); // cannot delete mandory childs, copy them annotatableType = ast.newNameQualifiedType((Name) ASTNode.copySubtree(ast, qualifier), (SimpleName) ASTNode.copySubtree(ast, name)); if (type instanceof ParameterizedType) { ((ParameterizedType) type).setType(annotatableType); } else { type = annotatableType; } } final List<IExtendedModifier> annotations = annotatableType.annotations(); assert annotations != null; Annotations.decompileAnnotations(t, annotations, context); return type; } // doesn't work, now with Dimension (see above): if (t.isArray()) { return // ast.newArrayType(newType(t.getComponentT(), contextT)); } if (t.isParameterized()) { final T genericT = t.getGenericT(); assert genericT != null; final ParameterizedType parameterizedType = ast.newParameterizedType(newType(genericT, context)); for (final T typeArg : t.getTypeArgs()) { assert typeArg != null; parameterizedType.typeArguments().add(newType(typeArg, context)); } return parameterizedType; } if (t.isWildcard()) { final T boundT = t.getBoundT(); if (boundT == null) { return ast.newWildcardType(); } if (t.isSubclassOf()) { final WildcardType wildcardType = ast.newWildcardType(); // default...newWildcardType.setUpperBound(true); wildcardType.setBound(newType(boundT, context)); return wildcardType; } final WildcardType wildcardType = ast.newWildcardType(); wildcardType.setUpperBound(false); wildcardType.setBound(newType(boundT, context)); return wildcardType; } if (t.isMulti()) { log.warn("Convert type for multi-type '" + t + "'!"); // prefer boolean for multi-type with 0 or 1, synchronous to newLiteral()! // prefer byte before char if no explicit char type given } if (t.is(T.BOOLEAN)) { return ast.newPrimitiveType(PrimitiveType.BOOLEAN); } if (t.is(T.BYTE)) { return ast.newPrimitiveType(PrimitiveType.BYTE); } if (t.is(T.CHAR)) { return ast.newPrimitiveType(PrimitiveType.CHAR); } if (t.is(T.SHORT)) { return ast.newPrimitiveType(PrimitiveType.SHORT); } if (t.is(T.INT)) { return ast.newPrimitiveType(PrimitiveType.INT); } if (t.is(T.FLOAT)) { return ast.newPrimitiveType(PrimitiveType.FLOAT); } if (t.is(T.LONG)) { return ast.newPrimitiveType(PrimitiveType.LONG); } if (t.is(T.DOUBLE)) { return ast.newPrimitiveType(PrimitiveType.DOUBLE); } if (t.is(T.VOID)) { return ast.newPrimitiveType(PrimitiveType.VOID); } if (t.isQualified()) { final T qualifierT = t.getQualifierT(); assert qualifierT != null : "cannot be null for qualified"; // could be ParamT etc., not decompileable with name as target; // restrict qualifications to really necessary enclosings: // t = Outer.Inner.InnerInner, t = Outer.Inner ==> Inner final T contextT = context.getT(); assert contextT != null; if (contextT.getFullName().startsWith(qualifierT.getFullName())) { // TODO full name has too much info yet (like annotations) return ast.newSimpleType(newSimpleName(t.getSimpleIdentifier(), ast)); } return ast.newQualifiedType(newType(qualifierT, context), newSimpleName(t.getSimpleIdentifier(), ast)); } // else fall through... return ast.newSimpleType(newTypeName(t, context)); }