/** INTERNAL: Visit an executable and create a MetadataMethod object. */
  @Override
  public MetadataMethod visitExecutable(
      ExecutableElement executableElement, MetadataClass metadataClass) {
    MetadataMethod method = new MetadataMethod(metadataClass.getMetadataFactory(), metadataClass);

    // Set the name.
    method.setName(executableElement.getSimpleName().toString());

    // Set the attribute name.
    method.setAttributeName(Helper.getAttributeNameFromMethodName(method.getName()));

    // Set the modifiers.
    method.setModifiers(getModifiers(executableElement.getModifiers()));

    // Visit executable element for the parameters, return type and generic type.
    executableElement.asType().accept(typeVisitor, method);

    // Set the annotations.
    buildMetadataAnnotations(method, executableElement.getAnnotationMirrors());

    // Handle multiple methods with the same name.
    MetadataMethod existing = metadataClass.getMethods().get(method.getName());
    if (existing == null) {
      metadataClass.addMethod(method);
    } else {
      while (existing.getNext() != null) {
        existing = existing.getNext();
      }
      existing.setNext(method);
    }

    return method;
  }
 private void processExecutableElement(String prefix, ExecutableElement element) {
   if (element.getModifiers().contains(Modifier.PUBLIC)
       && (TypeKind.VOID != element.getReturnType().getKind())) {
     Element returns = this.processingEnv.getTypeUtils().asElement(element.getReturnType());
     if (returns instanceof TypeElement) {
       ItemMetadata group =
           ItemMetadata.newGroup(
               prefix,
               this.typeUtils.getType(returns),
               this.typeUtils.getType(element.getEnclosingElement()),
               element.toString());
       if (this.metadataCollector.hasSimilarGroup(group)) {
         this.processingEnv
             .getMessager()
             .printMessage(
                 Kind.ERROR,
                 "Duplicate `@ConfigurationProperties` definition for prefix '" + prefix + "'",
                 element);
       } else {
         this.metadataCollector.add(group);
         processTypeElement(prefix, (TypeElement) returns, element);
       }
     }
   }
 }
示例#3
0
  private void parseMethod(Api api, ExecutableElement executableElement) throws IOException {

    Element actionElement =
        generator
            .getProcessingEnvironment()
            .getElementUtils()
            .getTypeElement(ApiMethodDoc.class.getName());
    TypeMirror apiMethodDocType = actionElement.asType();

    for (AnnotationMirror am : executableElement.getAnnotationMirrors()) {
      if (am.getAnnotationType().equals(apiMethodDocType)) {
        api.apiMethodDoc = Maps.newHashMap();
        for (Map.Entry<? extends ExecutableElement, ? extends AnnotationValue> ee :
            am.getElementValues().entrySet()) {
          api.apiMethodDoc.put(ee.getKey().getSimpleName().toString(), ee.getValue());
        }
        break;
      }
    }

    // generator.log("apiMethodDoc: " + api.apiMethodDoc);

    if (null == api.apiMethodDoc) {
      generator.log("Method miss @ApiMethodDoc. " + executableElement);
      return;
    }

    api.methodName = executableElement.getSimpleName().toString();
    api.methodMapping = executableElement.getAnnotation(RequestMapping.class);
    api.parameters = Lists.newArrayList();

    for (VariableElement var : executableElement.getParameters()) {
      api.parameters.add(var);
    }
  }
 private void processSimpleTypes(
     String prefix,
     TypeElement element,
     ExecutableElement source,
     TypeElementMembers members,
     Map<String, Object> fieldValues) {
   for (Map.Entry<String, ExecutableElement> entry : members.getPublicGetters().entrySet()) {
     String name = entry.getKey();
     ExecutableElement getter = entry.getValue();
     TypeMirror returnType = getter.getReturnType();
     ExecutableElement setter = members.getPublicSetter(name, returnType);
     VariableElement field = members.getFields().get(name);
     Element returnTypeElement = this.processingEnv.getTypeUtils().asElement(returnType);
     boolean isExcluded = this.typeExcludeFilter.isExcluded(returnType);
     boolean isNested = isNested(returnTypeElement, field, element);
     boolean isCollection = this.typeUtils.isCollectionOrMap(returnType);
     if (!isExcluded && !isNested && (setter != null || isCollection)) {
       String dataType = this.typeUtils.getType(returnType);
       String sourceType = this.typeUtils.getType(element);
       String description = this.typeUtils.getJavaDoc(field);
       Object defaultValue = fieldValues.get(name);
       boolean deprecated = isDeprecated(getter) || isDeprecated(setter) || isDeprecated(source);
       this.metadataCollector.add(
           ItemMetadata.newProperty(
               prefix,
               name,
               dataType,
               sourceType,
               null,
               description,
               defaultValue,
               (deprecated ? getItemDeprecation(getter) : null)));
     }
   }
 }
  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 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;
 }
  String getConverterClassName(Element el) {

    AnnotationValue converter = null;

    for (AnnotationMirror am : el.getAnnotationMirrors()) {
      Map<? extends ExecutableElement, ? extends AnnotationValue> elementValues =
          am.getElementValues();
      for (ExecutableElement e : elementValues.keySet()) {
        if ("converter".equals(e.getSimpleName().toString())) {
          converter = elementValues.get(e);
        }
      }
    }

    String result = null;
    if (converter != null && !TokenConverter.class.getCanonicalName().equals(converter)) {
      String tmp = converter.toString();
      if (tmp.endsWith(".class")) {
        int i = tmp.lastIndexOf('.');
        result = tmp.substring(0, i);
      } else {
        result = tmp;
      }
    }

    return result;
  }
 /**
  * Returns true if {@code annotation} has a single element named "value", letting us drop the
  * 'value=' prefix in the source code.
  */
 private static boolean hasSingleValueWithDefaultKey(AnnotationMirror annotation) {
   if (annotation.getElementValues().size() != 1) {
     return false;
   }
   ExecutableElement key = getOnlyElement(annotation.getElementValues().keySet());
   return key.getSimpleName().contentEquals("value");
 }
 /**
  * Tests whether a method invocation is an invocation of {@link Comparable#compareTo}.
  *
  * <p>
  *
  * @param node a method invocation node
  * @return true iff {@code node} is a invocation of {@code compareTo()}
  */
 private boolean isInvocationOfCompareTo(MethodInvocationTree node) {
   ExecutableElement method = TreeUtils.elementFromUse(node);
   return (method.getParameters().size() == 1
       && method.getReturnType().getKind() == TypeKind.INT
       // method symbols only have simple names
       && method.getSimpleName().contentEquals("compareTo"));
 }
