private boolean methodIsAvailableIn(TypeElement element, String methodName) { for (Element method : ElementFilter.methodsIn(element.getEnclosedElements())) { if (method.getSimpleName().contentEquals(methodName)) { return true; } } return false; }
private @Nullable ExecutableElement findMethod(TypeElement typeElement, String getter) { for (ExecutableElement m : ElementFilter.methodsIn(typeElement.getEnclosedElements())) { if (m.getSimpleName().contentEquals(getter)) { return m; } } return null; }
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; }
@Override public Optional<ExecutableElement> builderFactoryMethod() { return ElementFilter.methodsIn(element().getEnclosedElements()).stream() .filter(element -> element.getModifiers().contains(Modifier.STATIC)) .filter(element -> element.getSimpleName().toString().equals("builder")) .findFirst(); }
/** * 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; }
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 void validateShadowMethods(TypeElement sdkClassElem, TypeElement shadowClassElem, int classMinSdk, int classMaxSdk, boolean looseSignatures) { for (Element memberElement : ElementFilter.methodsIn(shadowClassElem.getEnclosedElements())) { ExecutableElement methodElement = (ExecutableElement) memberElement; // equals, hashCode, and toString are exempt, because of Robolectric's weird special behavior if (METHODS_ALLOWED_TO_BE_PUBLIC.contains(methodElement.getSimpleName().toString())) { continue; } verifySdkMethod(sdkClassElem, methodElement, classMinSdk, classMaxSdk, looseSignatures); String methodName = methodElement.getSimpleName().toString(); if (methodName.equals(CONSTRUCTOR_METHOD_NAME) || methodName.equals(STATIC_INITIALIZER_METHOD_NAME)) { Implementation implementation = memberElement.getAnnotation(Implementation.class); if (implementation == null) { messager.printMessage( Kind.ERROR, "Shadow methods must be annotated @Implementation", methodElement); } } } }
public static ExecutableElement getOnlyMethod(ProcessingEnvironment processingEnv, String className) { final TypeElement typeElement = processingEnv.getElementUtils().getTypeElement(className); final List<ExecutableElement> elements = ElementFilter.methodsIn(typeElement.getEnclosedElements()); if (elements.size() == 1) { return elements.get(0); } else { processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR, "Needs exactly one method", typeElement); throw new IllegalArgumentException(); } }
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; }
static boolean overridesMethod(Types types, TypeElement element, String methodName) { while (element != null) { if (ElementFilter.methodsIn(element.getEnclosedElements()).stream() .anyMatch(method -> method.getSimpleName().contentEquals(methodName))) { return true; } TypeMirror superType = element.getSuperclass(); if (superType.getKind() == TypeKind.NONE) { break; } else { element = (TypeElement) types.asElement(superType); } if (namesEqual(element, Object.class.getCanonicalName())) { break; } } return false; }
private static Collection<ExecutableElement> getMessageMethods(final TypeElement intf) { return ElementFilter.methodsIn(intf.getEnclosedElements()) .stream() .filter(method -> !method.isDefault() && !method.getModifiers().contains(Modifier.STATIC)) .collect(Collectors.toList()); } }
List<ExecutableElement> elementMethods = ElementFilter.methodsIn(elementMembers); for (ExecutableElement methodElement : elementMethods) { if (methodElement.getParameters().size() == 0) { String methodNameString = methodElement.getSimpleName().toString(); String methodNameLowerCase = methodNameString.toLowerCase();
@Override public Optional<ExecutableElement> factoryMethod() { Optional<ExecutableElement> staticFactory = ElementFilter.methodsIn(element().getEnclosedElements()).stream() .filter(element -> element.getModifiers().contains(Modifier.STATIC)) .filter(element -> element.getSimpleName().toString().equalsIgnoreCase("create")) .filter(element -> element.getParameters().size() > 0) .filter(element -> element.getReturnType().equals(element().asType())) .findAny(); Optional<ExecutableElement> constructor = ElementFilter.constructorsIn(element().getEnclosedElements()).stream() .filter(element -> element.getParameters().size() > 0) .findAny(); return staticFactory.isPresent() ? staticFactory : constructor; }
MirrorModel(TypeElement element) { this.element = element; ImmutableList.Builder<AttributeModel> builder = ImmutableList.builder(); for (ExecutableElement attribute : ElementFilter.methodsIn(element.getEnclosedElements())) { builder.add(new AttributeModel(attribute)); } this.attributes = builder.build(); this.name = element.getSimpleName().toString(); PackageElement packageElement; for (Element e = element;; e = e.getEnclosingElement()) { if (e.getKind() == ElementKind.PACKAGE) { packageElement = (PackageElement) e; break; } } this.$$package = packageElement.getQualifiedName().toString(); this.qualifiedName = element.getAnnotation(Mirror.Annotation.class).value(); }
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(); }
private void checkForInvalidSetter(ElementValidator validator) { if (!element().getKind().isField()) { for (ExecutableElement element : ElementFilter.methodsIn(entity.element().getEnclosedElements())) { List<? extends VariableElement> parameters = element.getParameters(); if (parameters.size() == 1) { String property = Names.removeMethodPrefixes(element.getSimpleName().toString()); if (property.toLowerCase(Locale.ROOT).equalsIgnoreCase(name())) { validator.error("Element \""+ fieldName() + "\" is read-only but has setter (Kotlin: change var to val)"); } } } } }
private void handleAnnotationMethods() { for (ExecutableElement method : ElementFilter.methodsIn(baseAnnotation.getEnclosedElements())) { elements.add(MoreElements.isAnnotationPresent(method, StringRes.class) ? modelFactory.fromStringResourceAnnotationMethod(method) : modelFactory.fromAnnotationMethod(method)); } }
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();
private void setClosestRequiredAncestor( ExtraBindingTarget extraBindingTarget, TypeElement superIntentBuilder) { for (ExecutableElement method : methodsIn(superIntentBuilder.getEnclosedElements())) { if (method.getSimpleName().contentEquals(NEXT_STATE_METHOD)) { final TypeMirror returnTypeMirror = method.getReturnType(); if (compilerUtil.isAssignable(returnTypeMirror, "dart.henson.AllRequiredSetState")) { return; } final Element reqElement = ((DeclaredType) typeUtils.erasure(returnTypeMirror)).asElement(); final TypeElement intentBuilderTypeElement = (TypeElement) reqElement.getEnclosingElement(); extraBindingTarget.closestRequiredAncestorPackage = compilerUtil.getPackageName(intentBuilderTypeElement); final String intentBuilderClass = compilerUtil.getClassName( intentBuilderTypeElement, extraBindingTarget.closestRequiredAncestorPackage); extraBindingTarget.closestRequiredAncestorClass = intentBuilderClass.substring(0, intentBuilderClass.indexOf(BUNDLE_BUILDER_SUFFIX)); } } }
private static void updateEmbeddableAccessType(TypeElement element, Context context, AccessType defaultAccessType) { List<? extends Element> fieldsOfClass = ElementFilter.fieldsIn( element.getEnclosedElements() ); for ( Element field : fieldsOfClass ) { updateEmbeddableAccessTypeForMember( context, defaultAccessType, field ); } List<? extends Element> methodOfClass = ElementFilter.methodsIn( element.getEnclosedElements() ); for ( Element method : methodOfClass ) { updateEmbeddableAccessTypeForMember( context, defaultAccessType, method ); } }