@Override @SuppressWarnings("ConstantConditions") protected void doVisitField( @Nullable VariableElement oldField, @Nullable VariableElement newField) { if (!shouldCheck(oldField, newField)) { return; } Predicate<VariableElement> isNotEnumConstant = v -> v.getKind() != ElementKind.ENUM_CONSTANT; List<? extends VariableElement> fields = ElementFilter.fieldsIn(oldField.getEnclosingElement().getEnclosedElements()); fields.removeIf(isNotEnumConstant); int oldIdx = fields.indexOf(oldField); fields = ElementFilter.fieldsIn(newField.getEnclosingElement().getEnclosedElements()); fields.removeIf(isNotEnumConstant); int newIdx = fields.indexOf(newField); if (newIdx != oldIdx) { pushActive(oldField, newField, oldIdx, newIdx); } }
@Override protected boolean shouldCheck(VariableElement oldField, VariableElement newField) { return isEnumClass && super.shouldCheck(oldField, newField) && oldField.getKind() == ElementKind.ENUM_CONSTANT && newField.getKind() == ElementKind.ENUM_CONSTANT; }
private void addActionToIntentBuilder( EIntentServiceHolder holder, ExecutableElement executableElement, String methodName, JFieldVar actionKeyField) { JMethod method = holder.getIntentBuilderClass().method(PUBLIC, holder.getIntentBuilderClass(), methodName); JBlock body = method.body(); // setAction body.invoke("action").arg(actionKeyField); // For each method params, we get put value into extras List<? extends VariableElement> methodParameters = executableElement.getParameters(); if (methodParameters.size() > 0) { // Extras params for (VariableElement param : methodParameters) { String paramName = param.getSimpleName().toString(); JClass parameterClass = codeModelHelper.typeMirrorToJClass(param.asType(), holder); JFieldVar paramVar = getStaticExtraField(holder, paramName); JVar methodParam = method.param(parameterClass, paramName); JMethod putExtraMethod = holder.getIntentBuilder().getPutExtraMethod(param.asType(), paramName, paramVar); body.invoke(putExtraMethod).arg(methodParam); } } body._return(JExpr._this()); }
public void generateFieldDeclaration(VariableElement fieldElement) { println( " {0}{1} {2};", generateModifierList(fieldElement.getModifiers().toArray(new Modifier[] {})), fieldElement.asType().toString(), fieldElement.getSimpleName()); }
public MapKeyNamingType getMapKeyNamingValue() { VariableElement enumConstant = AnnotationValueUtil.toEnumConstant(mapKeyNaming); if (enumConstant == null) { throw new AptIllegalStateException("mapKeyNaming"); } return MapKeyNamingType.valueOf(enumConstant.getSimpleName().toString()); }
public void generateFieldDeclaration(VariableElement fieldElement, Modifier... modifiers) { println( " {0}{1} {2};", generateModifierList(modifiers), fieldElement.asType().toString(), fieldElement.getSimpleName()); }
@Override public Void visitEnumConstant(VariableElement c, JAnnotationArrayMember p) { JClass annotationClass = helper.typeMirrorToJClass(c.asType(), holder); JExpression expression = JExpr.direct(annotationClass.fullName() + "." + c.getSimpleName()); p.param(expression); return null; }
@Override public void writeFieldReadStatement( VariableElement field, Collection<ExecutableElement> postCreateChildMethods, JavaWriter writer) throws IOException { DeclaredType type = (DeclaredType) field.asType(); TypeMirror itemType = type.getTypeArguments().get(0); TypeMirror itemTypeErasure = processingEnv.getTypeUtils().erasure(itemType); String collectionInitializer; try { collectionInitializer = initializers.findCollectionInitializer(type); } catch (InvalidTypeException e) { processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR, e.getMessage(), field); collectionInitializer = "null"; } writer.beginControlFlow("if (bundle.containsKey(\"%s\"))", field.getSimpleName()); writer.emitStatement("object.%s = %s", field.getSimpleName(), collectionInitializer); writer.emitStatement( "%1$s.readCollectionFromBundle(object.%2$s, bundle, %3$s.class, \"%2$s\")", CollectionBundler.class.getCanonicalName(), field.getSimpleName(), itemTypeErasure); writePostCreateChildMethodCalls(field, itemType, postCreateChildMethods, writer); writer.endControlFlow(); }
private void processFromProperties(TypeElement type, Set<TypeElement> types) { List<? extends Element> children = type.getEnclosedElements(); VisitorConfig config = conf.getConfig(type, children); // fields if (config.visitFieldProperties()) { for (VariableElement field : ElementFilter.fieldsIn(children)) { TypeElement typeElement = typeExtractor.visit(field.asType()); if (typeElement != null) { types.add(typeElement); } } } // getters if (config.visitMethodProperties()) { for (ExecutableElement method : ElementFilter.methodsIn(children)) { String name = method.getSimpleName().toString(); if ((name.startsWith("get") || name.startsWith("is")) && method.getParameters().isEmpty()) { TypeElement typeElement = typeExtractor.visit(method.getReturnType()); if (typeElement != null) { types.add(typeElement); } } } } }
public int compareTo(final MethodHandler that) { if (this == that) { return 0; } int res = methName.compareTo(that.methName); if (res != 0) { return res; } if (pars.size() < that.pars.size()) { return -1; } if (pars.size() > that.pars.size()) { return 1; } Iterator<VariableElement> it = that.pars.iterator(); for (VariableElement pd : pars) { VariableElement thatPd = it.next(); if (!pd.equals(thatPd)) { return 1; } } return 0; }
private void haveAfterTextChangedMethodParameters( ExecutableElement executableElement, IsValid valid) { List<? extends VariableElement> parameters = executableElement.getParameters(); boolean editableParameterFound = false; boolean textViewParameterFound = false; for (VariableElement parameter : parameters) { String parameterType = parameter.asType().toString(); if (parameterType.equals("android.text.Editable")) { if (editableParameterFound) { annotationHelper.printAnnotationError( executableElement, "Unrecognized parameter declaration. you can declare only one parameter of type android.text.Editable"); valid.invalidate(); } editableParameterFound = true; continue; } if (parameterType.equals("android.widget.TextView")) { if (textViewParameterFound) { annotationHelper.printAnnotationError( executableElement, "Unrecognized parameter declaration. you can declare only one parameter of type android.widget.TextView"); valid.invalidate(); } textViewParameterFound = true; continue; } valid.invalidate(); annotationHelper.printAnnotationError( executableElement, "Unrecognized parameter type. %s can only have a android.widget.TextView parameter and/or an android.text.Editable parameter. See android.text.TextWatcher.afterTextChanged() for more informations."); } }
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()); } }
@Override public boolean processVariableElement(VariableElement field, DeclaredTypeName fieldType) { boolean isViewProperty = TypeConstants.isBasicPropertyType(fieldType); ViewQuery isViewQuery = field.getAnnotation(ViewQuery.class); Set<Modifier> modifiers = field.getModifiers(); if (modifiers.containsAll(TypeConstants.PUBLIC_STATIC_FINAL)) { if (isViewQuery != null) { if (!TypeConstants.QUERY.equals(fieldType)) { utils .getMessager() .printMessage( Diagnostic.Kind.ERROR, "ViewQuery must be an instance of " + TypeConstants.QUERY.toString()); } else if (modelSpec.hasMetadata(ViewModelSpecWrapper.METADATA_KEY_QUERY_ELEMENT)) { utils .getMessager() .printMessage(Diagnostic.Kind.ERROR, "Only one ViewQuery can be declared per spec"); } else { modelSpec.putMetadata(ViewModelSpecWrapper.METADATA_KEY_VIEW_QUERY, isViewQuery); modelSpec.putMetadata(ViewModelSpecWrapper.METADATA_KEY_QUERY_ELEMENT, field); } return true; } else { return super.processVariableElement(field, fieldType); } } else if (isViewProperty) { utils .getMessager() .printMessage( Diagnostic.Kind.ERROR, "View properties must be public static final", field); } return false; }
@Override public void process(Element element, EBeanHolder holder) { final ExecutableElement afterPutMethod = (ExecutableElement) element; final UseModelHolder useModelHolder = holder.getPluginHolder(new UseModelHolder(holder)); useModelHolder.setAfterPutMethod(afterPutMethod); List<Class<? extends Annotation>> annotations = Arrays.asList(UseModel.class, LocalDBModel.class, ServerModel.class); for (Class<? extends Annotation> annotation : annotations) { if (element.getAnnotation(annotation) != null) return; } List<? extends VariableElement> parameters = afterPutMethod.getParameters(); JInvocation invocation = useModelHolder .getPutModelInitBlock() ._if(ref("result").ne(_null())) ._then() .invoke(afterPutMethod.getSimpleName().toString()); for (VariableElement param : parameters) { final String paramName = param.getSimpleName().toString(); ParamUtils.injectParam(paramName, invocation); } }
@Override public void printErrorCheckMethod( final PrintWriter writer, final ExecutableElement method, final String tabs) { final Check check = method.getAnnotation(Check.class); if (check != null) // Get the error code from an IntBuffer output parameter writer.println( tabs + "Util.checkCLError(" + check.value() + ".get(" + check.value() + ".position()));"); else { final Class return_type = Utils.getJavaType(method.getReturnType()); if (return_type == int.class) writer.println(tabs + "Util.checkCLError(__result);"); else { boolean hasErrCodeParam = false; for (final VariableElement param : method.getParameters()) { if ("errcode_ret".equals(param.getSimpleName().toString()) && Utils.getJavaType(param.asType()) == IntBuffer.class) { hasErrCodeParam = true; break; } } if (hasErrCodeParam) throw new RuntimeException( "A method is missing the @Check annotation: " + method.toString()); } } }
@Override public String apply(VariableElement input) { if (isVarArg(input.asType())) { return ((ArrayType) input.asType()).getComponentType() + "..."; } return input.asType().toString(); }
public boolean containsField(String name) { for (VariableElement field : getFields()) { if (field.getSimpleName().toString().equals(name)) { return true; } } return false; }
@Override public Void visitVariable(VariableElement e, Void p) { if (e.getAnnotation(Signaller.class) != null) { TypeElement typeElement = elementUtils.getTypeElement(e.asType().toString()); if (typeElement != null) { handleTypeElement(typeElement); } } return super.visitVariable(e, p); }
private void scanForMultipart( ExecutableElement executableElement, RestDocumentation.Resource.Method doc) { for (VariableElement var : executableElement.getParameters()) { TypeMirror varType = var.asType(); if (varType.toString().startsWith(MultipartHttpServletRequest.class.getName())) { doc.setMultipartRequest(true); return; } } }
private void processNestedLombokTypes( String prefix, TypeElement element, ExecutableElement source, TypeElementMembers members) { for (Map.Entry<String, VariableElement> entry : members.getFields().entrySet()) { String name = entry.getKey(); VariableElement field = entry.getValue(); if (isLombokField(field, element)) { processNestedType(prefix, element, source, name, null, field, field.asType()); } } }
// 4942232: // check that classes exist for all the parameters of native methods private void checkMethodParameters(Set<TypeElement> classes) { Types types = processingEnv.getTypeUtils(); for (TypeElement te : classes) { for (ExecutableElement ee : ElementFilter.methodsIn(te.getEnclosedElements())) { for (VariableElement ve : ee.getParameters()) { TypeMirror tm = ve.asType(); checkMethodParametersVisitor.visit(tm, types); } } } }
private void buildPathVariables( ExecutableElement executableElement, RestDocumentation.Resource.Method doc) { RestDocumentation.Resource.Method.UrlFields subs = doc.getUrlSubstitutions(); for (VariableElement var : executableElement.getParameters()) { PathVariable pathVar = var.getAnnotation(PathVariable.class); if (pathVar != null) { addUrlField(subs, var, pathVar.value()); } } }
private void buildUrlParameters( ExecutableElement executableElement, RestDocumentation.Resource.Method doc) { RestDocumentation.Resource.Method.UrlFields subs = doc.getUrlParameters(); for (VariableElement var : executableElement.getParameters()) { RequestParam reqParam = var.getAnnotation(RequestParam.class); if (reqParam != null) { addUrlField(subs, var, reqParam.value()); } } }
private void printMethod(ExecutableElement executableElement) { StringBuilder s = new StringBuilder(256); s.append("method: " + executableElement).append("\n\t"); s.append("annotations: " + executableElement.getAnnotationMirrors()).append("\n\t"); s.append("return: " + executableElement.getReturnType()).append("\n\t"); for (VariableElement var : executableElement.getParameters()) { s.append("parameter: " + var + ", " + var.getAnnotation(ApiParameterDoc.class)) .append("\n\t"); } generator.log(s.toString()); }
static Parameter forVariableElement(VariableElement variable) { ImmutableSet.Builder<String> qualifiers = ImmutableSet.builder(); for (AnnotationMirror annotationMirror : variable.getAnnotationMirrors()) { DeclaredType annotationType = annotationMirror.getAnnotationType(); if (annotationType.asElement().getAnnotation(Qualifier.class) != null) { qualifiers.add(Mirrors.getQualifiedName(annotationType).toString()); } } return new Parameter( FluentIterable.from(qualifiers.build()).first(), variable.asType().toString(), variable.getSimpleName().toString()); }
private boolean validateParametersTypes(ExecutableElement constructor) { boolean res = true; List<? extends VariableElement> parameters = constructor.getParameters(); Iterator<TypeElement> sources = context.sources().iterator(); for (VariableElement parameter : parameters) { TypeElement sourceType = sources.next(); if (!parameter.asType().equals(sourceType.asType())) { res = false; break; } } return res; }
private static void printBufferObjectChecks( PrintWriter writer, ExecutableElement method, Mode mode, boolean context_specific) { EnumSet<BufferKind> check_set = EnumSet.noneOf(BufferKind.class); for (VariableElement param : method.getParameters()) { BufferObject bo_annotation = param.getAnnotation(BufferObject.class); if (bo_annotation != null) { check_set.add(bo_annotation.value()); } } for (BufferKind kind : check_set) { printBufferObjectCheck(writer, kind, mode, context_specific); } }
@Override public void writeFieldWriteStatement(VariableElement field, JavaWriter writer) throws IOException { DeclaredType type = (DeclaredType) field.asType(); TypeMirror itemType = type.getTypeArguments().get(0); TypeMirror itemTypeErasure = processingEnv.getTypeUtils().erasure(itemType); writer.beginControlFlow("if (object.%s != null)", field.getSimpleName()); writer.emitStatement( "%1$s.writeCollectionToBundle(object.%2$s, bundle, %3$s.class, \"%2$s\")", CollectionBundler.class.getCanonicalName(), field.getSimpleName(), itemTypeErasure); writer.endControlFlow(); }
protected String manufactureAccessorName(VariableElement fieldElement) { String name; if (fieldElement .asType() .toString() .equals(java.lang.Boolean.class.getSimpleName().toLowerCase())) { name = "is"; } else { name = "get"; } name += firstCharToUpperCase(fieldElement.getSimpleName().toString()); return name; }
private void addActionInOnHandleIntent( EIntentServiceHolder holder, ExecutableElement executableElement, String methodName, JFieldVar actionKeyField) { // If action match, call the method JInvocation actionCondition = actionKeyField.invoke("equals").arg(holder.getOnHandleIntentIntentAction()); JBlock callActionBlock = holder.getOnHandleIntentBody()._if(actionCondition)._then(); JInvocation callActionInvocation = JExpr._super().invoke(methodName); // For each method params, we get back value from extras and put it // in super calls List<? extends VariableElement> methodParameters = executableElement.getParameters(); if (methodParameters.size() > 0) { // Extras JVar extras = callActionBlock.decl(classes().BUNDLE, "extras"); extras.init(holder.getOnHandleIntentIntent().invoke("getExtras")); JBlock extrasNotNullBlock = callActionBlock._if(extras.ne(_null()))._then(); // Extras params for (VariableElement param : methodParameters) { String paramName = param.getSimpleName().toString(); String extraParamName = paramName + "Extra"; JFieldVar paramVar = getStaticExtraField(holder, paramName); JClass extraParamClass = codeModelHelper.typeMirrorToJClass(param.asType(), holder); BundleHelper bundleHelper = new BundleHelper(annotationHelper, param); JExpression getExtraExpression = JExpr.invoke(extras, bundleHelper.getMethodNameToRestore()).arg(paramVar); if (bundleHelper.restoreCallNeedCastStatement()) { getExtraExpression = JExpr.cast(extraParamClass, getExtraExpression); if (bundleHelper.restoreCallNeedsSuppressWarning()) { JMethod onHandleIntentMethod = holder.getOnHandleIntentMethod(); if (onHandleIntentMethod.annotations().size() == 0) { onHandleIntentMethod.annotate(SuppressWarnings.class).param("value", "unchecked"); } } } JVar extraField = extrasNotNullBlock.decl(extraParamClass, extraParamName, getExtraExpression); callActionInvocation.arg(extraField); } extrasNotNullBlock.add(callActionInvocation); } else { callActionBlock.add(callActionInvocation); } callActionBlock._return(); }