@Override public void handleErrors(List<String> errors) { TypeElement module = processingEnv.getElementUtils().getTypeElement(moduleName); for (String error : errors) { processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR, error + " for " + moduleName, module); } } }
@Override public synchronized void init(ProcessingEnvironment env) { super.init(env); String sdk = env.getOptions().get(OPTION_SDK_INT); if (sdk != null) { try { this.sdk = Integer.parseInt(sdk); } catch (NumberFormatException e) { env.getMessager() .printMessage(Kind.WARNING, "Unable to parse supplied minSdk option '" + sdk + "'. Falling back to API 1 support."); } } debuggable = !"false".equals(env.getOptions().get(OPTION_DEBUGGABLE)); typeUtils = env.getTypeUtils(); filer = env.getFiler(); try { trees = Trees.instance(processingEnv); } catch (IllegalArgumentException ignored) { } }
@Override public synchronized void init(ProcessingEnvironment processingEnv) { super.init(processingEnv); mFiler = processingEnv.getFiler(); mElementUtils = processingEnv.getElementUtils(); mMessager = processingEnv.getMessager(); mIsFileCreated = false; }
Elements elementUtils = processingEnv.getElementUtils(); Types types = processingEnv.getTypeUtils(); switch (providerMethod.getEnclosingElement().getKind()) { case CLASS: break; // valid, move along continue; || methodModifiers.contains(STATIC)) { error("@Provides methods must not be private, abstract or static: " + type.getQualifiedName() + "." + providerMethod, providerMethod); continue; if (!providerMethodAsExecutable.getThrownTypes().isEmpty()) { error("@Provides methods must not have a throws clause: " + type.getQualifiedName() + "." + providerMethod, providerMethod); TypeMirror returnType = types.erasure(providerMethodAsExecutable.getReturnType()); if (!returnType.getKind().equals(TypeKind.ERROR)) { TypeElement invalidTypeElement = elementUtils.getTypeElement(invalidTypeName); if (invalidTypeElement != null && types.isSameType(returnType, types.erasure(invalidTypeElement.asType()))) { error(String.format("@Provides method must not return %s directly: %s.%s", invalidTypeElement, type.getQualifiedName(), providerMethod), providerMethod); TypeMirror objectType = elementUtils.getTypeElement("java.lang.Object").asType();
@Override public Iterable<? extends Completion> getCompletions(Element annotated, AnnotationMirror annotation, ExecutableElement attr, String userText) { if (processingEnv == null || annotated == null || !annotated.getKind().isClass()) { return Collections.emptyList(); || !"org.openide.util.lookup.ServiceProvider".contentEquals(((TypeElement) annotation.getAnnotationType().asElement()).getQualifiedName())) { return Collections.emptyList(); if (!"service".contentEquals(attr.getSimpleName())) { return Collections.emptyList(); TypeElement jlObject = processingEnv.getElementUtils().getTypeElement("java.lang.Object"); TypeElement c = toProcess.remove(0); result.add(new TypeCompletion(c.getQualifiedName().toString() + ".class")); parents.add(c.getSuperclass()); parents.addAll(c.getInterfaces()); if (tm == null || tm.getKind() != TypeKind.DECLARED) { continue; TypeElement type = (TypeElement) processingEnv.getTypeUtils().asElement(tm);
private void writeCreateSubscriberMethods(BufferedWriter writer, List<ExecutableElement> methods, String callPrefix, String myPackage) throws IOException { for (ExecutableElement method : methods) { List<? extends VariableElement> parameters = method.getParameters(); TypeMirror paramType = getParamTypeMirror(parameters.get(0), null); TypeElement paramElement = (TypeElement) processingEnv.getTypeUtils().asElement(paramType); String methodName = method.getSimpleName().toString(); String eventClass = getClassString(paramElement, myPackage) + ".class"; Subscribe subscribe = method.getAnnotation(Subscribe.class); List<String> parts = new ArrayList<>(); parts.add(callPrefix + "(\"" + methodName + "\","); processingEnv.getMessager().printMessage(Diagnostic.Kind.NOTE, "Indexed @Subscribe at " + method.getEnclosingElement().getSimpleName() + "." + methodName + "(" + paramElement.getSimpleName() + ")");
private boolean isSubtype(Element typeElement, String type) { return processingEnv.getTypeUtils().isSubtype(typeElement.asType(), processingEnv.getElementUtils().getTypeElement(type).asType()); }
private void writeAsyncClass(Element elem) throws ClassNotFoundException, IOException, Exception { if (elem.getKind().isInterface()) { TypeElement interfaceClazz = (TypeElement) elem; String className = interfaceClazz.getSimpleName().toString(); TypeSpec.Builder classBuilder = TypeSpec.interfaceBuilder(className + ASYNC).addModifiers(Modifier.PUBLIC) .addSuperinterface(TypeName.get(elem.asType())); // add class generic type classBuilder.addTypeVariables(getTypeNames(interfaceClazz.getTypeParameters())); // add direct method addMethods(interfaceClazz, classBuilder); // add method form superinterface addSuperInterfaceMethods(interfaceClazz.getInterfaces(), classBuilder); // write class JavaFile javaFile = JavaFile.builder(processingEnv.getElementUtils().getPackageOf(interfaceClazz).getQualifiedName().toString(), classBuilder.build()).build(); javaFile.writeTo(new File(System.getProperty("basedir"), TARGET_DIR)); } else { processingEnv.getMessager().printMessage(Diagnostic.Kind.NOTE, "MotanAsyncProcessor not process, because " + elem.toString() + " not a interface."); } }
private Set<String> useProvidedTypesForServices(TypeElement typeElement, ImmutableList<TypeMirror> typesMirrors) { List<String> wrongTypes = Lists.newArrayList(); List<String> types = Lists.newArrayList(); for (TypeMirror typeMirror : typesMirrors) { if (typeMirror.getKind() != TypeKind.DECLARED || !processing().getTypeUtils().isAssignable(typeElement.asType(), typeMirror)) { wrongTypes.add(typeMirror.toString()); } else { types.add(typeMirror.toString()); } } if (!wrongTypes.isEmpty()) { processing().getMessager().printMessage( Diagnostic.Kind.ERROR, "@Metainf.Service(value = {...}) contains types that are not implemented by " + typeElement.getSimpleName() + ": " + wrongTypes, typeElement, AnnotationMirrors.findAnnotation(typeElement.getAnnotationMirrors(), Metainf.Service.class)); } return FluentIterable.from(types).toSet(); }
Element possibleCopyMethod, boolean onValueType) { if (possibleCopyMethod.getKind() == ElementKind.METHOD) { if (!valueAttribute.containingType.names().possibleAttributeBuilder(possibleCopyMethod.getSimpleName())) { return false; .environment() .processing() .getTypeUtils(); if (candidateCopyMethod.getParameters().size() == 1 && typeUtils.isSameType( candidateCopyMethod.getParameters().get(0).asType(), valueAttribute.containedTypeElement.asType())) { TypeKind kind = candidateCopyMethod.getReturnType().getKind(); return !kind.isPrimitive() && kind != TypeKind.ARRAY; && !candidateCopyMethod.getModifiers().contains(Modifier.STATIC)) { TypeKind kind = candidateCopyMethod.getReturnType().getKind(); return !kind.isPrimitive() && kind != TypeKind.ARRAY; } else if (!onValueType && possibleCopyMethod.getKind() == ElementKind.CONSTRUCTOR) { return candidateConstructor.getParameters().size() == 1 && candidateConstructor.getParameters().get(0).asType().equals(valueAttribute.containedTypeElement.asType());
List<TypeElement> enclosedTypes = ElementFilter.typesIn(elem.getEnclosedElements()); for (TypeElement enclosedType : enclosedTypes) { imports.add(enclosedType.getQualifiedName().toString()); Elements elementUtils = env.getElementUtils(); modelBuilder.documentType(elem, elementUtils.getDocComment(elem), imports); for (Element memberElement : ElementFilter.methodsIn(elem.getEnclosedElements())) { try { ExecutableElement methodElement = (ExecutableElement) memberElement; Implementation implementation = memberElement.getAnnotation(Implementation.class); for (Modifier modifier : memberElement.getModifiers()) { documentedMethod.modifiers.add(modifier.toString()); documentedMethod.maxSdk = sdkOrNull(implementation.maxSdk()); for (VariableElement variableElement : methodElement.getParameters()) { documentedMethod.params.add(variableElement.toString()); documentedMethod.returnType = methodElement.getReturnType().toString(); for (TypeMirror typeMirror : methodElement.getThrownTypes()) { documentedMethod.exceptions.add(typeMirror.toString()); String docMd = elementUtils.getDocComment(methodElement); if (docMd != null) { documentedMethod.setDocumentation(docMd);
/** * Returns true if there's a public way to build the value type with an instance no-arg method. * * @param attribute value attribute to check. * @param possibleBuildMethod method which matches {@link StyleMirror#attributeBuilder()} * @return true if this is the possibleBuildMethod can build the value type. */ private static boolean isPossibleBuildMethod(ValueAttribute attribute, Element possibleBuildMethod) { if (possibleBuildMethod.getKind() != ElementKind.METHOD) { return false; } if (!attribute.containingType.names().possibleAttributeBuilder(possibleBuildMethod.getSimpleName())) { return false; } Types typeUtils = attribute.containingType.constitution.protoclass() .environment() .processing() .getTypeUtils(); ExecutableElement candidateBuildMethod = (ExecutableElement) possibleBuildMethod; return !candidateBuildMethod.getModifiers().contains(Modifier.STATIC) && candidateBuildMethod.getModifiers().contains(Modifier.PUBLIC) && candidateBuildMethod.getTypeParameters().isEmpty() && candidateBuildMethod.getReturnType().getKind() == TypeKind.DECLARED && typeUtils.isSameType(candidateBuildMethod.getReturnType(), attribute.containedTypeElement.asType()); }
public JMethod overrideAnnotatedMethod(ExecutableElement executableElement, GeneratedClassHolder holder) { TypeMirror annotatedClass = holder.getAnnotatedElement().asType(); DeclaredType baseClass = (DeclaredType) executableElement.getEnclosingElement().asType(); Types typeUtils = environment.getProcessingEnvironment().getTypeUtils(); for (TypeParameterElement typeParameter : executableElement.getTypeParameters()) { List<? extends TypeMirror> bounds = typeParameter.getBounds(); String methodName = executableElement.getSimpleName().toString(); AbstractJClass returnType = typeMirrorToJClass(executableElement.getReturnType(), actualTypes); int modifier = elementVisibilityModifierToJMod(executableElement);
private boolean validateElement(Element element) { return element.getKind().isClass() && processingEnv.getTypeUtils().isAssignable(element.asType(), processingEnv.getElementUtils().getTypeElement(INTERCEPTOR_FULL_NAME).asType()); }
@Override public Optional<TypeMirror> builderType() { Optional<Entity> entityAnnotation = annotationOf(Entity.class); if (entityAnnotation.isPresent()) { Entity entity = entityAnnotation.get(); Elements elements = processingEnvironment.getElementUtils(); TypeMirror mirror = null; try { Class<?> builderClass = entity.builder(); // easiest way to get the class TypeMirror if (builderClass != void.class) { mirror = elements.getTypeElement(builderClass.getName()).asType(); } } catch (MirroredTypeException typeException) { mirror = typeException.getTypeMirror(); } if (mirror != null && mirror.getKind() != TypeKind.VOID) { return Optional.of(mirror); } } if (builderFactoryMethod().isPresent()) { return Optional.of(builderFactoryMethod().get().getReturnType()); } return ElementFilter.typesIn(element().getEnclosedElements()).stream() .filter(element -> element.getSimpleName().toString().contains("Builder")) .map(Element::asType) .filter(Objects::nonNull) .filter(type -> type.getKind() != TypeKind.VOID) .findFirst(); }
private void processDefaultLifeCycle(Set<? extends Element> elements) { DefaultLifeCycle ca = e.getAnnotation(DefaultLifeCycle.class); String lifeCycleClassName = ((TypeElement) e).getQualifiedName().toString(); String lifeCyclePackageName = lifeCycleClassName.substring(0, lifeCycleClassName.lastIndexOf('.')); lifeCycleClassName = lifeCycleClassName.substring(lifeCycleClassName.lastIndexOf('.') + 1); JavaFileObject fileObject = processingEnv.getFiler().createSourceFile(applicationPackageName + "." + applicationClassName); processingEnv.getMessager().printMessage(Diagnostic.Kind.NOTE, "Creating " + fileObject.toUri()); Writer writer = fileObject.openWriter(); try { processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR, x.toString());
void infoLog(String toLog) { processingEnv.getMessager().printMessage(Diagnostic.Kind.NOTE, "[" + round + "] " + toLog); }
private void processJsonFieldAnnotation(Element element, Map<String, JsonObjectHolder> jsonObjectMap, Elements elements, Types types) { if (!isJsonFieldFieldAnnotationValid(element, elements)) { return; } TypeElement enclosingElement = (TypeElement)element.getEnclosingElement(); JsonObjectHolder objectHolder = jsonObjectMap.get(TypeUtils.getInjectedFQCN(enclosingElement, elements)); JsonFieldHolder fieldHolder = objectHolder.fieldMap.get(element.getSimpleName().toString()); if (fieldHolder == null) { fieldHolder = new JsonFieldHolder(); objectHolder.fieldMap.put(element.getSimpleName().toString(), fieldHolder); } JsonField annotation = element.getAnnotation(JsonField.class); TypeMirror typeConverterType; try { typeConverterType = mProcessingEnv.getElementUtils().getTypeElement(annotation.typeConverter().getCanonicalName()).asType(); } catch (MirroredTypeException mte) { typeConverterType = mte.getTypeMirror(); } String[] fieldName = annotation.name(); JsonIgnore ignoreAnnotation = element.getAnnotation(JsonIgnore.class); boolean shouldParse = ignoreAnnotation == null || ignoreAnnotation.ignorePolicy() == IgnorePolicy.SERIALIZE_ONLY; boolean shouldSerialize = ignoreAnnotation == null || ignoreAnnotation.ignorePolicy() == IgnorePolicy.PARSE_ONLY; String error = fieldHolder.fill(element, elements, types, fieldName, typeConverterType, objectHolder, shouldParse, shouldSerialize); if (!TextUtils.isEmpty(error)) { error(element, error); } ensureTypeConverterClassValid(typeConverterType, elements, types); }
public boolean process(final Set<? extends TypeElement> annotations, final RoundEnvironment roundEnv) { if (resetResults) { processingResults = new HashMap<>(); } for (Element element : roundEnv.getElementsAnnotatedWith(Wid.class)) { if (element instanceof TypeElement) { TypeElement typeElement = (TypeElement) element; processingEnv.getMessager().printMessage(Diagnostic.Kind.NOTE, MessageFormat.format("Wid Processor : processing class {0}.", typeElement.asType().toString())); processingResults.put(typeElement.asType().toString(), new ArrayList<>()); if (typeElement.getInterfaces() != null && typeElement.getInterfaces().size() > 0) { for (TypeMirror mirror : typeElement.getInterfaces()) { if (mirror.getAnnotation(Wid.class) != null) { processingResults.get(typeElement.asType().toString()).add(mirror.getAnnotation(Wid.class)); } } } processingResults.get(typeElement.asType().toString()).add(typeElement.getAnnotation(Wid.class)); } } return postProcessWorkItemDefinition(); }
private boolean isMethodInBaseRequestOptions(ExecutableElement toFind) { // toFind is a method in a GlideExtension whose first argument is a BaseRequestOptions<?> type. // Since we're comparing against methods in BaseRequestOptions itself, we need to drop that // first type. TypeElement requestOptionsType = processingEnvironment .getElementUtils() .getTypeElement(RequestOptionsGenerator.BASE_REQUEST_OPTIONS_QUALIFIED_NAME); List<String> toFindParameterNames = getComparableParameterNames(toFind, true /*skipFirst*/); String toFindSimpleName = toFind.getSimpleName().toString(); for (Element element : requestOptionsType.getEnclosedElements()) { if (element.getKind() != ElementKind.METHOD) { continue; } ExecutableElement inBase = (ExecutableElement) element; if (toFindSimpleName.equals(inBase.getSimpleName().toString())) { List<String> parameterNamesInBase = getComparableParameterNames(inBase, false /*skipFirst*/); if (parameterNamesInBase.equals(toFindParameterNames)) { return true; } } } return false; }