示例#10
0
  @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);
    }
  }
  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);
          }
        }
      }
    }
  }
示例#12
0
 @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());
     }
   }
 }
示例#13
0
 /**
  * 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);
 }
示例#14
0
 private boolean checkForDependencies(List<ExecutableElement> providerMethods) {
   for (ExecutableElement element : providerMethods) {
     if (!element.getParameters().isEmpty()) {
       return true;
     }
   }
   return false;
 }
 private void hasConstructor(TypeElement type) {
   for (ExecutableElement cons : ElementFilter.constructorsIn(type.getEnclosedElements())) {
     if (cons.getParameters().isEmpty()) {
       return;
     }
   }
   error("missing default (no-args) constructor", type);
 }
示例#16
0
 private boolean checkForMultibindings(List<ExecutableElement> providerMethods) {
   for (ExecutableElement element : providerMethods) {
     if (element.getAnnotation(Provides.class).type() == Provides.Type.SET) {
       return true;
     }
   }
   return false;
 }
示例#17
0
  public static boolean isSimpleMethod(final Element element) {
    if (element instanceof ExecutableElement) {
      final ExecutableElement ee = (ExecutableElement) element;
      final List<? extends VariableElement> parameters = ee.getParameters();

      return !hasAnyModifier(ee, Modifier.STATIC) && parameters.isEmpty();
    }
    return false;
  }
示例#18
0
 private static Set<TypeElement> nestedAnnotationElements(
     TypeElement annotationElement, Set<TypeElement> annotationElements) {
   if (annotationElements.add(annotationElement)) {
     for (ExecutableElement method : methodsIn(annotationElement.getEnclosedElements())) {
       TRAVERSE_NESTED_ANNOTATIONS.visit(method.getReturnType(), annotationElements);
     }
   }
   return annotationElements;
 }
示例#19
0
 private static String getResultType(ExecutableElement method, boolean native_stub) {
   if (native_stub && method.getAnnotation(PointerWrapper.class) != null) {
     return "long";
   } else if (!native_stub && method.getAnnotation(GLreturn.class) != null) {
     return Utils.getMethodReturnType(method, method.getAnnotation(GLreturn.class), false);
   } else {
     return Utils.getJavaType(Utils.getMethodReturnType(method)).getSimpleName();
   }
 }
 private void processNestedTypes(
     String prefix, TypeElement element, ExecutableElement source, TypeElementMembers members) {
   for (Map.Entry<String, ExecutableElement> entry : members.getPublicGetters().entrySet()) {
     String name = entry.getKey();
     ExecutableElement getter = entry.getValue();
     VariableElement field = members.getFields().get(name);
     processNestedType(prefix, element, source, name, getter, field, getter.getReturnType());
   }
 }
示例#21
0
 /**
  * @param executable the executable to check
  * @return {@code true}, iff the executable does not represent {@link
  *     java.lang.Object#equals(Object)} or an overridden version of it
  */
 private static boolean isNotObjectEquals(ExecutableElement executable) {
   if (executable.getSimpleName().contentEquals("equals")
       && executable.getParameters().size() == 1
       && asTypeElement(executable.getParameters().get(0).asType())
           .getQualifiedName()
           .contentEquals("java.lang.Object")) {
     return false;
   }
   return true;
 }
