protected boolean hasTargetMethod(TypeElement type, String methodName) { if (type == null) { return false; } List<? extends Element> allMembers = getProcessingEnvironment().getElementUtils().getAllMembers(type); for (ExecutableElement element : ElementFilter.methodsIn(allMembers)) { if (element.getSimpleName().contentEquals(methodName)) { return true; } } return false; } }
private boolean hasActivityOptions(TypeElement type, int optionsParamPosition) { if (type == null) { return false; } for (ExecutableElement element : ElementFilter.methodsIn(elementUtils.getAllMembers(type))) { if (element.getSimpleName().contentEquals("startActivity")) { List<? extends VariableElement> parameters = element.getParameters(); if (parameters.size() == optionsParamPosition + 1) { VariableElement parameter = parameters.get(optionsParamPosition); if (parameter.asType().toString().equals(CanonicalNameConstants.BUNDLE)) { return true; } } } } return false; }
private void collectTypedefs(TypeElement type, Map<String, TypeMirror> collected) { for (VariableElement field : ElementFilter.fieldsIn(elements.getAllMembers(type))) { if (field.getAnnotation(Generator.Typedef.class) != null) { collected.put(field.getSimpleName().toString(), field.asType()); } } }
public static String getSetter(Element element, Elements elements) { TypeElement enclosingElement = (TypeElement) element.getEnclosingElement(); String elementName = element.getSimpleName().toString(); String elementNameLowerCase = elementName.toLowerCase(); List<String> possibleMethodNames = new ArrayList<>(); possibleMethodNames.add("set" + elementNameLowerCase); // Handle the case where variables are named in the form mVariableName instead of just variableName if (elementName.length() > 1 && elementName.charAt(0) == 'm' && (elementName.charAt(1) >= 'A' && elementName.charAt(1) <= 'Z')) { possibleMethodNames.add("set" + elementNameLowerCase.substring(1)); } List<? extends Element> elementMembers = elements.getAllMembers(enclosingElement); List<ExecutableElement> elementMethods = ElementFilter.methodsIn(elementMembers); for (ExecutableElement methodElement : elementMethods) { String methodNameString = methodElement.getSimpleName().toString(); String methodNameLowerCase = methodNameString.toLowerCase(); if (possibleMethodNames.contains(methodNameLowerCase)) { if (methodElement.getParameters().size() == 1) { if (methodElement.getParameters().get(0).asType().toString().equals(element.asType().toString())) { return methodNameString; } } } } return null; }
private void collectSimpleUsages(TypeElement type, Map<String, TypeMirror> collected) { for (ExecutableElement method : ElementFilter.methodsIn(elements.getAllMembers(type))) { if (shouldConsideredAsTypeUsage(method)) { collectIfSimpleType(method.getReturnType(), collected); for (VariableElement parameter : method.getParameters()) { collectIfSimpleType(parameter.asType(), collected); } } } }
List<? extends Element> elementMembers = elements.getAllMembers(enclosingElement); List<ExecutableElement> elementMethods = ElementFilter.methodsIn(elementMembers); for (ExecutableElement methodElement : elementMethods) {
public Set<String> getNonAttributeAbstractMethodSignatures() { if (element.getKind().isClass() || element.getKind().isInterface()) { Set<String> signatures = new LinkedHashSet<>(); List<? extends Element> members = constitution.protoclass() .environment() .processing() .getElementUtils() .getAllMembers(CachingElements.getDelegate((TypeElement) element)); for (ExecutableElement m : ElementFilter.methodsIn(members)) { if (!m.getParameters().isEmpty() || m.getSimpleName().contentEquals(AccessorAttributesCollector.HASH_CODE_METHOD) || m.getSimpleName().contentEquals(AccessorAttributesCollector.TO_STRING_METHOD)) { if (m.getModifiers().contains(Modifier.ABSTRACT)) { TypeMirror returnType = m.getReturnType(); if (!AccessorAttributesCollector.isEclipseImplementation(m)) { returnType = AccessorAttributesCollector.asInheritedMemberReturnType( constitution.protoclass().processing(), CachingElements.getDelegate((TypeElement) element), m); } signatures.add(toSignature(m, returnType)); } } } return signatures; } return Collections.emptySet(); }
List<? extends Element> inheritedMembers = getProcessingEnvironment().getElementUtils().getAllMembers(typeElement);
for (Element element : processing.getElementUtils().getAllMembers(originalType)) { if (element.getKind() == ElementKind.METHOD) { switch (element.getSimpleName().toString()) {
final Map<String, Set<TypeMirror>> methods = new HashMap<>(); final TypeElement e = (TypeElement) types.asElement(resultType); for (ExecutableElement executableElement : ElementFilter.methodsIn(elements.getAllMembers(e))) { if (executableElement.getModifiers().contains(Modifier.PUBLIC) && executableElement.getParameters().size() == 1) { final String methodName = executableElement.getSimpleName().toString(); for (Element element : ElementFilter.fieldsIn(elements.getAllMembers(e))) { if (element.getModifiers().contains(Modifier.PUBLIC) && !element.getModifiers().contains(Modifier.FINAL)) { final Set<TypeMirror> types = fields.computeIfAbsent(element.getSimpleName().toString(), (key -> new HashSet<>()));
private void collectAccessors(TypeElement type, Map<String, Accessor> accesors) { List<? extends Element> allMembers = elements.getAllMembers(type); for (VariableElement field : ElementFilter.fieldsIn(allMembers)) { if (isAccessible(field)) { Accessor accessor = new Accessor(field); accesors.put(accessor.name, accessor); } } // toString, hashCode from Object for (ExecutableElement method : ElementFilter.methodsIn(allMembers)) { TypeElement definingType = (TypeElement) method.getEnclosingElement(); if (definingType.getQualifiedName().contentEquals(Object.class.getCanonicalName()) || isSimpleAccessor(method) && isAccessible(method)) { Accessor accessor = new Accessor(method); accesors.put(accessor.name, accessor); } } // For other accessors we use shared utility AccessorProvider provider = SourceOrdering.getAllAccessorsProvider(elements, types, type); for (ExecutableElement method : provider.get()) { // this should be already checked, but we check for completeness if (isSimpleAccessor(method) && isAccessible(method)) { Accessor accessor = new Accessor(method); accesors.put(accessor.name, accessor); } } }
.processing() .getElementUtils() .getAllMembers(CachingElements.getDelegate((TypeElement) element)));
ordering.immutableSortedCopy( disambiguateMethods(ElementFilter.methodsIn( elements.getAllMembers(originatingType))));
private void checkForMutableFields(Protoclass protoclass, TypeElement element) { Elements elementUtils = protoclass.environment().processing().getElementUtils(); for (VariableElement field : ElementFilter.fieldsIn( elementUtils.getAllMembers(CachingElements.getDelegate(element)))) { if (!field.getModifiers().contains(Modifier.FINAL)) { Reporter report = protoclass.report(); boolean ownField = CachingElements.equals(element, field.getEnclosingElement()); if (ownField) { report.withElement(field) .warning(About.INCOMPAT, "Avoid introduction of fields (except constants) in abstract value types"); } else { report.warning(About.INCOMPAT, "Abstract value type inherits mutable fields"); } } } }
protected R scanAllInheritedMethods(TypeElement x, State state) { R toReturn = DEFAULT_VALUE; List<ExecutableElement> methods = ElementFilter.methodsIn(state.elements.getAllMembers(x)); for (ExecutableElement method : methods) { toReturn = scan(method, state); } return toReturn; }
/** * Visits all inner elements of provided {@link TypeElement}. * * @param typeElement inner elements of which you want to visit */ private void visitAllMyElements(TypeElement typeElement) { Name qualifiedName = typeElement.getQualifiedName(); if ( !processedTypes.contains( qualifiedName ) ) { processedTypes.add( qualifiedName ); for ( Element element : elementUtils.getAllMembers( typeElement ) ) { visit( element ); } } }
private static PartialToBuilderMethod detectPartialToBuilderMethod( DeclaredType datatype, DeclaredType builder, Elements elements, Types types) { List<ExecutableElement> valueMethods = elements.getAllMembers(asElement(datatype)) .stream() .flatMap(METHODS) .filter(BuildableType::isCallableMethod) .collect(toList()); // Check whether there is a toBuilder() method if (valueMethods.stream().anyMatch(new IsToBuilderMethod(datatype, builder, types))) { return PartialToBuilderMethod.TO_BUILDER_AND_MERGE; } else { return PartialToBuilderMethod.MERGE_DIRECTLY; } }
private static MergeBuilderMethod detectMergeFromBuilderMethod( DeclaredType builder, Elements elements, Types types, TypeElement datatypeElement) { if (findAnnotationMirror(datatypeElement, FreeBuilder.class).isPresent()) { return MergeBuilderMethod.MERGE_DIRECTLY; } else { List<ExecutableElement> methods = elements.getAllMembers(asElement(builder)) .stream() .flatMap(METHODS) .filter(BuildableType::isCallableMethod) .collect(toList()); // Check whether there is a mergeFrom(Builder) method if (methods.stream().anyMatch(new IsMergeFromMethod(builder, builder, types))) { return MergeBuilderMethod.MERGE_DIRECTLY; } else { return MergeBuilderMethod.BUILD_PARTIAL_AND_MERGE; } } }
@Override protected Set<ConstraintCheckIssue> doCheck(Element element, AnnotationMirror annotation) { //check if default message on annotation is correct or not: if ( ElementKind.ANNOTATION_TYPE.equals( element.getKind() ) ) { for ( Element innerElement : elementUtils.getAllMembers( (TypeElement) element ) ) { if ( ElementKind.METHOD.equals( innerElement.getKind() ) && "message".equals( innerElement.getSimpleName().toString() ) ) { if ( checkMessage( ( (ExecutableElement) innerElement ).getDefaultValue().getValue().toString() ) ) { return CollectionHelper.asSet( ConstraintCheckIssue.warning( innerElement, annotation, "INVALID_MESSAGE_VALUE_ANNOTATION_PARAMETERS" ) ); } } } } return Collections.emptySet(); } }
/** * Find a method that is overridden by the one passed to this function. * * @param currentMethod the method for which we want to find the overridden methods * @param typeElement the class or interface analyzed * @return the overridden method if there is one, and {@code null} otherwise */ private ExecutableElement getOverriddenMethod(ExecutableElement currentMethod, TypeElement typeElement) { if ( typeElement == null ) { return null; } TypeElement enclosingTypeElement = getEnclosingTypeElement( currentMethod ); for ( Element element : elementUtils.getAllMembers( typeElement ) ) { if ( !element.getKind().equals( ElementKind.METHOD ) ) { continue; } if ( elementUtils.overrides( currentMethod, (ExecutableElement) element, enclosingTypeElement ) ) { return (ExecutableElement) element; } } return null; }