@Override
public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
// System.out.println("supported options: "+
// Arrays.toString(getSupportedOptions().toArray()));
if (!roundEnv.processingOver()) {
for (TypeElement currAnno : annotations) {
// System.out.println("Found " + currAnno.getQualifiedName());
if (currAnno.getQualifiedName().contentEquals(GENERATE_POJO_BUILDER_CLASS.getName())) {
Set<? extends Element> annotatedElements = roundEnv.getElementsAnnotatedWith(currAnno);
// System.out.println("[GenerateBuilder] annotatedElements="+
// Arrays.toString(annotatedElements.toArray()));
for (Element elem : annotatedElements) {
if (elem.getKind() == ElementKind.CLASS) {
TypeElement typeElem = (TypeElement) elem;
GeneratePojoBuilder annotation = typeElem.getAnnotation(GENERATE_POJO_BUILDER_CLASS);
generatePojoBuilderProcessor.process(typeElem, annotation);
} else if (elem.getKind() == ElementKind.METHOD) {
ExecutableElement execElem = (ExecutableElement) elem;
GeneratePojoBuilder annotation = execElem.getAnnotation(GENERATE_POJO_BUILDER_CLASS);
generatePojoBuilderProcessor.process(execElem, annotation);
}
}
}
}
}
return false;
}
private void filterClass(
Collection<TypeElement> rootElements, Collection<? extends Element> elements) {
for (Element element : elements) {
if (element.getKind().equals(ElementKind.CLASS)
|| element.getKind().equals(ElementKind.INTERFACE)) {
rootElements.add((TypeElement) element);
filterClass(rootElements, ElementFilter.typesIn(element.getEnclosedElements()));
}
}
}
default Result checkSignature(Element elem) {
if (elem.getKind() != ElementKind.INTERFACE) {
String err =
"A signature template must be an interface, but an element annotated with "
+ "`@Signature` has TypeKind {0}.";
err = format(err, elem.getKind());
return error(err, AllSignatureChecks.class, elem);
}
return checkSignature((TypeElement) elem);
}
@Override
public VisitorConfig getConfig(TypeElement e, List<? extends Element> elements) {
boolean fields = false, methods = false;
for (Element element : elements) {
if (hasRelevantAnnotation(element)) {
fields |= element.getKind().equals(ElementKind.FIELD);
methods |= element.getKind().equals(ElementKind.METHOD);
}
}
return VisitorConfig.get(fields, methods);
}
@Override
public String shorten(TypeElement type) {
Element parent = type.getEnclosingElement();
if (parent.getKind() == ElementKind.PACKAGE) {
return getPrefixForTopLevelClass(parent.toString(), type.getSimpleName())
+ type.getSimpleName();
} else if (parent.getKind().isInterface() || parent.getKind().isClass()) {
return shorten((TypeElement) parent) + "." + type.getSimpleName();
} else {
return type.getQualifiedName().toString();
}
}
private boolean isNested(Element returnType, VariableElement field, TypeElement element) {
if (hasAnnotation(field, nestedConfigurationPropertyAnnotation())) {
return true;
}
return this.typeUtils.isEnclosedIn(returnType, element)
&& returnType.getKind() != ElementKind.ENUM;
}
/**
* Returns true if and only if a component can instantiate new instances (typically of a module)
* rather than requiring that they be passed.
*/
static boolean componentCanMakeNewInstances(TypeElement typeElement) {
switch (typeElement.getKind()) {
case CLASS:
break;
case ENUM:
case ANNOTATION_TYPE:
case INTERFACE:
return false;
default:
throw new AssertionError("TypeElement cannot have kind: " + typeElement.getKind());
}
if (typeElement.getModifiers().contains(ABSTRACT)) {
return false;
}
if (requiresEnclosingInstance(typeElement)) {
return false;
}
for (Element enclosed : typeElement.getEnclosedElements()) {
if (enclosed.getKind().equals(CONSTRUCTOR)
&& ((ExecutableElement) enclosed).getParameters().isEmpty()
&& !enclosed.getModifiers().contains(PRIVATE)) {
return true;
}
}
// TODO(gak): still need checks for visibility
return false;
}
private static List<? extends TypeMirror> computeReturn(
Set<ElementKind> types, CompilationInfo info, TreePath parent, Tree error, int offset) {
ReturnTree rt = (ReturnTree) parent.getLeaf();
if (rt.getExpression() == error) {
TreePath method = findMethod(parent);
if (method == null) {
return null;
}
Element el = info.getTrees().getElement(method);
if (el == null || el.getKind() != ElementKind.METHOD) {
return null;
}
types.add(ElementKind.PARAMETER);
types.add(ElementKind.LOCAL_VARIABLE);
types.add(ElementKind.FIELD);
return Collections.singletonList(((ExecutableElement) el).getReturnType());
}
return null;
}
private void handleEmbeddedType(Element element, Set<TypeElement> elements) {
TypeMirror type = element.asType();
if (element.getKind() == ElementKind.METHOD) {
type = ((ExecutableElement) element).getReturnType();
}
String typeName = type.toString();
if (typeName.startsWith(Collection.class.getName())
|| typeName.startsWith(List.class.getName())
|| typeName.startsWith(Set.class.getName())) {
type = ((DeclaredType) type).getTypeArguments().get(0);
} else if (typeName.startsWith(Map.class.getName())) {
type = ((DeclaredType) type).getTypeArguments().get(1);
}
TypeElement typeElement = typeExtractor.visit(type);
if (typeElement != null
&& !TypeUtils.hasAnnotationOfType(typeElement, conf.getEntityAnnotations())) {
if (!typeElement.getQualifiedName().toString().startsWith("java.")) {
elements.add(typeElement);
}
}
}
private void createConstructorAndBuilder() {
List<ExecutableElement> constructors = new ArrayList<ExecutableElement>();
for (Element e : annotatedElement.getEnclosedElements()) {
if (e.getKind() == CONSTRUCTOR) {
constructors.add((ExecutableElement) e);
}
}
for (ExecutableElement userConstructor : constructors) {
JMethod copyConstructor = generatedClass.constructor(PUBLIC);
JMethod staticHelper =
generatedClass.method(PUBLIC | STATIC, generatedClass._extends(), "build");
codeModelHelper.generifyStaticHelper(this, staticHelper, getAnnotatedElement());
JBlock body = copyConstructor.body();
JInvocation superCall = body.invoke("super");
JInvocation newInvocation = JExpr._new(generatedClass);
for (VariableElement param : userConstructor.getParameters()) {
String paramName = param.getSimpleName().toString();
JClass paramType = codeModelHelper.typeMirrorToJClass(param.asType(), this);
copyConstructor.param(paramType, paramName);
staticHelper.param(paramType, paramName);
superCall.arg(JExpr.ref(paramName));
newInvocation.arg(JExpr.ref(paramName));
}
JVar newCall = staticHelper.body().decl(generatedClass, "instance", newInvocation);
staticHelper.body().invoke(newCall, getOnFinishInflate());
staticHelper.body()._return(newCall);
body.invoke(getInit());
}
}
private ExecutableElement[] findGetterAndSetter(TypeElement cls, VariableElement variable) {
ExecutableElement[] gs = new ExecutableElement[] {null, null};
List<? extends Element> enclosedElements = cls.getEnclosedElements();
String capitalizedVarName = StringUtils.startUpperCase(variable.getSimpleName().toString());
String getterName = String.format("get%s", capitalizedVarName);
String setterName = String.format("set%s", capitalizedVarName);
for (int i = 0, c = enclosedElements.size(); i < c; i++) {
Element e = enclosedElements.get(i);
if (e.getKind() == ElementKind.METHOD) {
if (getterName.equals(e.getSimpleName().toString())) {
gs[0] = (ExecutableElement) e;
} else if (setterName.equals(e.getSimpleName().toString())) {
gs[1] = (ExecutableElement) e;
} else {
continue;
}
if (gs[0] != null && gs[1] != null) {
break;
}
}
}
return gs;
}
private <A extends Annotation> ActionModel processAction(
int genericPosition, Element element, Element outputElement, Class<A> annotationClass) {
A annotation = element.getAnnotation(annotationClass);
if (annotation != null) {
System.out.println("Element: " + element.getSimpleName());
if (elementTools.isMethod(element)) {
TypeMirror outputGeneric =
((DeclaredType) outputElement.asType()).getTypeArguments().get(genericPosition);
List<? extends VariableElement> parameters = ((ExecutableElement) element).getParameters();
if (parameters.size() == 1
&& processingEnv.getTypeUtils().isSameType(parameters.get(0).asType(), outputGeneric)) {
ActionModel actionModel = new ActionModel();
actionModel.setMethodName(elementTools.getFieldName(element));
actionModel.setType(element.asType());
if (element.getKind() == ElementKind.METHOD) {
actionModel.setType(((ExecutableElement) element).getParameters().get(0).asType());
}
System.out.println("It maches!!!" + actionModel);
return actionModel;
} else {
System.out.println("Does not match");
}
}
}
return null;
}
private boolean tryToUseSourceAsAWorkaround() {
if (element.getKind() != ElementKind.METHOD) {
// we don't bother with non-method attributes
// (like factory builder, where attributes are parameters)
return false;
}
CharSequence returnTypeString =
SourceExtraction.getReturnTypeString((ExecutableElement) element);
if (returnTypeString.length() == 0) {
// no source could be extracted for some reason, workaround will not work
return false;
}
Entry<String, List<String>> extractedTypes = SourceTypes.extract(returnTypeString);
// forces source imports based resolution,
// we should not rely that types would be fully qualified
Entry<String, List<String>> resolvedTypes = resolveTypes(extractedTypes);
this.rawTypeName = resolvedTypes.getKey();
this.workaroundTypeParameters = resolvedTypes.getValue();
this.workaroundTypeString = SourceTypes.stringify(resolvedTypes);
// workaround may have successed, need to continue with whatever we have
return true;
}
// Assumes targetKinds and E are sensible.
private static <E extends Element> List<E> listFilter(
Iterable<? extends Element> elements, Set<ElementKind> targetKinds, Class<E> clazz) {
List<E> list = new ArrayList<E>();
for (Element e : elements) {
if (targetKinds.contains(e.getKind())) list.add(clazz.cast(e));
}
return list;
}
private boolean hasMethod(String methodName) {
for (Element element : typeElement.getEnclosedElements()) {
if (element.getKind() == ElementKind.METHOD
&& methodName.equalsIgnoreCase(element.getSimpleName().toString())) {
return true;
}
}
return false;
}
// Assumes targetKinds and E are sensible.
private static <E extends Element> Set<E> setFilter(
Set<? extends Element> elements, Set<ElementKind> targetKinds, Class<E> clazz) {
// Return set preserving iteration order of input set.
Set<E> set = new LinkedHashSet<E>();
for (Element e : elements) {
if (targetKinds.contains(e.getKind())) set.add(clazz.cast(e));
}
return set;
}
private void createBeanInfo(TypeElement classElement) throws Exception {
if (verbose) {
processingEnv
.getMessager()
.printMessage(
Diagnostic.Kind.NOTE, "Generating BeanInfo for " + classElement.getSimpleName());
}
String className = classElement.getSimpleName().toString();
String qualifiedName = classElement.getQualifiedName().toString();
PackageElement packageElement = (PackageElement) classElement.getEnclosingElement();
String packageName = packageElement.getQualifiedName().toString();
Map<String, VariableElement> fields = new HashMap<String, VariableElement>();
Writer writer = null;
try {
// Build Bean Info
TypeElement curClassElement = classElement;
do {
for (Element e : curClassElement.getEnclosedElements()) {
if (e.getKind().equals(ElementKind.FIELD)
&& !e.getModifiers().contains(Modifier.TRANSIENT)
&& !e.getModifiers().contains(Modifier.STATIC)) {
fields.put(e.getSimpleName().toString(), (VariableElement) e);
}
}
TypeMirror t = curClassElement.getSuperclass();
if (t instanceof DeclaredType) {
curClassElement = (TypeElement) ((DeclaredType) t).asElement();
} else {
curClassElement = null;
}
} while (curClassElement != null);
VelocityContext vc = new VelocityContext();
vc.put("className", className);
vc.put("packageName", packageName);
vc.put("fields", fields);
// Create source file
JavaFileObject jfo = processingEnv.getFiler().createSourceFile(qualifiedName + "BeanInfo");
if (verbose) {
processingEnv
.getMessager()
.printMessage(Diagnostic.Kind.NOTE, "creating source file: " + jfo.toUri());
}
writer = jfo.openWriter();
template.merge(vc, writer);
} finally {
closeQuietly(writer);
}
}
private boolean doesClassContainNoArgsConstructor(Element el) {
for (Element subelement : el.getEnclosedElements()) {
if (subelement.getKind() == ElementKind.CONSTRUCTOR
&& subelement.getModifiers().contains(Modifier.PUBLIC)) {
TypeMirror mirror = subelement.asType();
if (mirror.accept(noArgsVisitor, null)) return true;
}
}
return false;
}
public void printElement(TypeElement typeElement) {
List<? extends AnnotationMirror> annotationMirrors = typeElement.getAnnotationMirrors();
generator.log("class: " + typeElement + ", annotations: " + annotationMirrors);
for (Element ele : typeElement.getEnclosedElements()) {
if (ele.getKind().equals(ElementKind.METHOD)) {
ExecutableElement method = (ExecutableElement) ele;
printMethod(method);
}
}
}
/**
* {@inheritDoc}
*
* <p>In most cases, subclasses want to call this method first because it may clear all
* annotations and use the hierarchy's root annotations.
*/
@Override
public void postAsMemberOf(AnnotatedTypeMirror type, AnnotatedTypeMirror owner, Element element) {
super.postAsMemberOf(type, owner, element);
if (element.getKind().isField()) {
Collection<? extends AnnotationMirror> declaredFieldAnnotations = getDeclAnnotations(element);
AnnotatedTypeMirror fieldAnnotations = getAnnotatedType(element);
computeFieldAccessType(type, declaredFieldAnnotations, owner, fieldAnnotations, element);
}
}
private List<Element> getFixedFieldAnnotateMethod(Element clazz) {
List<Element> listGetter = new ArrayList<Element>();
for (Element element : clazz.getEnclosedElements()) {
if (element.getKind().equals(ElementKind.METHOD)
&& element.getSimpleName().toString().startsWith("get")) {
listGetter.add(element);
}
}
return listGetter;
}
@Override
public Void visitExecutable(AnnotatedExecutableType t, Void p) {
Void result = super.visitExecutable(t, p);
Element elem = t.getElement();
if (elem.getKind() == ElementKind.CONSTRUCTOR) {
AnnotatedDeclaredType returnType = (AnnotatedDeclaredType) t.getReturnType();
DeclaredType underlyingType = returnType.getUnderlyingType();
returnType.replaceAnnotation(getFreeOrRawAnnotationOfSuperType(underlyingType));
}
return result;
}
public void parse(TypeElement layoutElement) {
if (!layoutElement.getInterfaces().isEmpty()) {
parseSuperLayout(
(TypeElement) ((DeclaredType) layoutElement.getInterfaces().get(0)).asElement());
}
parseName(layoutElement);
objectTypeSuperclass = layoutElement.getAnnotation(Layout.class).objectTypeSuperclass();
for (Element element : layoutElement.getEnclosedElements()) {
if (element.getKind() == ElementKind.FIELD) {
final String simpleName = element.getSimpleName().toString();
if (simpleName.endsWith("_IDENTIFIER")) {
parseIdentifier((VariableElement) element);
} else {
throw new AssertionError("Unknown field in layout interface");
}
} else if (element.getKind() == ElementKind.METHOD) {
final String simpleName = element.getSimpleName().toString();
if (simpleName.equals("create" + name + "Shape")) {
parseShapeConstructor((ExecutableElement) element);
} else if (simpleName.equals("create" + name)) {
parseConstructor((ExecutableElement) element);
} else if (simpleName.equals("is" + name)) {
parseGuard((ExecutableElement) element);
} else if (simpleName.startsWith("get")) {
parseGetter((ExecutableElement) element);
} else if (simpleName.startsWith("set")) {
parseSetter((ExecutableElement) element);
} else {
throw new AssertionError("Unknown method in layout interface " + interfaceFullName);
}
}
}
assert constructorProperties.size() == properties.size();
assert constructorProperties.containsAll(properties.keySet());
}
static boolean checkAbstractValueType(Element element, Collection<String> violations) {
boolean ofSupportedKind =
false
|| element.getKind() == ElementKind.INTERFACE
|| element.getKind() == ElementKind.ANNOTATION_TYPE
|| element.getKind() == ElementKind.CLASS;
boolean staticOrTopLevel =
false
|| element.getEnclosingElement().getKind() == ElementKind.PACKAGE
|| element.getModifiers().contains(Modifier.STATIC);
boolean nonFinal = !element.getModifiers().contains(Modifier.FINAL);
boolean hasNoTypeParameters = ((TypeElement) element).getTypeParameters().isEmpty();
boolean publicOrPackageVisible =
!element.getModifiers().contains(Modifier.PRIVATE)
&& !element.getModifiers().contains(Modifier.PROTECTED);
if (!ofSupportedKind) {
violations.add("must be class or interface or annotation type");
}
if (!nonFinal) {
violations.add("must be non-final");
}
if (!hasNoTypeParameters) {
violations.add("should have no type parameters");
}
if (!publicOrPackageVisible) {
violations.add("should be public or package-visible");
}
if (!staticOrTopLevel) {
violations.add("should be top-level or static inner class");
}
return violations.isEmpty();
}
private void collectFields() {
for (Element element : typeElement.getEnclosedElements()) {
if (element.getKind() == ElementKind.FIELD) {
String fieldName = element.getSimpleName().toString();
boolean isPublic = isPublicField(element);
boolean hasGet = hasGetMethod(fieldName);
boolean hasSet = hasSetMethod(fieldName);
fields.put(fieldName, new Field(fieldName, hasGet, hasSet, isPublic));
}
}
}
@Override
public Result checkCapsule(TypeElement template) {
for (Element element : template.getEnclosedElements()) {
if (element.getKind() == ElementKind.FIELD) {
if (hasLocalSignatureField(element)) {
String err = "Cannot have a `@Local` field whose type is a signature.";
return error(err, CheckForLocalSignatureFields.class, element);
}
}
}
return OK;
}
// TODO(sgoldfed): better format for other types of elements?
static String elementToString(Element element) {
switch (element.getKind()) {
case FIELD:
// fall through
case CONSTRUCTOR:
// fall through
case METHOD:
return element.getEnclosingElement() + "." + element;
default:
return element.toString();
}
}
/** Returns the no-args constructor for {@code type}, or null if no such constructor exists. */
public static ExecutableElement getNoArgsConstructor(TypeElement type) {
for (Element enclosed : type.getEnclosedElements()) {
if (enclosed.getKind() != ElementKind.CONSTRUCTOR) {
continue;
}
ExecutableElement constructor = (ExecutableElement) enclosed;
if (constructor.getParameters().isEmpty()) {
return constructor;
}
}
return null;
}
@Override
public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
if (roundEnv.processingOver()) {
return true;
}
for (Element element : roundEnv.getElementsAnnotatedWith(ServiceProvider.class)) {
assert element.getKind().isClass();
processElement((TypeElement) element);
}
return true;
}
private boolean hasParcelableConstructor(TypeElement typeElement) {
for (Element e : typeElement.getEnclosedElements()) {
if (e.getKind() == ElementKind.CONSTRUCTOR && hasSomeModifier(e, Modifier.PUBLIC)) {
ExecutableElement c = (ExecutableElement) e;
List<? extends VariableElement> params = c.getParameters();
if (params.size() == 1
&& ClassName.get(params.get(0).asType()).equals(ClassName.get(Parcel.class))) {
return true;
}
}
}
return false;
}
