Refine search
private static boolean isTypeElement(Element element) { ElementKind kind = element.getKind(); return kind.isClass() || kind.isInterface(); }
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 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 static boolean isSameKind (ElementKind k1, ElementKind k2) { if ((k1 == k2) || (k1 == ElementKind.OTHER && (k2.isClass() || k2.isInterface())) || (k2 == ElementKind.OTHER && (k1.isClass() || k1.isInterface()))) { return true; } return false; }
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 static void addParent(final TypeSpec.Builder builder, final TypeElement superElement) { final ElementKind kind = superElement.getKind(); final TypeName parentType = TypeUtils.getTypeName(superElement); if (kind.isInterface()) { builder.addSuperinterface(parentType); } else if (kind.isClass()) { builder.superclass(parentType); } else { throw new UnsupportedOperationException("Unknown type of parent"); } }
private String getName(Element e) { if (e.getKind().isClass() || e.getKind().isInterface()) { return processingEnv.getElementUtils().getBinaryName((TypeElement)e).toString(); } else if (e.getKind() == ElementKind.PACKAGE) { return e.getSimpleName().toString(); } else { return getName(e.getEnclosingElement()) + '.' + e.getSimpleName(); } }
/** * Returns a binary name of the {@link TypeElement} represented by this * {@link ElementHandle}. When the {@link ElementHandle} doesn't represent * a {@link TypeElement} it throws a {@link IllegalStateException} * @return the qualified name * @throws an {@link IllegalStateException} when this {@link ElementHandle} * isn't created for the {@link TypeElement}. */ public @NonNull String getBinaryName () throws IllegalStateException { if ((this.kind.isClass() && !isArray(signatures[0])) || this.kind.isInterface() || this.kind == ElementKind.OTHER) { return this.signatures[0]; } else { throw new IllegalStateException (); } }
private static boolean shouldDisableFor(Reporter reporter, Element element) { while (element != null) { if (element.getKind() == ElementKind.PACKAGE) { for (String segment : DOT_SPLITTER.split(((PackageElement) element).getQualifiedName())) { if (!segment.isEmpty() && Ascii.isUpperCase(segment.charAt(0))) { reporter.warning(About.INCOMPAT, WARNING_START + " uppercase package names"); return true; } } } if (element.getKind().isClass() || element.getKind().isInterface()) { if (Ascii.isLowerCase(element.getSimpleName().charAt(0))) { reporter.warning(About.INCOMPAT, WARNING_START + " lowercase class names"); return true; } } element = element.getEnclosingElement(); } return false; } }
@Override public boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnvironment) { Set<? extends Element> elements = roundEnvironment.getElementsAnnotatedWith(Route.class); if (elements == null || elements.isEmpty()) { return true; } mLogger.info(String.format(">>> %s: RouteProcessor begin... <<<", mModuleName)); // 合法的TypeElement集合 Set<TypeElement> typeElements = new HashSet<>(); for (Element element : elements) { if (element.getKind().isClass() && validateClass((TypeElement) element)) { // 注解在Class上的Route typeElements.add((TypeElement) element); } else if (element.getKind() == ElementKind.METHOD) { // 注解在Method上的Route validateMethod((ExecutableElement) element); } } if (mModuleName != null) { String validModuleName = mModuleName.replace(".", "_").replace("-", "_"); generateRouteTable(validModuleName, typeElements); generateTargetInterceptorsTable(validModuleName, typeElements); } else { throw new RuntimeException(String.format("No option `%s` passed to Route annotation processor.", OPTION_MODULE_NAME)); } mLogger.info(String.format(">>> %s: RouteProcessor end. <<<", mModuleName)); return true; }
private TypeInfoKind kind() { ElementKind kind = element.getKind(); if (kind.isClass()) { return TypeInfoKind.CLASS; } if (kind.isInterface()) { return TypeInfoKind.INTERFACE; } if (ElementKind.ANNOTATION_TYPE.equals(kind)) { return TypeInfoKind.ANNOTATION_TYPE; } if (ElementKind.ENUM.equals(kind)) { return TypeInfoKind.ENUM; } throw new UnsupportedOperationException(kind.toString()); }
@Nullable private TypeElement findBuilderElement() { Protoclass protoclass = protoclass(); if (!protoclass.kind().isValue()) { return null; } for (Element t : protoclass.sourceElement().getEnclosedElements()) { ElementKind kind = t.getKind(); if (kind.isClass() || kind.isInterface()) { String simpleName = t.getSimpleName().toString(); Naming typeInnerBuilderNaming = names().namings.typeInnerBuilder; if (!typeInnerBuilderNaming.detect(simpleName).isEmpty()) { return (TypeElement) t; } } } return null; }
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); } } }
/** * Returns a qualified name of the {@link TypeElement} represented by this * {@link ElementHandle}. When the {@link ElementHandle} doesn't represent * a {@link TypeElement} it throws a {@link IllegalStateException} * @return the qualified name * @throws an {@link IllegalStateException} when this {@link ElementHandle} * isn't creatred for the {@link TypeElement}. */ public @NonNull String getQualifiedName () throws IllegalStateException { if ((this.kind.isClass() && !isArray(signatures[0])) || this.kind.isInterface() || this.kind == ElementKind.OTHER) { return this.signatures[0].replace (Target.DEFAULT.syntheticNameChar(),'.'); //NOI18N } else { throw new IllegalStateException (); } }
static TypeElement getMostEnclosingElement(Element element) { if (element == null) { return null; } while (element.getEnclosingElement() != null && element.getEnclosingElement().getKind().isClass() || element.getEnclosingElement().getKind().isInterface()) { element = element.getEnclosingElement(); } return (TypeElement) element; } }