@Override public boolean process( Set<? extends TypeElement> annotations, RoundEnvironment roundEnv ) { for ( TypeElement type : annotations ) { for ( Element annotated : roundEnv.getElementsAnnotatedWith( type ) ) { for ( AnnotationMirror mirror : annotated.getAnnotationMirrors() ) { if ( mirror.getAnnotationType().asElement().equals( type ) ) { try { process( type, annotated, mirror, processingEnv.getElementUtils() .getElementValuesWithDefaults( mirror ) ); } catch ( Exception e ) { e.printStackTrace(); processingEnv.getMessager().printMessage( Kind.ERROR, "Internal error: " + e, annotated, mirror ); } } } } } return false; }
@Override public boolean process(Set<? extends TypeElement> types, RoundEnvironment env) { remainingTypes.putAll(providerMethodsByClass(env)); for (Iterator<String> i = remainingTypes.keySet().iterator(); i.hasNext();) { String typeName = i.next(); TypeElement type = processingEnv.getElementUtils().getTypeElement(typeName); List<ExecutableElement> providesTypes = remainingTypes.get(typeName); try { // Attempt to get the annotation. If types are missing, this will throw // CodeGenerationIncompleteException. Map<String, Object> parsedAnnotation = getAnnotation(Module.class, type); if (parsedAnnotation == null) { error(type + " has @Provides methods but no @Module annotation", type); continue; } JavaFile javaFile = generateModuleAdapter(type, parsedAnnotation, providesTypes); javaFile.writeTo(processingEnv.getFiler()); } catch (CodeGenerationIncompleteException e) { continue; // A dependent type was not defined, we'll try to catch it on another pass. } catch (IOException e) { error("Code gen failed: " + e, type); } i.remove(); } if (env.processingOver() && remainingTypes.size() > 0) { processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR, "Could not find types required by provides methods for " + remainingTypes.keySet()); } return false; // FullGraphProcessor needs an opportunity to process. }
if (!roundEnv.processingOver()) { for (TypeElement te : annotations) { final Set< ? extends Element> elts = roundEnv.getElementsAnnotatedWith(te); for (Element elt : elts) { env.getMessager().printMessage(Kind.WARNING, String.format("%s : thou shalt not hack %s", roundEnv.getRootElements(), elt), elt);
@Override public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) { this.metadataCollector.processing(roundEnv); roundEnv.getRootElements().forEach(this::processElement); if (roundEnv.processingOver()) { writeMetaData(); } return false; }
@Override public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment round) { if (!round.processingOver() && !round.errorRaised()) { processTemplates(round.getElementsAnnotatedWith(Generator.Template.class)); } return true; }
@Override public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) { if (roundEnv.processingOver()) { if (log != null) { log.close(); TypeMirror verticleType = processingEnv.getElementUtils().getTypeElement(Verticle.class.getName()).asType(); for (Element rootElt : roundEnv.getRootElements()) { Set<Modifier> modifiers = rootElt.getModifiers(); if (rootElt.getKind() == ElementKind.CLASS && !modifiers.contains(Modifier.ABSTRACT) && modifiers.contains(Modifier.PUBLIC) && processingEnv.getTypeUtils().isSubtype(rootElt.asType(), verticleType)) { TypeElement typeElt = (TypeElement) rootElt; for (Element enclosedElt : typeElt.getEnclosedElements()) { if (enclosedElt.getKind() == ElementKind.METHOD) { ExecutableElement methodElt = (ExecutableElement) enclosedElt; roundEnv.getElementsAnnotatedWith(CodeTranslate.class).forEach(annotatedElt -> { methodElts.add((ExecutableElement) annotatedElt); }); 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())); continue;
public @Override boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) { if (roundEnv.processingOver()) { return false; for (Element e : roundEnv.getElementsAnnotatedWith(NbBundle.Messages.class)) { NbBundle.Messages messages = e.getAnnotation(NbBundle.Messages.class); if (messages == null) { // bug in java.source, apparently; similar to #195983 continue; String pkg = packageEntry.getKey(); Set<Element> annotatedElements = packageEntry.getValue(); PackageElement pkgE = processingEnv.getElementUtils().getPackageElement(pkg); if (pkgE != null) { Set<Element> unscannedTopElements = new HashSet<Element>(); unscannedTopElements.addAll(pkgE.getEnclosedElements()); } catch (/*NullPointerException,BadClassFile*/RuntimeException x) { // #196556 processingEnv.getMessager().printMessage(Kind.WARNING, "#196556: reading " + pkg + " failed with " + x + " in " + x.getStackTrace()[0] + "; do a clean build!"); unscannedTopElements.removeAll(roundEnv.getRootElements()); addToAnnotatedElements(unscannedTopElements, annotatedElements); } else { processingEnv.getMessager().printMessage(Kind.WARNING, "Could not check for other source files in " + pkg);
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; TypeElement invalidTypeElement = elementUtils.getTypeElement(invalidTypeName); if (invalidTypeElement != null && types.isSameType(returnType, types.erasure(invalidTypeElement.asType()))) { TypeMirror objectType = elementUtils.getTypeElement("java.lang.Object").asType(); for (Element module : env.getElementsAnnotatedWith(Module.class)) { if (!module.getKind().equals(ElementKind.CLASS)) { error("Modules must be classes: " + elementToString(module), module);
@Override protected boolean handleProcess(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) throws LayerGenerationException { Messager messager = processingEnv.getMessager(); for (Element e : roundEnv.getElementsAnnotatedWith(PropertyEditorSearchPath.class)) { String pkg = findPackage(e); String pkgFilename = pkg.replace(".", "-"); //NOI18N for (Element e : roundEnv.getElementsAnnotatedWith(PropertyEditorRegistration.class)) { if (e.getKind() == ElementKind.CLASS) { String className = ((TypeElement) e).getQualifiedName().toString(); Collection<AnnotationValue> targetTypes = null; List<? extends AnnotationMirror> annotationMirrors = e.getAnnotationMirrors(); for (AnnotationMirror am : annotationMirrors) { for (Entry<? extends ExecutableElement, ? extends AnnotationValue> entry : am.getElementValues().entrySet()) { messager.printMessage(Kind.ERROR, "No targetType is specified", e); //NOI18N continue; TypeElement typeElement = processingEnv.getElementUtils().getTypeElement("java.beans.PropertyEditor"); //NOI18N if (!processingEnv.getTypeUtils().isSubtype(e.asType(), typeElement.asType())) { messager.printMessage(Kind.ERROR, className + " is not subtype of PropertyEditor", e); //NOI18N continue; for (Element e : roundEnv.getElementsAnnotatedWith(BeanInfoSearchPath.class)) { String pkg = findPackage(e); String pkgFilename = pkg.replace(".", "-"); //NOI18N
String[] prefix = customAnnotation.getAnnotation(DEEP_LINK_SPEC_CLASS).prefix(); if (Utils.hasEmptyOrNullString(prefix)) { error(customAnnotation, "Prefix property cannot have null or empty strings"); roundEnv.getElementsAnnotatedWith(MoreElements.asType(customAnnotation))); elementsToProcess.addAll(roundEnv.getElementsAnnotatedWith(DEEP_LINK_CLASS)); String qualifiedName = returnType.getQualifiedName().toString(); if (!qualifiedName.equals("android.content.Intent") && !qualifiedName.equals("androidx.core.app.TaskStackBuilder")) { deepLinkElements.add(new DeepLinkAnnotatedElement(deepLink, element, type)); } catch (MalformedURLException e) { messager.printMessage(Diagnostic.Kind.ERROR, "Malformed Deep Link URL " + deepLink); roundEnv.getElementsAnnotatedWith(DeepLinkHandler.class); for (Element deepLinkHandlerElement : deepLinkHandlerElements) { Optional<AnnotationMirror> annotationMirror = roundEnv.getElementsAnnotatedWith(DeepLinkModule.class); for (Element deepLinkModuleElement : deepLinkModuleElements) { String packageName = processingEnv.getElementUtils() .getPackageOf(deepLinkModuleElement).getQualifiedName().toString();
@Override protected boolean handleProcess(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) { for (Element e : roundEnv.getElementsAnnotatedWith(NamedServiceDefinition.class)) { NamedServiceDefinition nsd = e.getAnnotation(NamedServiceDefinition.class); Matcher m = reference.matcher(nsd.path()); while (m.find()) { final ExecutableElement attr = findAttribute(e, m.group(1)); if (attr == null) { processingEnv.getMessager().printMessage( Diagnostic.Kind.ERROR, "The path attribute contains '" + TypeMirror stringType = processingEnv.getElementUtils().getTypeElement("java.lang.String").asType(); // NOI18N if (processingEnv.getTypeUtils().isAssignable(toCheck, stringType)) { continue; continue; processingEnv.getMessager().printMessage( Diagnostic.Kind.ERROR, "The path attribute contains '" + m.group(0) + Retention ret = e.getAnnotation(Retention.class); Target tar = e.getAnnotation(Target.class); throw new IllegalStateException(ex); for (Element e : roundEnv.getElementsAnnotatedWith(c)) {
if (!env.processingOver()) { for (Element e : env.getElementsAnnotatedWith(Module.class)) { if (!(e instanceof TypeElement)) { error("@Module applies to a type, " + e.getSimpleName() + " is a " + e.getKind(), e); continue; delayedModuleNames.add(((TypeElement) e).getQualifiedName().toString()); modules.add(elements().getTypeElement(moduleName)); continue; } catch (InvalidBindingException e) { error("Graph validation failed: " + e.getMessage(), elements().getTypeElement(e.type)); continue; } catch (RuntimeException e) { StringWriter sw = new StringWriter(); e.printStackTrace(new PrintWriter(sw)); processingEnv.getMessager() .printMessage(Diagnostic.Kind.WARNING, "Graph visualization failed. Please report this as a bug.\n\n" + sw, moduleType);
Types types = processingEnv.getTypeUtils(); for (Element element : roundEnv.getElementsAnnotatedWith(annotation)) { typeElementOf(element).ifPresent(typeElement -> { EntityElement entity = null; Elements elements = processingEnv.getElementUtils(); TypeMirror typeMirror = entity.element().getSuperclass(); while (typeMirror.getKind() != TypeKind.NONE) { TypeElement superElement = elements.getTypeElement(typeMirror.toString()); if (superElement != null) { mergeSuperType(entity, superElement); StringBuilder sb = new StringBuilder("Model has error(s) code generation may fail: "); validators.forEach(validator -> sb.append(validator.toString())); processingEnv.getMessager().printMessage(Diagnostic.Kind.WARNING, sb); generator.generate(); } catch (IOException e) { processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR, e.getMessage());
processingEnv.getMessager().printMessage(Diagnostic.Kind.NOTE, "Attempting to workaround javac bug #6512707"); for (Element el : roundEnv.getRootElements()) { if (el.getKind().isClass() || el.getKind().isInterface()) { seenElements.add(((TypeElement) el).getQualifiedName().toString()); TypeElement resolved = processingEnv.getElementUtils().getTypeElement(fqn); processingEnv.getMessager().printMessage(Diagnostic.Kind.NOTE, "Cannot clean " + fqn); continue; cleanTrees.invoke(null, List.from(toClean.toArray(new JCTree[0]))); } catch (Throwable t) { processingEnv.getMessager().printMessage(Diagnostic.Kind.NOTE, "Failed with a Throwable: " + t.getMessage());
@Override public boolean process(Set<? extends TypeElement> type, RoundEnvironment env) { Types typeUtils = processingEnv.getTypeUtils(); Filer filer = processingEnv.getFiler(); String fragmentArgsLib = processingEnv.getOptions().get(OPTION_IS_LIBRARY); if (fragmentArgsLib != null && fragmentArgsLib.equalsIgnoreCase("true")) { isLibrary = true; for (Element element : env.getElementsAnnotatedWith(Arg.class)) { TypeElement enclosingElement = (TypeElement) element.getEnclosingElement(); throw new ProcessingException(element, "@Arg can only be used on fragment fields (%s.%s)", enclosingElement.getQualifiedName(), element); if (element.getModifiers().contains(Modifier.FINAL)) { throw new ProcessingException(element, "@Arg fields must not be final (%s.%s)", enclosingElement.getQualifiedName(), element); for (Element element : env.getElementsAnnotatedWith(FragmentWithArgs.class)) { try { scanForAnnotatedFragmentClasses(env, FragmentWithArgs.class, fragmentClasses, element);
@Override public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) { for (TypeElement annotation : annotations) { Set<? extends Element> elementsAnnotatedWith = roundEnv.getElementsAnnotatedWith(annotation); for (Element element : elementsAnnotatedWith) { if (!element.getModifiers().contains(Modifier.PUBLIC)) { processingEnv.getMessager().printMessage( Diagnostic.Kind.ERROR, element.getSimpleName() + " must be public", element ); } } } return false; } }
@Override public boolean process(@Nullable Set<? extends TypeElement> annotations, @NonNull RoundEnvironment roundEnv) { try { final ArrayList<? extends Element> annotatedElements = new ArrayList<>(roundEnv.getElementsAnnotatedWith(Configuration.class)); if (!annotatedElements.isEmpty()) { for (final Element e : annotatedElements) { if (e.getKind() == ElementKind.ANNOTATION_TYPE) { new ClassCreator(MoreElements.asType(e), e.getAnnotation(Configuration.class), processingEnv).createClasses(); } else { processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR, String.format("%s is only supported on %s", Configuration.class.getName(), ElementKind.ANNOTATION_TYPE.name()), e); } } } } catch (Exception e) { e.printStackTrace(); processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR, "Failed to generate acra classes"); } return true; }
@Override public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) { if (roundEnv.processingOver()) { return false; mPropNameInterStageStore = new PropNameInterStageStore(processingEnv.getFiler()); final SpecModel specModel = specModelFactory.create( processingEnv.getElementUtils(), processingEnv.getTypeUtils(), (TypeElement) element, processingEnv.getMessager(), processingEnv .getMessager() .printMessage( Diagnostic.Kind.ERROR, String.format(
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 void doProcess(final Set<? extends TypeElement> annotations, final RoundEnvironment roundEnv) { final String propertiesPath = processingEnv.getOptions().getOrDefault(EXPRESSION_PROPERTIES, ""); final Properties expressionProperties = new Properties(); if (!propertiesPath.isEmpty()) { final boolean addGeneratedAnnotation = Boolean.parseBoolean(processingEnv.getOptions().getOrDefault(ADD_GENERATED_ANNOTATION, "true")); boolean generate = true; final Validator validator = new Validator(processingEnv); if (interfaceAnnotations.contains(annotation.getQualifiedName().toString())) { try { final Set<? extends TypeElement> interfaces = typesIn(roundEnv.getElementsAnnotatedWith(annotation)); for (TypeElement interfaceElement : interfaces) { try { final Collection<ValidationMessage> validationMessages = validator.validate(messageInterface); for (ValidationMessage message : validationMessages) { if (message.printMessage(processingEnv.getMessager())) { generate = false; if (interfaceElement.getKind().isInterface() && !interfaceElement.getModifiers().contains(Modifier.PRIVATE)) { for (AbstractGenerator processor : generators) { logger.debug("Executing processor %s", processor.getName());