Refine search
private boolean checkHasNoErrors(ExecutableElement element, Messager messager) { if (element.getModifiers().contains(Modifier.STATIC)) { messager.printMessage(Diagnostic.Kind.ERROR, "Subscriber method must not be static", element); return false; } if (!element.getModifiers().contains(Modifier.PUBLIC)) { messager.printMessage(Diagnostic.Kind.ERROR, "Subscriber method must be public", element); return false; } List<? extends VariableElement> parameters = ((ExecutableElement) element).getParameters(); if (parameters.size() != 1) { messager.printMessage(Diagnostic.Kind.ERROR, "Subscriber method must have exactly 1 parameter", element); return false; } return true; }
/** * Return true if the possibleBuilderMethod matches the * Style#attributeBuilder() and returns a class. * * TODO: may need to make this return true if the return type is an interface too... * * @param possibleBuilderMethod executableElement */ private static boolean isPossibleBuilderMethod(Element possibleBuilderMethod, boolean onValueType, ValueAttribute valueAttribute) { if (possibleBuilderMethod.getKind() == ElementKind.METHOD) { if (!valueAttribute.containingType.names().possibleAttributeBuilder(possibleBuilderMethod.getSimpleName())) { return false; } ExecutableElement candidateMethod = (ExecutableElement) possibleBuilderMethod; TypeKind kind = candidateMethod.getReturnType().getKind(); return possibleBuilderMethod.getModifiers().containsAll( Arrays.asList(Modifier.STATIC, Modifier.PUBLIC)) && candidateMethod.getParameters().isEmpty() && candidateMethod.getReturnType().getKind() == TypeKind.DECLARED && !kind.isPrimitive() && kind != TypeKind.ARRAY; } else if (!onValueType && possibleBuilderMethod.getKind() == ElementKind.CONSTRUCTOR) { if (!valueAttribute.containingType.names().newTokenInAttributeBuilder()) { return false; } ExecutableElement candidateConstructor = (ExecutableElement) possibleBuilderMethod; return candidateConstructor.getModifiers().contains(Modifier.PUBLIC) && candidateConstructor.getTypeParameters().isEmpty(); } return false; }
private static boolean hasNone(ExecutableElement elem, Modifier... modifiers) { final Set<Modifier> set = elem.getModifiers(); for (Modifier modifier : modifiers) { if (set.contains(modifier)) { return false; } } return true; }
public MethodExtraInfo(ExecutableElement methodElement) { this.isStatic = methodElement.getModifiers().contains(Modifier.STATIC); this.returnType = typeWithoutGenerics(canonicalize(methodElement.getReturnType())); }
private CharSequence appendAccessModifier(ExecutableElement m, StringBuilder signature) { if (m.getModifiers().contains(Modifier.PUBLIC)) { return signature.append("public "); } if (m.getModifiers().contains(Modifier.PROTECTED)) { return signature.append("protected "); } return signature; }
private boolean shouldConsideredAsTypeUsage(ExecutableElement method) { return method.getTypeParameters().isEmpty() && !method.getModifiers().contains(Modifier.PRIVATE) && !method.getModifiers().contains(Modifier.STATIC); }
static boolean suitableForBuilderFactory(ExecutableElement element) { return element.getKind() == ElementKind.METHOD && element.getReturnType().getKind() != TypeKind.VOID && !element.getModifiers().contains(Modifier.PRIVATE) && element.getModifiers().contains(Modifier.STATIC); }
/** * @return True if the clazz (or one of its superclasses) implements the given method. Returns * false if the method doesn't exist anywhere in the class hierarchy or it is abstract. */ static boolean implementsMethod(TypeElement clazz, MethodSpec method, Types typeUtils, Elements elements) { ExecutableElement methodOnClass = getMethodOnClass(clazz, method, typeUtils, elements); if (methodOnClass == null) { return false; } Set<Modifier> modifiers = methodOnClass.getModifiers(); return !modifiers.contains(Modifier.ABSTRACT); }
@Override public Void visitExecutable(ExecutableElement elem, TypeElement parent) { Set<Modifier> modifiers = elem.getModifiers(); if (!METHODS_ALLOWED_TO_BE_PUBLIC.contains(elem.getSimpleName().toString())) { if (!modifiers.contains(Modifier.PUBLIC) && !modifiers.contains(Modifier.PROTECTED)) { message(Kind.ERROR, "@Implementation methods should be protected (preferred) or public (deprecated)"); } } // TODO: Check that it has the right signature return null; } }
@Override public Optional<ExecutableElement> builderFactoryMethod() { return ElementFilter.methodsIn(element().getEnclosedElements()).stream() .filter(element -> element.getModifiers().contains(Modifier.STATIC)) .filter(element -> element.getSimpleName().toString().equals("builder")) .findFirst(); }
private Stream<CompilationMessage> validateConstructor( Element extensionClass ) { Optional<ExecutableElement> publicNoArgConstructor = constructorsIn( extensionClass.getEnclosedElements() ).stream() .filter( c -> c.getModifiers().contains( Modifier.PUBLIC ) ) .filter( c -> c.getParameters().isEmpty() ).findFirst(); if ( !publicNoArgConstructor.isPresent() ) { return Stream.of( new ExtensionMissingPublicNoArgConstructor( extensionClass, "Extension class %s should contain a public no-arg constructor, none found.", extensionClass ) ); } return Stream.empty(); } }
/** * Returns true if generated code can invoke {@code constructor}. That is, if * the constructor is non-private and its enclosing class is either a * top-level class or a static nested class. */ public static boolean isCallableConstructor(ExecutableElement constructor) { if (constructor.getModifiers().contains(Modifier.PRIVATE)) { return false; } TypeElement type = (TypeElement) constructor.getEnclosingElement(); return type.getEnclosingElement().getKind() == ElementKind.PACKAGE || type.getModifiers().contains(Modifier.STATIC); }
@Override public boolean isValidConstructor(ExecutableElement constructor) { return constructor.getModifiers().contains(Modifier.PUBLIC) && constructor.getAnnotation(QueryProjection.class) != null && !constructor.getParameters().isEmpty(); }
static boolean suitableForBuilderConstructor(ExecutableElement element) { return element.getKind() == ElementKind.CONSTRUCTOR && !element.getModifiers().contains(Modifier.PRIVATE); }
@Override public boolean apply(Element input) { if (input.getKind() != ElementKind.METHOD) { return false; } if (isJavaLangObject((TypeElement) input.getEnclosingElement())) { return false; } ExecutableElement element = (ExecutableElement) input; boolean parameterless = element.getParameters().isEmpty(); boolean nonstatic = !element.getModifiers().contains(Modifier.STATIC); return parameterless && nonstatic; } }
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 + "()"; }
private static boolean hasStringArrayConstructor(TypeElement element) { for (ExecutableElement e : ElementFilter.constructorsIn(element.getEnclosedElements())) { if (e.getModifiers().contains(Modifier.PUBLIC) && e.getParameters().size() == 1) { if (isArrayOfStrings(e.getParameters().get(0).asType())) { return true; } } } return false; }
private static Collection<ExecutableElement> getMessageMethods(final TypeElement intf) { return ElementFilter.methodsIn(intf.getEnclosedElements()) .stream() .filter(method -> !method.isDefault() && !method.getModifiers().contains(Modifier.STATIC)) .collect(Collectors.toList()); } }
/** * Checks if an public empty constructor is available */ private boolean hasPublicEmptyConstructor(DeclaredType type) { Element element = type.asElement(); List<? extends Element> containing = element.getEnclosedElements(); for (Element e : containing) { if (e.getKind() == ElementKind.CONSTRUCTOR) { ExecutableElement c = (ExecutableElement) e; if ((c.getParameters() == null || c.getParameters().isEmpty()) && c.getModifiers() .contains(javax.lang.model.element.Modifier.PUBLIC)) { return true; } } } return false; }
/** * Check if the given class or any of its super classes have a super method with the given name. * Private methods are ignored since the generated subclass can't call super on those. */ protected boolean hasSuperMethod(TypeElement classElement, Element attribute) { if (!Utils.isEpoxyModel(classElement.asType())) { return false; } for (Element subElement : classElement.getEnclosedElements()) { if (subElement.getKind() == ElementKind.METHOD) { ExecutableElement method = (ExecutableElement) subElement; if (!method.getModifiers().contains(Modifier.PRIVATE) && method.getSimpleName().toString().equals(attribute.getSimpleName().toString()) && method.getParameters().size() == 1 && method.getParameters().get(0).asType().equals(attribute.asType())) { return true; } } } Element superClass = typeUtils.asElement(classElement.getSuperclass()); return (superClass instanceof TypeElement) && hasSuperMethod((TypeElement) superClass, attribute); }