Message(Kind kind, String message, Element element, AnnotationMirror annotationMirror) { this.kind = kind; this.message = message; this.annotationMirrorString = annotationMirror == null ? null : annotationMirror.toString(); if (element != null) { Element enclosingElement = element; do { elements.add(0, enclosingElement.toString()); enclosingElement = enclosingElement.getEnclosingElement(); } while (!enclosingElement.getKind().equals(ElementKind.PACKAGE)); } }
public static boolean isFinalField(Element element) { return element.getKind().equals(ElementKind.FIELD) && element.getModifiers().contains(Modifier.FINAL); }
@Override public VisitorConfig getConfig(TypeElement e, List<? extends Element> elements) { boolean fields = false, methods = false; for (Element element : elements) { if (hasRelevantAnnotation(element)) { fields |= element.getKind().equals(ElementKind.FIELD); methods |= element.getKind().equals(ElementKind.METHOD); } } return VisitorConfig.get(fields, methods, VisitorConfig.FIELDS_ONLY); }
@Override public Boolean visitDeclared(DeclaredType declaredType, Element element) { if ( ElementKind.ENUM.equals( element.getKind() ) ) { return Boolean.TRUE; } if ( ElementKind.CLASS.equals( element.getKind() ) || ElementKind.INTERFACE.equals( element.getKind() ) ) { TypeElement typeElement = ( (TypeElement) element ); String typeName = typeElement.getQualifiedName().toString(); if ( Constants.BASIC_TYPES.contains( typeName ) ) { return Boolean.TRUE; } if ( TypeUtils.containsAnnotation( element, Constants.EMBEDDABLE ) ) { return Boolean.TRUE; } for ( TypeMirror mirror : typeElement.getInterfaces() ) { TypeElement interfaceElement = (TypeElement) context.getTypeUtils().asElement( mirror ); if ( "java.io.Serializable".equals( interfaceElement.getQualifiedName().toString() ) ) { return Boolean.TRUE; } } } return Boolean.FALSE; } }
public static <T extends Element> ImmutableList<FieldModel> extractFields(T element) { final List<FieldModel> fields = new ArrayList<>(); for (Element enclosedElement : element.getEnclosedElements()) { if (ElementKind.FIELD.equals(enclosedElement.getKind())) { Set<Modifier> modifiers = enclosedElement.getModifiers(); fields.add( new FieldModel( FieldSpec.builder( TypeName.get(enclosedElement.asType()), enclosedElement.getSimpleName().toString(), modifiers.toArray(new Modifier[modifiers.size()])) .build(), enclosedElement)); } } return ImmutableList.copyOf(fields); } }
private String[] getCollectionTypes(String propertyName, String explicitTargetEntity, String explicitMapKeyClass, ElementKind expectedElementKind) { for ( Element elem : element.getEnclosedElements() ) { if ( !expectedElementKind.equals( elem.getKind() ) ) { continue; } String elementPropertyName = elem.getSimpleName().toString(); if ( elem.getKind().equals( ElementKind.METHOD ) ) { elementPropertyName = StringUtil.getPropertyName( elementPropertyName ); } if ( !propertyName.equals( elementPropertyName ) ) { continue; } DeclaredType type = determineDeclaredType( elem ); if ( type == null ) { continue; } return determineTypes( propertyName, explicitTargetEntity, explicitMapKeyClass, type ); } return null; }
public void isPrefMethod(Element element, ElementValidation valid) { if (!element.getKind().equals(ElementKind.METHOD)) { valid.addError("Only methods are allowed in an %s annotated interface"); } else { ExecutableElement executableElement = (ExecutableElement) element; String methodName = executableElement.getSimpleName().toString(); if (executableElement.getParameters().size() > 0) { valid.addError("Method " + methodName + " should have no parameters in an %s annotated interface"); } else { String returnType = executableElement.getReturnType().toString(); if (!VALID_PREF_RETURN_TYPES.contains(returnType)) { valid.addError("Method " + methodName + " should only return preference simple types in an %s annotated interface"); } else { if (INVALID_PREF_METHOD_NAMES.contains(methodName)) { valid.addError("The method name " + methodName + " is forbidden in an %s annotated interface"); } else { return; } } } } valid.invalidate(); }
private void addMethods(TypeElement interfaceClazz, TypeSpec.Builder classBuilder) { List<? extends Element> elements = interfaceClazz.getEnclosedElements(); if (elements != null && !elements.isEmpty()) { for (Element e : elements) { if (ElementKind.METHOD.equals(e.getKind())) { ExecutableElement method = (ExecutableElement) e; MethodSpec.Builder methodBuilder = MethodSpec.methodBuilder(method.getSimpleName().toString() + ASYNC) .addModifiers(Modifier.PUBLIC, Modifier.ABSTRACT).returns(ResponseFuture.class) .addTypeVariables(getTypeNames(method.getTypeParameters())); // add method params List<? extends VariableElement> vars = method.getParameters(); for (VariableElement var : vars) { methodBuilder.addParameter(ParameterSpec.builder(TypeName.get(var.asType()), var.getSimpleName().toString()) .build()); } classBuilder.addMethod(methodBuilder.build()); } } } }
@Override public VisitorConfig getConfig(TypeElement e, List<? extends Element> elements) { Access access = e.getAnnotation(Access.class); if (access != null) { if (access.value() == AccessType.FIELD) { return VisitorConfig.FIELDS_ONLY; } else { return VisitorConfig.METHODS_ONLY; } } boolean fields = false, methods = false; for (Element element : elements) { if (hasRelevantAnnotation(element)) { fields |= element.getKind().equals(ElementKind.FIELD); methods |= element.getKind().equals(ElementKind.METHOD); } } return VisitorConfig.get(fields, methods, VisitorConfig.ALL); }
public static AccessType determineAnnotationSpecifiedAccessType(Element element) { final AnnotationMirror accessAnnotationMirror = TypeUtils.getAnnotationMirror( element, Constants.ACCESS ); AccessType forcedAccessType = null; if ( accessAnnotationMirror != null ) { Element accessElement = (Element) TypeUtils.getAnnotationValue( accessAnnotationMirror, DEFAULT_ANNOTATION_PARAMETER_NAME ); if ( accessElement.getKind().equals( ElementKind.ENUM_CONSTANT ) ) { if ( accessElement.getSimpleName().toString().equals( AccessType.PROPERTY.toString() ) ) { forcedAccessType = AccessType.PROPERTY; } else if ( accessElement.getSimpleName().toString().equals( AccessType.FIELD.toString() ) ) { forcedAccessType = AccessType.FIELD; } } } return forcedAccessType; }
private Set<Element> getNonnullReceiverFields(NullnessStore nullnessResult) { Set<AccessPath> nonnullAccessPaths = nullnessResult.getAccessPathsWithValue(Nullness.NONNULL); Set<Element> result = new LinkedHashSet<>(); for (AccessPath ap : nonnullAccessPaths) { if (ap.getRoot().isReceiver()) { ImmutableList<Element> elements = ap.getElements(); if (elements.size() == 1) { Element elem = elements.get(0); if (elem.getKind().equals(ElementKind.FIELD)) { result.add(elem); } } } } return result; }
@Override public AnnotationMetaAttribute visitExecutable(ExecutableType t, Element p) { if ( !p.getKind().equals( ElementKind.METHOD ) ) { return null; } String string = p.getSimpleName().toString(); if ( !StringUtil.isProperty( string, TypeUtils.toTypeString( t.getReturnType() ) ) ) { return null; } TypeMirror returnType = t.getReturnType(); return returnType.accept( this, p ); }
@Override public Void visitVariable(VariableTree tree, Void unused) { Symbol symbol = ASTHelpers.getSymbol(tree); /* It is quite common to have upper case static field names that match variable names, * as for example between HTTP request parameters name definitions and their corresponding * extracted value. */ if (symbol.getKind().equals(ElementKind.FIELD) && !isUpperCaseAndStatic(symbol) && ASTHelpers.enclosingClass(symbol).equals(classSymbol)) { fields.add(symbol); } return super.visitVariable(tree, unused); } }
@Override public Boolean visitExecutable(ExecutableType t, Element element) { if ( !element.getKind().equals( ElementKind.METHOD ) ) { return Boolean.FALSE; } String string = element.getSimpleName().toString(); if ( !StringUtil.isProperty( string, TypeUtils.toTypeString( t.getReturnType() ) ) ) { return Boolean.FALSE; } TypeMirror returnType = t.getReturnType(); return returnType.accept( this, element ); } }
@Override public String visitExecutable(ExecutableType t, Element p) { if ( !p.getKind().equals( ElementKind.METHOD ) ) { return null; } String string = p.getSimpleName().toString(); if ( !StringUtil.isProperty( string, TypeUtils.toTypeString( t.getReturnType() ) ) ) { return null; } TypeMirror returnType = t.getReturnType(); return returnType.accept( this, p ); } }
private Set<Element> getNonnullStaticFields(NullnessStore nullnessResult) { Set<AccessPath> nonnullAccessPaths = nullnessResult.getAccessPathsWithValue(Nullness.NONNULL); Set<Element> result = new LinkedHashSet<>(); for (AccessPath ap : nonnullAccessPaths) { assert !ap.getRoot().isReceiver(); Element varElement = ap.getRoot().getVarElement(); if (varElement.getKind().equals(ElementKind.FIELD)) { result.add(varElement); } } return result; }
@Override public Void visitVariable(VariableTree tree, Void unused) { Symbol symbol = ASTHelpers.getSymbol(tree); if (!symbol.getKind().equals(ElementKind.PARAMETER)) { return super.visitVariable(tree, unused); } String variableName = symbol.toString(); Symbol matchedField = fields.get(Ascii.toLowerCase(variableName)); if (matchedField != null) { String fieldName = matchedField.toString(); if (!variableName.equals(fieldName)) { matchedParameters.put(getCurrentPath(), matchedField); } } return super.visitVariable(tree, unused); } }
private void handleRootElementAnnotationMirrors(final Element element) { List<? extends AnnotationMirror> annotationMirrors = element.getAnnotationMirrors(); for ( AnnotationMirror mirror : annotationMirrors ) { if ( !ElementKind.CLASS.equals( element.getKind() ) ) { continue; } String fqn = ( (TypeElement) element ).getQualifiedName().toString(); MetaEntity alreadyExistingMetaEntity = tryGettingExistingEntityFromContext( mirror, fqn ); if ( alreadyExistingMetaEntity != null && alreadyExistingMetaEntity.isMetaComplete() ) { String msg = "Skipping processing of annotations for " + fqn + " since xml configuration is metadata complete."; context.logMessage( Diagnostic.Kind.OTHER, msg ); continue; } boolean requiresLazyMemberInitialization = false; AnnotationMetaEntity metaEntity; if ( TypeUtils.containsAnnotation( element, Constants.EMBEDDABLE ) || TypeUtils.containsAnnotation( element, Constants.MAPPED_SUPERCLASS ) ) { requiresLazyMemberInitialization = true; } metaEntity = new AnnotationMetaEntity( (TypeElement) element, context, requiresLazyMemberInitialization ); if ( alreadyExistingMetaEntity != null ) { metaEntity.mergeInMembers( alreadyExistingMetaEntity ); } addMetaEntityToContext( mirror, metaEntity ); } }
@SuppressWarnings("unused") private int depth(ExpressionTree expression) { switch (expression.getKind()) { case MEMBER_SELECT: MemberSelectTree selectTree = (MemberSelectTree) expression; return 1 + depth(selectTree.getExpression()); case METHOD_INVOCATION: MethodInvocationTree invTree = (MethodInvocationTree) expression; return depth(invTree.getMethodSelect()); case IDENTIFIER: IdentifierTree varTree = (IdentifierTree) expression; Symbol symbol = ASTHelpers.getSymbol(varTree); return symbol.getKind().equals(ElementKind.FIELD) ? 2 : 1; default: return 0; } }
private <T extends Symbol> T getMember( Class<T> type, ElementKind kind, Symbol classSymbol, String name) { if (classSymbol.type == null) { return null; } for (Type t : types.closure(classSymbol.type)) { Scope scope = t.tsym.members(); for (Symbol sym : scope.getSymbolsByName(getName(name))) { if (sym.getKind().equals(kind)) { return type.cast(sym); } } } if (classSymbol.hasOuterInstance()) { T sym = getMember(type, kind, classSymbol.type.getEnclosingType().asElement(), name); if (sym != null) { return sym; } } if (classSymbol.owner != null && classSymbol != classSymbol.owner && classSymbol.owner instanceof Symbol.ClassSymbol) { T sym = getMember(type, kind, classSymbol.owner, name); if (sym != null && sym.isStatic()) { return sym; } } return null; }