private String getListName(Element element, Element param) { String listName = param.getSimpleName().toString(); if (element.getKind() == ElementKind.PARAMETER) { listName = element.getEnclosingElement().getSimpleName().toString() + "_" + listName; } else if (element.getKind() == ElementKind.METHOD) { listName = element.getSimpleName().toString() + "_" + listName; } return listName; }
private String extractTag(Element element) { WakeLock annotation = element.getAnnotation(WakeLock.class); String tag = annotation.tag(); if (WakeLock.DEFAULT_TAG.equals(tag)) { tag = element.getEnclosingElement().getSimpleName().toString() + "." + element.getSimpleName().toString(); } return tag; } }
CachingElement(Element delegate) { this.delegate = delegate; this.kind = delegate.getKind(); this.simpleName = delegate.getSimpleName(); this.modifiers = delegate.getModifiers(); }
public void hasNotMultipleAnnotatedMethodWithSameName(Element element, ElementValidation valid, Class<? extends Annotation> annotation) { Set<String> actionNames = new TreeSet<>(); List<? extends Element> enclosedElements = element.getEnclosedElements(); for (Element enclosedElement : enclosedElements) { if (enclosedElement.getKind() != ElementKind.METHOD || !annotationHelper.hasOneOfClassAnnotations(enclosedElement, annotation)) { continue; } String enclosedElementName = enclosedElement.getSimpleName().toString(); if (actionNames.contains(enclosedElementName)) { valid.addError(enclosedElement, "The " + TargetAnnotationHelper.annotationName(annotation) + " annotated method must have unique name even if the signature is not the same"); } else { actionNames.add(enclosedElementName); } } }
@Override public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) { for (TypeElement annotation : annotations) { Set<? extends Element> elementsAnnotatedWith = roundEnv.getElementsAnnotatedWith(annotation); for (Element element : elementsAnnotatedWith) { if (!element.getModifiers().contains(Modifier.PUBLIC)) { processingEnv.getMessager().printMessage( Diagnostic.Kind.ERROR, element.getSimpleName() + " must be public", element ); } } } return false; } }
/** * Get information about methods returning class type of the original class so we can duplicate * them in the generated class for chaining purposes */ protected void collectMethodsReturningClassType(TypeElement modelClass, Types typeUtils) { TypeElement clazz = modelClass; while (clazz.getSuperclass().getKind() != TypeKind.NONE) { for (Element subElement : clazz.getEnclosedElements()) { Set<Modifier> modifiers = subElement.getModifiers(); if (subElement.getKind() == ElementKind.METHOD && !modifiers.contains(Modifier.PRIVATE) && !modifiers.contains(Modifier.FINAL) && !modifiers.contains(Modifier.STATIC)) { TypeMirror methodReturnType = ((ExecutableType) subElement.asType()).getReturnType(); if (methodReturnType.equals(clazz.asType()) || typeUtils.isSubtype(clazz.asType(), methodReturnType)) { ExecutableElement castedSubElement = ((ExecutableElement) subElement); List<? extends VariableElement> params = castedSubElement.getParameters(); String methodName = subElement.getSimpleName().toString(); if (methodName.equals(RESET_METHOD) && params.isEmpty()) { continue; } methodsReturningClassType.add(new MethodInfo(methodName, modifiers, buildParamSpecs(params), castedSubElement.isVarArgs())); } } } clazz = (TypeElement) typeUtils.asElement(clazz.getSuperclass()); } }
private boolean isInaccessibleViaGeneratedCode(Class<? extends Annotation> annotationClass, String targetThing, Element element) { boolean hasError = false; TypeElement enclosingElement = (TypeElement) element.getEnclosingElement(); // Verify field or method modifiers. Set<Modifier> modifiers = element.getModifiers(); if (modifiers.contains(PRIVATE) || modifiers.contains(STATIC)) { error(element, "@%s %s must not be private or static. (%s.%s)", annotationClass.getSimpleName(), targetThing, enclosingElement.getQualifiedName(), element.getSimpleName()); hasError = true; } // Verify containing type. if (enclosingElement.getKind() != CLASS) { error(enclosingElement, "@%s %s may only be contained in classes. (%s.%s)", annotationClass.getSimpleName(), targetThing, enclosingElement.getQualifiedName(), element.getSimpleName()); hasError = true; } // Verify containing class visibility is not private. if (enclosingElement.getModifiers().contains(PRIVATE)) { error(enclosingElement, "@%s %s may not be contained in private classes. (%s.%s)", annotationClass.getSimpleName(), targetThing, enclosingElement.getQualifiedName(), element.getSimpleName()); hasError = true; } return hasError; }
private String computePath(ExecutableElement element) { String path = element.getSimpleName().toString(); for (Element e = element.getEnclosingElement(); // e.getKind().isClass() || e.getKind().isInterface(); // e = e.getEnclosingElement()) { path = e.getSimpleName() + "." + path; } if (element.getModifiers().contains(Modifier.ABSTRACT)) { return path; } return path + "()"; }
private ControllerModelField buildFieldInfo(Element modelFieldElement) { validateFieldAccessibleViaGeneratedCode(modelFieldElement, AutoModel.class, errorLogger); TypeMirror fieldType = modelFieldElement.asType(); if (fieldType.getKind() != TypeKind.ERROR) { // If the field is a generated Epoxy model then the class won't have been generated // yet and it won't have type info. If the type can't be found that we assume it is // a generated model and is ok. if (!isEpoxyModel(fieldType)) { errorLogger.logError("Fields with %s annotations must be of type %s (%s#%s)", AutoModel.class.getSimpleName(), EPOXY_MODEL_TYPE, modelFieldElement.getEnclosingElement().getSimpleName(), modelFieldElement.getSimpleName()); } } return new ControllerModelField(modelFieldElement); }
private void collectIfSimpleType(TypeMirror type, Map<String, TypeMirror> collected) { if (type.getKind() == TypeKind.DECLARED) { DeclaredType declared = (DeclaredType) type; if (declared.getTypeArguments().isEmpty()) { collected.put(declared.asElement().getSimpleName().toString(), declared); } } }
private void debugElement(Element element, String s) { logger.finest(format(s + ": kind=%s, cls=%s, simpleName=%s, type=%s, typeKind=%s, enclosed=%s, enclosing=%s", element.getKind(), element.getClass().getName(), element.getSimpleName(), element.asType(), element.asType().getKind(), element.getEnclosedElements(), element.getEnclosingElement())); TypeMirror typeMirror = element.asType(); if (element.getKind() == ENUM) { for (Element enclosed : element.getEnclosedElements()) { debugElement(enclosed, s + " "); } } else { debugType(typeMirror, element, s + " "); } }
private void debugType(TypeMirror typeMirror, Element element, String indent) { if (indent.length() > 20) { return; } if (typeMirror.getKind() == TypeKind.DECLARED) { DeclaredType declaredType = (DeclaredType) typeMirror; logger.finest(format("%stype=%s, asElement=%s, (elementKind=%s, elementClass=%s), typeArgs=%s, enclosing=%s", indent, declaredType, declaredType.asElement(), declaredType.asElement().getKind(), declaredType.asElement().getClass(), declaredType.getTypeArguments(), declaredType.getEnclosingType())); if (declaredType.asElement().getKind() == ENUM && !element.equals(declaredType.asElement())) { debugElement(declaredType.asElement(), indent + " --> "); } else if (typeMirror.getKind() == TypeKind.EXECUTABLE) { ExecutableType type = (ExecutableType) typeMirror; logger.finest(format("%stype=%s, typeArgs=%s, paramTypes=%s, returnType=%s", logger.finest(format("%s%s %s is of kind=%s", indent, typeMirror, element.getSimpleName(), typeMirror.getKind()));
/** * Determine if inner class could be a builder. * * @param possibleBuilderClass nested value element that could be builder class. * @return true if it's a static inner class. */ private static boolean isPossibleBuilderClass(Element possibleBuilderClass, ValueAttribute valueAttribute) { if (possibleBuilderClass.getKind() == ElementKind.CLASS) { return possibleBuilderClass.getModifiers().contains(Modifier.STATIC) && possibleBuilderClass.getKind() == ElementKind.CLASS && valueAttribute.containingType.names().possibleAttributeBuilder(possibleBuilderClass.getSimpleName()); } return false; }
private Stream<CompilationMessage> validateFieldModifiers( Element recordElement ) { return fieldsIn( recordElement.getEnclosedElements() ).stream().filter( element -> { Set<Modifier> modifiers = element.getModifiers(); return !modifiers.contains( PUBLIC ) && !modifiers.contains( STATIC ); } ).map( element -> new RecordTypeError( element, "Record definition error: field %s#%s must be public", recordElement.getSimpleName(), element.getSimpleName() ) ); }
/** * Return true if the possibleBuilderMethod matches the * Style#attributeBuilder() and returns a class. * * TODO: may need to make this return true if the return type is an interface too... * * @param possibleBuilderMethod executableElement */ private static boolean isPossibleBuilderMethod(Element possibleBuilderMethod, boolean onValueType, ValueAttribute valueAttribute) { if (possibleBuilderMethod.getKind() == ElementKind.METHOD) { if (!valueAttribute.containingType.names().possibleAttributeBuilder(possibleBuilderMethod.getSimpleName())) { return false; } ExecutableElement candidateMethod = (ExecutableElement) possibleBuilderMethod; TypeKind kind = candidateMethod.getReturnType().getKind(); return possibleBuilderMethod.getModifiers().containsAll( Arrays.asList(Modifier.STATIC, Modifier.PUBLIC)) && candidateMethod.getParameters().isEmpty() && candidateMethod.getReturnType().getKind() == TypeKind.DECLARED && !kind.isPrimitive() && kind != TypeKind.ARRAY; } else if (!onValueType && possibleBuilderMethod.getKind() == ElementKind.CONSTRUCTOR) { if (!valueAttribute.containingType.names().newTokenInAttributeBuilder()) { return false; } ExecutableElement candidateConstructor = (ExecutableElement) possibleBuilderMethod; return candidateConstructor.getModifiers().contains(Modifier.PUBLIC) && candidateConstructor.getTypeParameters().isEmpty(); } return false; }
static void validateFieldAccessibleViaGeneratedCode(Element fieldElement, Class<?> annotationClass, ErrorLogger errorLogger, boolean skipPrivateFieldCheck) { TypeElement enclosingElement = (TypeElement) fieldElement.getEnclosingElement(); if ((modifiers.contains(PRIVATE) && !skipPrivateFieldCheck) || modifiers.contains(STATIC)) { errorLogger.logError( "%s annotations must not be on private or static fields. (class: %s, field: %s)", annotationClass.getSimpleName(), enclosingElement.getSimpleName(), fieldElement.getSimpleName()); if (!enclosingElement.getModifiers().contains(STATIC)) { errorLogger.logError( "Nested classes with %s annotations must be static. (class: %s, field: %s)", annotationClass.getSimpleName(), enclosingElement.getSimpleName(), fieldElement.getSimpleName()); .logError("%s annotations may only be contained in classes. (class: %s, field: %s)", annotationClass.getSimpleName(), enclosingElement.getSimpleName(), fieldElement.getSimpleName()); "%s annotations may not be contained in private classes. (class: %s, field: %s)", annotationClass.getSimpleName(), enclosingElement.getSimpleName(), fieldElement.getSimpleName());
private static boolean isElegibleAccessorMethod(Element element) { if (element.getKind() != ElementKind.METHOD) { return false; } if (element.getModifiers().contains(Modifier.STATIC)) { return false; } switch (element.getSimpleName().toString()) { case HASH_CODE_METHOD: case TO_STRING_METHOD: return false; default: } String definitionType = element.getEnclosingElement().toString(); if (definitionType.equals(Object.class.getName()) || definitionType.equals(Proto.ORDINAL_VALUE_INTERFACE_TYPE) || definitionType.equals(Proto.PARCELABLE_INTERFACE_TYPE)) { return false; } return true; }
Accessor(Element element) { this.element = element; this.name = element.getSimpleName().toString(); this.callable = element.getKind() == ElementKind.METHOD; }
static Element collectClassSegments(Element start, List<String> classSegments) { Element e = start; for (; e.getKind() != ElementKind.PACKAGE; e = e.getEnclosingElement()) { classSegments.add(e.getSimpleName().toString()); } Collections.reverse(classSegments); return e; }
private void parseResourceBool(Element element, Map<TypeElement, BindingSet.Builder> builderMap, Set<TypeElement> erasedTargetNames) { boolean hasError = false; TypeElement enclosingElement = (TypeElement) element.getEnclosingElement(); // Verify that the target type is bool. if (element.asType().getKind() != TypeKind.BOOLEAN) { error(element, "@%s field type must be 'boolean'. (%s.%s)", BindBool.class.getSimpleName(), enclosingElement.getQualifiedName(), element.getSimpleName()); hasError = true; } // Verify common generated code restrictions. hasError |= isInaccessibleViaGeneratedCode(BindBool.class, "fields", element); hasError |= isBindingInWrongPackage(BindBool.class, element); if (hasError) { return; } // Assemble information on the field. String name = element.getSimpleName().toString(); int id = element.getAnnotation(BindBool.class).value(); Id resourceId = elementToId(element, BindBool.class, id); BindingSet.Builder builder = getOrCreateBindingBuilder(builderMap, enclosingElement); builder.addResource( new FieldResourceBinding(resourceId, name, FieldResourceBinding.Type.BOOL)); erasedTargetNames.add(enclosingElement); }