private String getMethodName(ExecutableElement element) { String returnType = element.getReturnType().toString(); String simpleName = element.getSimpleName().toString(); return returnType + " " + simpleName; }
static boolean isSetterMethod(Element element) { if (element.getKind() != ElementKind.METHOD) { return false; } ExecutableElement method = (ExecutableElement) element; String methodName = method.getSimpleName().toString(); return PATTERN_STARTS_WITH_SET.matcher(methodName).matches() && method.getParameters().size() == 1; }
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; }
private List<TypeMirror> extractListenerTypeMirrors(Element activityElement) { List<? extends AnnotationMirror> annotationMirrors = activityElement.getAnnotationMirrors(); String annotationName = RoboGuice.class.getName(); for (AnnotationMirror annotationMirror : annotationMirrors) { if (annotationName.equals(annotationMirror.getAnnotationType().toString())) { for (Map.Entry<? extends ExecutableElement, ? extends AnnotationValue> entry : annotationMirror.getElementValues().entrySet()) { if ("value".equals(entry.getKey().getSimpleName().toString())) { AnnotationValue action = entry.getValue(); @SuppressWarnings("unchecked") List<AnnotationValue> elements = (List<AnnotationValue>) action.getValue(); List<TypeMirror> listenerTypeMirrors = new ArrayList<>(elements.size()); for (AnnotationValue annotationValue : elements) { listenerTypeMirrors.add((TypeMirror) annotationValue.getValue()); } return listenerTypeMirrors; } } } } return Collections.emptyList(); }
ElementFilter.methodsIn(entity.element().getEnclosedElements()).stream() .anyMatch(element -> element.getSimpleName().toString().equals(setterName))) { readOnly = false; TypeName[] array = new TypeName[wildcards.size()]; setTypeName = ParameterizedTypeName.get(parameterizedName.rawType, wildcards.toArray(array));
@NonNull public Element fromConfigDelegateMethod(@NonNull ExecutableElement method) { return new DelegateMethod.Config(method.getSimpleName().toString(), TypeName.get(method.getReturnType()), getAnnotations(method).getLeft(), method.getParameters().stream().map(p -> ParameterSpec.builder(TypeName.get(p.asType()), p.getSimpleName().toString()).build()).collect(Collectors.toList()), method.getTypeParameters().stream().map(TypeVariableName::get).collect(Collectors.toList()), method.getModifiers(), elements.getDocComment(method)); }
/** * Retrieve the string value inside an @Contract annotation without statically depending on the * type. * * @param sym A method which has an @Contract annotation. * @return The string value spec inside the annotation. */ private static @Nullable String getContractFromAnnotation(Symbol.MethodSymbol sym) { for (AnnotationMirror annotation : sym.getAnnotationMirrors()) { Element element = annotation.getAnnotationType().asElement(); assert element.getKind().equals(ElementKind.ANNOTATION_TYPE); if (((TypeElement) element) .getQualifiedName() .contentEquals("org.jetbrains.annotations.Contract")) { for (Map.Entry<? extends ExecutableElement, ? extends AnnotationValue> e : annotation.getElementValues().entrySet()) { if (e.getKey().getSimpleName().contentEquals("value")) { String value = e.getValue().toString(); if (value.startsWith("\"") && value.endsWith("\"")) { value = value.substring(1, value.length() - 1); } return value; } } } } return null; } }
if (enclosedElt.getKind() == ElementKind.METHOD) { ExecutableElement methodElt = (ExecutableElement) enclosedElt; if (methodElt.getSimpleName().toString().equals("start") && methodElt.getParameters().isEmpty()) { methodElts.add(methodElt); FileObject obj = processingEnv.getFiler().getResource(StandardLocation.SOURCE_PATH, "", typeElt.getQualifiedName().toString().replace('.', '/') + ".java"); File srcFolder = new File(obj.toUri()).getParentFile(); String filename = Case.SNAKE.format(Case.CAMEL.parse(typeElt.getSimpleName().toString())); for (Lang lang : langs) { if (isSkipped(typeElt, lang)) { log.write("Skipping " + lang.getExtension() + " translation for " + typeElt.getQualifiedName() + "#" + methodElt.getSimpleName()); continue; copyDirRec(srcFolder, dstFolder, log); } catch (Exception e) { log.println("Skipping generation of " + typeElt.getQualifiedName()); e.printStackTrace(log);
/** * Generates a Javadoc code block for generated methods that delegate to methods in * {@link GlideExtension}s. * * <p>The generated block looks something like this: * <pre> * <code> * {@literal @see} com.extension.package.name.ExtensionClassName#extensionMethod(arg1, argN) * </code> * </pre> * * @param method The method from the {@link GlideExtension} annotated class that the generated * method this Javadoc will be attached to delegates to. */ CodeBlock generateSeeMethodJavadoc(ExecutableElement method) { // Use the simple name of the containing type instead of just the containing type's TypeMirror // so that we avoid appending <CHILD> or other type arguments to the class and breaking // Javadoc's linking. // With this we get @see RequestOptions#methodName(). // With just ClassName.get(element.getEnclosingElement().asType()), we get: // @see RequestOptions<CHILD>#methodName(). return generateSeeMethodJavadoc(getJavadocSafeName(method.getEnclosingElement()), method.getSimpleName().toString(), method.getParameters()); }
public Model(DeclaredType type) { this.type = type; for (ExecutableElement e : ElementFilter.methodsIn(type.asElement().getEnclosedElements())) { Metadata im = e.getAnnotation(Metadata.class); if(im==null) continue; String name = im.value(); if (name.length() == 0) name = ((TypeElement) type.asElement()).getQualifiedName().toString() + '.' + e.getSimpleName(); metadataProperties.put(e,name); } }
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 ExecutableElement getMethod(List<ExecutableElement> methods, String methodName, String returnType, String... parameterTypes) { for (ExecutableElement method : methods) { List<? extends VariableElement> parameters = method.getParameters(); // Get the method return type or "VOID" if none. String methodReturnType = method.getReturnType().getKind() == TypeKind.VOID ? TypeKind.VOID.toString() : method.getReturnType().toString(); if (parameters.size() == parameterTypes.length && methodReturnType.equals(returnType)) { if (methodName == null || method.getSimpleName().toString().equals(methodName)) { // At this point, method name, return type and number of // parameters are correct. Now we need to validate the // parameter types. boolean validMethod = true; for (int i = 0; i < parameters.size(); i++) { VariableElement param = parameters.get(i); if (!param.asType().toString().equals(parameterTypes[i])) { // Parameter type does not match, this is not the // correct method. validMethod = false; break; } } if (validMethod) { return method; } } } } return null; }
public void hasSeekBarTouchTrackingMethodParameters(ExecutableElement executableElement, ElementValidation valid) { List<? extends VariableElement> parameters = executableElement.getParameters(); if (parameters.size() > 1) { valid.addError("Unrecognized parameter declaration. You can only have one parameter of type " + CanonicalNameConstants.SEEKBAR + ". Try declaring " + executableElement.getSimpleName() + "(" + CanonicalNameConstants.SEEKBAR + " seekBar);"); return; } if (parameters.size() == 1) { String parameterType = parameters.get(0).asType().toString(); if (!parameterType.equals(CanonicalNameConstants.SEEKBAR)) { valid.addError("Unrecognized parameter declaration. You can only have one parameter of type " + CanonicalNameConstants.SEEKBAR + ". Try declaring " + executableElement.getSimpleName() + "(" + CanonicalNameConstants.SEEKBAR + " seekBar);"); } } }
public List<DeclaredType> extractAnnotationClassArrayParameter(Element element, String annotationName, String methodName) { AnnotationMirror annotationMirror = findAnnotationMirror(element, annotationName); Map<? extends ExecutableElement, ? extends AnnotationValue> elementValues = annotationMirror.getElementValues(); for (Map.Entry<? extends ExecutableElement, ? extends AnnotationValue> entry : elementValues.entrySet()) { /* * "methodName" is unset when the default value is used */ if (methodName.equals(entry.getKey().getSimpleName().toString())) { AnnotationValue annotationValue = entry.getValue(); @SuppressWarnings("unchecked") List<AnnotationValue> annotationClassArray = (List<AnnotationValue>) annotationValue.getValue(); List<DeclaredType> result = new ArrayList<>(annotationClassArray.size()); for (AnnotationValue annotationClassValue : annotationClassArray) { result.add((DeclaredType) annotationClassValue.getValue()); } return result; } } return null; }
@NonNull public Element fromBuilderDelegateMethod(@NonNull ExecutableElement method) { return new DelegateMethod(method.getSimpleName().toString(), TypeName.get(method.getReturnType()), getAnnotations(method).getLeft(), method.getParameters().stream().map(p -> ParameterSpec.builder(TypeName.get(p.asType()), p.getSimpleName().toString()).build()).collect(Collectors.toList()), method.getTypeParameters().stream().map(TypeVariableName::get).collect(Collectors.toList()), method.getModifiers(), elements.getDocComment(method)); }
@Value.Lazy @Override public JacksonMode jacksonSerializeMode() { boolean wasJacksonSerialize = false; for (AnnotationMirror a : element().getAnnotationMirrors()) { TypeElement e = (TypeElement) a.getAnnotationType().asElement(); if (!wasJacksonSerialize && e.getQualifiedName().contentEquals(JACKSON_SERIALIZE)) { wasJacksonSerialize = true; } if (e.getQualifiedName().contentEquals(JACKSON_DESERIALIZE)) { for (ExecutableElement attr : a.getElementValues().keySet()) { if (attr.getSimpleName().contentEquals("builder")) { // If builder attribute is specified, we don't consider this as // our, immutables, business to generate anything. return JacksonMode.BUILDER; } } return JacksonMode.DELEGATED; } } return wasJacksonSerialize ? JacksonMode.DELEGATED : JacksonMode.NONE; }
@NonNull public Element fromTransformDelegateMethod(@NonNull ExecutableElement method, Element transform) { if (transform instanceof TransformedField.Transformable) { return new TransformedField(method.getSimpleName().toString(), TypeName.get(method.getReturnType()), (TransformedField.Transformable) transform); } return transform; }
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; } }
protected boolean isValidInjectAnnotatedMethod(ExecutableElement methodElement) { TypeElement enclosingElement = (TypeElement) methodElement.getEnclosingElement(); // Verify modifiers. Set<Modifier> modifiers = methodElement.getModifiers(); if (modifiers.contains(PRIVATE)) { error(methodElement, "@Inject annotated methods must not be private : %s#%s", enclosingElement.getQualifiedName(), methodElement.getSimpleName()); return false; } // Verify parentScope modifiers. Set<Modifier> parentModifiers = enclosingElement.getModifiers(); if (parentModifiers.contains(PRIVATE)) { error(methodElement, "@Injected fields in class %s. The class must be non private.", enclosingElement.getSimpleName()); return false; } for (VariableElement paramElement : methodElement.getParameters()) { if (!isValidInjectedType(paramElement)) { return false; } } if (modifiers.contains(PUBLIC) || modifiers.contains(PROTECTED)) { if (!hasWarningSuppressed(methodElement, SUPPRESS_WARNING_ANNOTATION_VISIBLE_VALUE)) { crashOrWarnWhenMethodIsNotPackageVisible(methodElement, format("@Inject annotated methods should have package visibility: %s#%s", // enclosingElement.getQualifiedName(), methodElement.getSimpleName())); } } return true; }