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()))) { TypeMirror objectType = elementUtils.getTypeElement("java.lang.Object").asType(); if (!module.getKind().equals(ElementKind.CLASS)) { error("Modules must be classes: " + elementToString(module), module); continue;
private boolean isMethodProcessable(ExecutableElement element) { // if an immutable type with an implementation provided skip it if (!isUnimplementable() && element().getKind().isClass() && isImmutable() && !element.getModifiers().contains(Modifier.ABSTRACT)) { if (!ImmutableAnnotationKind.of(element()).isPresent() || !ImmutableAnnotationKind.of(element()).get().hasAnyMemberAnnotation(element)) { return false; } } String name = element.getSimpleName().toString(); // skip kotlin data class methods with component1, component2.. names if (isUnimplementable() && name.startsWith("component") && name.length() > "component".length()) { return false; } TypeMirror type = element.getReturnType(); boolean isInterface = element().getKind().isInterface(); boolean isTransient = Mirrors.findAnnotationMirror(element, Transient.class).isPresent(); // must be a getter style method with no args, can't return void or itself or its builder return type.getKind() != TypeKind.VOID && element.getParameters().isEmpty() && (isImmutable() || isInterface || !element.getModifiers().contains(Modifier.FINAL)) && (!isImmutable() || !type.equals(element().asType())) && !type.equals(builderType().orElse(null)) && !element.getModifiers().contains(Modifier.STATIC) && !element.getModifiers().contains(Modifier.DEFAULT) && (!isTransient || isInterface) && !name.equals("toString") && !name.equals("hashCode"); }
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 static boolean isTypeElement(Element element) { ElementKind kind = element.getKind(); return kind.isClass() || kind.isInterface(); }
private TypeElement enclosingTypeOf(Element element) { for (Element e = element; e != null;) { ElementKind kind = e.getKind(); if (kind.isClass() || kind.isInterface()) { return (TypeElement) e; } e = e.getEnclosingElement(); } throw new NoSuchElementException(); }
private String computePath(ExecutableElement element) { String path = element.getSimpleName().toString(); for (Element e = element.getEnclosingElement(); // e.getKind().isClass() || e.getKind().isInterface(); // e = e.getEnclosingElement()) { path = e.getSimpleName() + "." + path; } if (element.getModifiers().contains(Modifier.ABSTRACT)) { return path; } return path + "()"; }
public void validateRestSimpleParameter(Element element, String requiredClass, String parameterName, ElementValidation validation) { TypeMirror requiredType = annotationHelper.typeElementFromQualifiedName(requiredClass).asType(); DeclaredType paramterType = annotationHelper.extractAnnotationClassParameter(element, annotationHelper.getTarget(), parameterName); if (paramterType != null) { if (annotationHelper.isSubtype(paramterType, requiredType)) { Element parameterElement = paramterType.asElement(); if (parameterElement.getKind().isClass()) { if (!annotationHelper.isAbstract(parameterElement)) { if (parameterElement.getAnnotation(EBean.class) != null) { typeIsValid(EBean.class, paramterType, validation); return; } List<ExecutableElement> constructors = ElementFilter.constructorsIn(parameterElement.getEnclosedElements()); for (ExecutableElement constructor : constructors) { if (annotationHelper.isPublic(constructor) && constructor.getParameters().isEmpty()) { return; } } validation.addError(element, "The " + parameterName + " class must have a public no argument constructor or must be annotated with @EBean"); } else { validation.addError(element, "The " + parameterName + " class must not be abstract"); } } else { validation.addError(element, "The " + parameterName + " class must be a class"); } } else { validation.addError(element, "The " + parameterName + " class must be a subtype of " + requiredClass); } } }
@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;
for ( Element elem : element.getEnclosedElements() ) { if ( !expectedElementKind.equals( elem.getKind() ) ) { continue; String name = elem.getSimpleName().toString(); if ( ElementKind.METHOD.equals( elem.getKind() ) ) { name = StringUtil.getPropertyName( name ); mirror = ( (ExecutableElement) elem ).getReturnType(); switch ( mirror.getKind() ) { case INT: { return "java.lang.Integer"; return ((DeclaredType)mirror).asElement().asType().toString(); return mirror.toString();
public void isPrefMethod(Element element, ElementValidation valid) { if (!element.getKind().equals(ElementKind.METHOD)) { valid.addError("Only methods are allowed in an %s annotated interface"); } else { ExecutableElement executableElement = (ExecutableElement) element; String methodName = executableElement.getSimpleName().toString(); if (executableElement.getParameters().size() > 0) { valid.addError("Method " + methodName + " should have no parameters in an %s annotated interface"); } else { String returnType = executableElement.getReturnType().toString(); if (!VALID_PREF_RETURN_TYPES.contains(returnType)) { valid.addError("Method " + methodName + " should only return preference simple types in an %s annotated interface"); } else { if (INVALID_PREF_METHOD_NAMES.contains(methodName)) { valid.addError("The method name " + methodName + " is forbidden in an %s annotated interface"); } else { return; } } } } valid.invalidate(); }
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 addMethods(TypeElement interfaceClazz, TypeSpec.Builder classBuilder) { List<? extends Element> elements = interfaceClazz.getEnclosedElements(); if (elements != null && !elements.isEmpty()) { for (Element e : elements) { if (ElementKind.METHOD.equals(e.getKind())) { ExecutableElement method = (ExecutableElement) e; MethodSpec.Builder methodBuilder = MethodSpec.methodBuilder(method.getSimpleName().toString() + ASYNC) .addModifiers(Modifier.PUBLIC, Modifier.ABSTRACT).returns(ResponseFuture.class) .addTypeVariables(getTypeNames(method.getTypeParameters())); // add method params List<? extends VariableElement> vars = method.getParameters(); for (VariableElement var : vars) { methodBuilder.addParameter(ParameterSpec.builder(TypeName.get(var.asType()), var.getSimpleName().toString()) .build()); } classBuilder.addMethod(methodBuilder.build()); } } } }
@Override public String toString() { StringBuilder sb = new StringBuilder(); sb.append("simpleName: "); sb.append(this.element.getSimpleName()); sb.append(", kind: "); sb.append(this.element.getKind().toString()); sb.append(", type: "); sb.append(this.element.asType().toString()); return sb.toString(); } }
@Override public TypeMirror typeMirror() { if (element().getKind().isField()) { return element().asType(); } else { ExecutableElement executableElement = (ExecutableElement) element(); return executableElement.getReturnType(); } }
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."); } }
public static <T extends Element> ImmutableList<FieldModel> extractFields(T element) { final List<FieldModel> fields = new ArrayList<>(); for (Element enclosedElement : element.getEnclosedElements()) { if (ElementKind.FIELD.equals(enclosedElement.getKind())) { Set<Modifier> modifiers = enclosedElement.getModifiers(); fields.add( new FieldModel( FieldSpec.builder( TypeName.get(enclosedElement.asType()), enclosedElement.getSimpleName().toString(), modifiers.toArray(new Modifier[modifiers.size()])) .build(), enclosedElement)); } } return ImmutableList.copyOf(fields); } }
private boolean validateElement(Element element) { return element.getKind().isClass() && processingEnv.getTypeUtils().isAssignable(element.asType(), processingEnv.getElementUtils().getTypeElement(INTERCEPTOR_FULL_NAME).asType()); }
protected String descriptionOf(javax.lang.model.element.Element element) { StringBuilder description = new StringBuilder(); ElementKind kind = element.getKind(); if (kind != null) { description.append(kind.name()).append(' '); } Name name = element.getSimpleName(); if (element instanceof TypeElement) { name = ((TypeElement) element).getQualifiedName(); } description.append(name.toString()); return description.toString(); } }
public Void visitIdentifier(IdentifierTree node, Void p) { TreePath path = getCurrentPath(); Element element = info.getTrees().getElement(path); if (element != null && element.asType().getKind() != TypeKind.ERROR) { // solve the imports only when declared type!!! if (element.getKind().isClass() || element.getKind().isInterface() || (element.getKind().isField() && ((Symbol) element).isStatic())) { Tree parent = path.getParentPath() != null ? path.getParentPath().getLeaf() : null; if ( (parent != null && parent.getKind() == Kind.CASE && ((CaseTree) parent).getExpression() == node && element.getKind() == ElementKind.ENUM_CONSTANT) || (path.getCompilationUnit() != null && ((Symbol) element).enclClass() != null && path.getCompilationUnit().getSourceFile() == ((Symbol) element).enclClass().sourcefile)) { translateMap.put(node, make.Identifier(element.getSimpleName())); } else { translateMap.put(node, make.QualIdent(element)); } } } return null; }