@Override public List<? extends Element> getEnclosedElements() { List<? extends Element> es = enclosedElements; if (es == null) { es = delegate.getEnclosedElements(); enclosedElements = es; } return es; }
private List<ExecutableElement> getValidMethods(Element element) { List<? extends Element> members = element.getEnclosedElements(); List<ExecutableElement> methods = ElementFilter.methodsIn(members); List<ExecutableElement> validMethods = new ArrayList<>(); for (ExecutableElement method : methods) { validMethods.add(method); } return validMethods; }
private Element findEnclosedByName(Element enclosing, String name) { for (Element e : enclosing.getEnclosedElements()) { if (e.getSimpleName().contentEquals(name)) { return e; } } throw new NoSuchElementException("No enclosed element named '" + name + "' found in " + enclosing); }
/** * Gets all of the methods of the class and includes the methods of any * implemented interfaces. * * @param typeElement * @return full list of methods. */ public List<ExecutableElement> getMethods(TypeElement typeElement) { List<? extends Element> enclosedElements = typeElement.getEnclosedElements(); List<ExecutableElement> methods = new ArrayList<>(ElementFilter.methodsIn(enclosedElements)); // Add methods of the interfaces. These will be valid as they have gone // through the validator. for (TypeMirror iface : typeElement.getInterfaces()) { DeclaredType dt = (DeclaredType) iface; methods.addAll(ElementFilter.methodsIn(dt.asElement().getEnclosedElements())); } return methods; }
private List<ExecutableElement> methodsAnnotatedWith( Element returnType, Class<? extends Annotation> annotationType ) { return ElementFilter.methodsIn( returnType.getEnclosedElements() ).stream() .filter( m -> m.getAnnotation( annotationType ) != null ).collect( Collectors.toList() ); }
private void addAllEnclosed( Element element, List<Element> result, Map<Element, Element> parametersToTheirMethods) { result.add(element); for (Element enclosed : element.getEnclosedElements()) { addAllEnclosed(enclosed, result, parametersToTheirMethods); if (enclosed.getKind() == METHOD || enclosed.getKind() == CONSTRUCTOR) { for (Element parameter : ((ExecutableElement) enclosed).getParameters()) { result.add(parameter); parametersToTheirMethods.put(parameter, enclosed); } } } }
private void processElement(Element element) { addMetadataFor(element); staticTypesIn(element.getEnclosedElements()).forEach(this::processElement); }
private void addAllNonPrivateFields(Element element, Elements elements, Types types, JsonObjectHolder objectHolder) { List<? extends Element> enclosedElements = element.getEnclosedElements(); for (Element enclosedElement : enclosedElements) { ElementKind enclosedElementKind = enclosedElement.getKind(); if (enclosedElementKind == ElementKind.FIELD) { Set<Modifier> modifiers = enclosedElement.getModifiers(); if (!modifiers.contains(Modifier.PRIVATE) && !modifiers.contains(Modifier.PROTECTED) && !modifiers.contains(Modifier.TRANSIENT) && !modifiers.contains(Modifier.STATIC)) { createOrUpdateFieldHolder(enclosedElement, elements, types, objectHolder); } } } }
private Stream<CompilationMessage> validateConstructor( Element extensionClass ) { Optional<ExecutableElement> publicNoArgConstructor = constructorsIn( extensionClass.getEnclosedElements() ).stream() .filter( c -> c.getModifiers().contains( Modifier.PUBLIC ) ) .filter( c -> c.getParameters().isEmpty() ).findFirst(); if ( !publicNoArgConstructor.isPresent() ) { return Stream.of( new ExtensionMissingPublicNoArgConstructor( extensionClass, "Extension class %s should contain a public no-arg constructor, none found.", extensionClass ) ); } return Stream.empty(); } }
void detectParcelableCreator() { for (VariableElement v : ElementFilter.fieldsIn(element.getEnclosedElements())) { if (v.getSimpleName().contentEquals(Proto.PARCELABLE_CREATOR_FIELD)) { hasCreatorDefined = true; break; } } }
@SuppressWarnings("unchecked") @Override public Ordering<Element> enclosedBy(Element element) { return (Ordering<Element>) Ordering.explicit(element.getEnclosedElements()); } };
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); } } }
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() ) ); }
private static List<ExecutableElement> getConstructorsWithAnnotations( Element exploringConstructor, List<String> annotations) { return constructorsIn(exploringConstructor.getEnclosingElement().getEnclosedElements()).stream() .filter(constructor -> hasAnyOfAnnotation(constructor, annotations)) .sorted(Comparator.comparing((e -> e.getSimpleName().toString()))) .collect(toImmutableList()); }
private Stream<CompilationMessage> validateFieldType( Element recordElement ) { return fieldsIn( recordElement.getEnclosedElements() ).stream() .filter( element -> !element.getModifiers().contains( STATIC ) ) .filter( element -> !fieldTypeVisitor.visit( element.asType() ) ) .map( element -> new RecordTypeError( element, "Record definition error: type of field %s#%s is not supported", recordElement.getSimpleName(), element.getSimpleName() ) ); }
@Override public void attach(Linker linker) { for (Element enclosedElement : enclosingClass.getEnclosedElements()) { if (enclosedElement.getKind().isField() && isStatic(enclosedElement)) { Inject injectAnnotation = enclosedElement.getAnnotation(Inject.class); if (injectAnnotation != null) { String key = GeneratorKeys.get(enclosedElement.asType()); linker.requestBinding(key, enclosingClass.toString(), getClass().getClassLoader()); } } } }
private static TagModel newTagModel(Element typeElement, Types types) { return new TagModel( ClassName.bestGuess(typeElement.toString()), types.directSupertypes(typeElement.asType()).size() > 1, // java.lang.Object is always a supertype !typeElement.getEnclosedElements().isEmpty(), typeElement); } }
private Long findSerialVersionUID() { for (VariableElement field : ElementFilter.fieldsIn(element.getEnclosedElements())) { if (field.getSimpleName().contentEquals(SERIAL_VERSION_FIELD_NAME) && field.asType().getKind() == TypeKind.LONG) { return (Long) field.getConstantValue(); } } return null; }
public void isAbstractOrHasEmptyOrContextConstructor(Element element, ElementValidation valid) { List<ExecutableElement> constructors = ElementFilter.constructorsIn(element.getEnclosedElements()); if (!annotationHelper.isAbstract(element)) { if (constructors.size() == 1) { ExecutableElement constructor = constructors.get(0); if (!annotationHelper.isPrivate(constructor)) { if (constructor.getParameters().size() > 1) { valid.addError("%s annotated element should have a constructor with one parameter max, of type " + CanonicalNameConstants.CONTEXT); } else if (constructor.getParameters().size() == 1) { VariableElement parameter = constructor.getParameters().get(0); if (!parameter.asType().toString().equals(CanonicalNameConstants.CONTEXT)) { valid.addError("%s annotated element should have a constructor with one parameter max, of type " + CanonicalNameConstants.CONTEXT); } } } else { valid.addError("%s annotated element should not have a private constructor"); } } else { valid.addError("%s annotated element should have only one constructor"); } } }
public void isAbstractOrHasEmptyConstructor(Element element, ElementValidation valid) { List<ExecutableElement> constructors = ElementFilter.constructorsIn(element.getEnclosedElements()); if (!annotationHelper.isAbstract(element)) { if (constructors.size() == 1) { ExecutableElement constructor = constructors.get(0); if (!annotationHelper.isPrivate(constructor)) { if (constructor.getParameters().size() != 0) { valid.addError("%s annotated element should have an empty constructor"); } } else { valid.addError("%s annotated element should not have a private constructor"); } } else { valid.addError("%s annotated element should have only one constructor"); } } }