示例#22
0
 // 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 AutoValueExtension.Context createContext(TypeElement type) {
    String packageName = MoreElements.getPackage(type).getQualifiedName().toString();
    Set<ExecutableElement> allMethods = MoreElements.getLocalAndInheritedMethods(type, elements);
    Set<ExecutableElement> methods = methodsToImplement(type, allMethods);
    Map<String, ExecutableElement> properties = new LinkedHashMap<String, ExecutableElement>();
    for (ExecutableElement e : methods) {
      properties.put(e.getSimpleName().toString(), e);
    }

    return new TestContext(processingEnvironment, packageName, type, properties);
  }
 private void setConstructor() {
   constructor = generatedClass.constructor(PRIVATE);
   JVar constructorContextParam = constructor.param(getClasses().CONTEXT, "context");
   JBlock constructorBody = constructor.body();
   List<ExecutableElement> constructors =
       ElementFilter.constructorsIn(annotatedElement.getEnclosedElements());
   ExecutableElement superConstructor = constructors.get(0);
   if (superConstructor.getParameters().size() == 1) {
     constructorBody.invoke("super").arg(constructorContextParam);
   }
   constructorBody.assign(getContextField(), constructorContextParam);
 }
示例#25
0
  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());
  }
示例#26
0
 /** 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;
 }
示例#27
0
 /**
  * Build the comments for the method. Do nothing if {@link Configuration#nocomment} is set to
  * true.
  *
  * @param node the XML element that specifies which components to document
  * @param methodDocTree the content tree to which the documentation will be added
  */
 public void buildMethodComments(XMLNode node, Content methodDocTree) {
   if (!configuration.nocomment) {
     ExecutableElement method = currentMethod;
     if (utils.getBody(currentMethod).isEmpty()) {
       DocFinder.Output docs =
           DocFinder.search(configuration, new DocFinder.Input(utils, currentMethod));
       if (docs.inlineTags != null && !docs.inlineTags.isEmpty())
         method = (ExecutableElement) docs.holder;
     }
     TypeMirror containingType = method.getEnclosingElement().asType();
     writer.addComments(containingType, method, methodDocTree);
   }
 }
  /**
   * Determines whether or not the given element overrides the named method in the named class.
   *
   * @param e an element for a method
   * @param clazz the class
   * @param method the name of a method
   * @return true if the method given by {@code e} overrides the named method in the named class;
   *     false otherwise
   */
  private boolean overrides(ExecutableElement e, Class<?> clazz, String method) {

    // Get the element named by "clazz".
    TypeElement clazzElt = elements.getTypeElement(clazz.getCanonicalName());
    assert clazzElt != null;

    // Check all of the methods in the class for name matches and overriding.
    for (ExecutableElement elt : methodsIn(clazzElt.getEnclosedElements()))
      if (elt.getSimpleName().contentEquals(method) && elements.overrides(e, elt, clazzElt))
        return true;

    return false;
  }
示例#29
0
 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;
 }
  private Set<TypeElement> processDelegateMethods() {
    Set<Element> delegateMethods = (Set) getElements(QueryDelegate.class);
    Set<TypeElement> typeElements = new HashSet<TypeElement>();

    for (Element delegateMethod : delegateMethods) {
      ExecutableElement method = (ExecutableElement) delegateMethod;
      Element element = delegateMethod.getEnclosingElement();
      String name = method.getSimpleName().toString();
      Type delegateType = typeFactory.getType(element.asType(), true);
      Type returnType = typeFactory.getType(method.getReturnType(), true);
      List<Parameter> parameters = elementHandler.transformParams(method.getParameters());
      // remove first element
      parameters = parameters.subList(1, parameters.size());

      EntityType entityType = null;
      for (AnnotationMirror annotation : delegateMethod.getAnnotationMirrors()) {
        if (TypeUtils.isAnnotationMirrorOfType(annotation, QueryDelegate.class)) {
          TypeMirror type = TypeUtils.getAnnotationValueAsTypeMirror(annotation, "value");
          if (type != null) {
            entityType = typeFactory.getEntityType(type, true);
          }
        }
      }

      if (entityType != null) {
        registerTypeElement(entityType.getFullName(), (TypeElement) element);
        entityType.addDelegate(
            new Delegate(entityType, delegateType, name, parameters, returnType));
        TypeElement typeElement =
            processingEnv.getElementUtils().getTypeElement(entityType.getFullName());
        boolean isAnnotated = false;
        for (Class<? extends Annotation> ann : conf.getEntityAnnotations()) {
          if (typeElement.getAnnotation(ann) != null) {
            isAnnotated = true;
          }
        }
        if (isAnnotated) {
          // handle also properties of entity type
          typeElements.add(
              processingEnv.getElementUtils().getTypeElement(entityType.getFullName()));
        } else {
          // skip handling properties
          context.extensionTypes.put(entityType.getFullName(), entityType);
          context.allTypes.put(entityType.getFullName(), entityType);
        }
      }
    }

    return typeElements;
  }