/**
  * 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");
 }
  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;
  }
Beispiel #3
0
  /**
   * Returns the annotation on {@code element} formatted as a Map. This returns a Map rather than an
   * instance of the annotation interface to work-around the fact that Class and Class[] fields
   * won't work at code generation time. See
   * http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=5089128
   */
  public static Map<String, Object> getAnnotation(Class<?> annotationType, Element element) {
    for (AnnotationMirror annotation : element.getAnnotationMirrors()) {
      if (!rawTypeToString(annotation.getAnnotationType(), '$').equals(annotationType.getName())) {
        continue;
      }

      Map<String, Object> result = new LinkedHashMap<String, Object>();
      for (Method m : annotationType.getMethods()) {
        result.put(m.getName(), m.getDefaultValue());
      }
      for (Map.Entry<? extends ExecutableElement, ? extends AnnotationValue> e :
          annotation.getElementValues().entrySet()) {
        String name = e.getKey().getSimpleName().toString();
        Object value = e.getValue().accept(VALUE_EXTRACTOR, null);
        Object defaultValue = result.get(name);
        if (!lenientIsInstance(defaultValue.getClass(), value)) {
          throw new IllegalStateException(
              String.format(
                  "Value of %s.%s is a %s but expected a %s\n    value: %s",
                  annotationType,
                  name,
                  value.getClass().getName(),
                  defaultValue.getClass().getName(),
                  value instanceof Object[] ? Arrays.toString((Object[]) value) : value));
        }
        result.put(name, value);
      }
      return result;
    }
    return null; // Annotation not found.
  }
Beispiel #4
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);
    }
  }
 @Override
 public Set<TypeElement> scan(Element e, Set<TypeElement> p) {
   for (AnnotationMirror annotationMirror : elements.getAllAnnotationMirrors(e)) {
     Element e2 = annotationMirror.getAnnotationType().asElement();
     p.add((TypeElement) e2);
   }
   return super.scan(e, p);
 }
 private static boolean hasAnnotationWithName(Element element, String simpleName) {
   for (AnnotationMirror mirror : element.getAnnotationMirrors()) {
     String annotationName = mirror.getAnnotationType().asElement().getSimpleName().toString();
     if (simpleName.equals(annotationName)) {
       return true;
     }
   }
   return false;
 }
 private Optional<String> getPointsAnnotationValueIfAny(Element element) {
   for (AnnotationMirror am : element.getAnnotationMirrors()) {
     Name annotationName = am.getAnnotationType().asElement().getSimpleName();
     if (annotationName.contentEquals("Points")) {
       String value = getAnnotationValue(am);
       return Optional.of(value);
     }
   }
   return Optional.absent();
 }
 private AnnotationMirror getAnnotation(Element element, String type) {
   if (element != null) {
     for (AnnotationMirror annotation : element.getAnnotationMirrors()) {
       if (type.equals(annotation.getAnnotationType().toString())) {
         return annotation;
       }
     }
   }
   return null;
 }
 GwtCompatibility(TypeElement type) {
   Optional<AnnotationMirror> gwtCompatibleAnnotation = Optional.absent();
   List<? extends AnnotationMirror> annotations = type.getAnnotationMirrors();
   for (AnnotationMirror annotation : annotations) {
     Name name = annotation.getAnnotationType().asElement().getSimpleName();
     if (name.contentEquals("GwtCompatible")) {
       gwtCompatibleAnnotation = Optional.of(annotation);
     }
   }
   this.gwtCompatibleAnnotation = gwtCompatibleAnnotation;
 }
Beispiel #10
0
 /**
  * Returns an {@link AnnotationMirror} for the annotation of type {@code annotationClassName} on
  * {@code element}, or {@link Optional#absent()} if no such annotation exists.
  */
 public static Optional<AnnotationMirror> findAnnotationMirror(
     Element element, String annotationClassName) {
   for (AnnotationMirror annotationMirror : element.getAnnotationMirrors()) {
     TypeElement annotationTypeElement =
         (TypeElement) (annotationMirror.getAnnotationType().asElement());
     if (annotationTypeElement.getQualifiedName().contentEquals(annotationClassName)) {
       return Optional.of(annotationMirror);
     }
   }
   return Optional.absent();
 }
Beispiel #11
0
 static boolean isJacksonJsonTypeInfoAnnotated(Element element) {
   List<? extends AnnotationMirror> annotationMirrors = element.getAnnotationMirrors();
   for (AnnotationMirror annotation : annotationMirrors) {
     TypeElement annotationElement = (TypeElement) annotation.getAnnotationType().asElement();
     if ("com.fasterxml.jackson.annotation.JsonTypeInfo"
         .equals(annotationElement.getQualifiedName().toString())) {
       return true;
     }
   }
   return false;
 }
    /**
     * If any constant-value annotation has &gt; MAX_VALUES number of values provided, treats the
     * value as UnknownVal. Works together with ValueVisitor.visitAnnotation, which issues a warning
     * to the user in this case.
     */
    private void replaceWithUnknownValIfTooManyValues(AnnotatedTypeMirror atm) {
      AnnotationMirror anno = atm.getAnnotationInHierarchy(UNKNOWNVAL);

      if (anno != null && anno.getElementValues().size() > 0) {
        List<Object> values =
            AnnotationUtils.getElementValueArray(anno, "value", Object.class, false);
        if (values != null && values.size() > MAX_VALUES) {
          atm.replaceAnnotation(UNKNOWNVAL);
        }
      }
    }
Beispiel #13
0
 static boolean isJacksonSerializedAnnotated(Element element) {
   List<? extends AnnotationMirror> annotationMirrors = element.getAnnotationMirrors();
   for (AnnotationMirror annotation : annotationMirrors) {
     TypeElement annotationElement = (TypeElement) annotation.getAnnotationType().asElement();
     if (JACKSON_MAPPING_ANNOTATION_CLASSES.contains(
         annotationElement.getQualifiedName().toString())) {
       return true;
     }
   }
   return false;
 }
Beispiel #14
0
 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());
 }
Beispiel #15
0
  protected boolean isExplicitTypeDefinition(Element declaration) {
    if (declaration.getKind() != ElementKind.CLASS) {
      debug("%s isn't a potential JAXB type because it's not a class.", declaration);
      return false;
    }

    PackageElement pckg =
        this.context.getProcessingEnvironment().getElementUtils().getPackageOf(declaration);
    if ((pckg != null) && (pckg.getAnnotation(Ignore.class) != null)) {
      debug(
          "%s isn't a potential JAXB type because its package is annotated as to be ignored.",
          declaration);
      return false;
    }

    if (isThrowable(declaration)) {
      debug(
          "%s isn't a potential JAXB type because it's an instance of java.lang.Throwable.",
          declaration);
      return false;
    }

    List<? extends AnnotationMirror> annotationMirrors = declaration.getAnnotationMirrors();
    boolean explicitXMLTypeOrElement = false;
    for (AnnotationMirror mirror : annotationMirrors) {
      Element annotationDeclaration = mirror.getAnnotationType().asElement();
      if (annotationDeclaration != null) {
        String fqn =
            annotationDeclaration instanceof TypeElement
                ? ((TypeElement) annotationDeclaration).getQualifiedName().toString()
                : "";
        // exclude all XmlTransient types and all jaxws types.
        if (XmlTransient.class.getName().equals(fqn)
            || fqn.startsWith("javax.xml.ws")
            || fqn.startsWith("javax.ws.rs")
            || fqn.startsWith("javax.jws")) {
          debug("%s isn't a potential JAXB type because of annotation %s.", declaration, fqn);
          return false;
        } else {
          explicitXMLTypeOrElement =
              (XmlType.class.getName().equals(fqn)) || (XmlRootElement.class.getName().equals(fqn));
        }
      }

      if (explicitXMLTypeOrElement) {
        break;
      }
    }

    return explicitXMLTypeOrElement;
  }
  private Set<ConstraintCheckError> checkInternal(
      Element element, AnnotationMirror annotation, TypeMirror type, String messageKey) {

    if (constraintHelper.checkConstraint(annotation.getAnnotationType(), type)
        != ConstraintCheckResult.ALLOWED) {

      return CollectionHelper.asSet(
          new ConstraintCheckError(
              element,
              annotation,
              messageKey,
              annotation.getAnnotationType().asElement().getSimpleName()));
    }

    return Collections.emptySet();
  }
  /** @return the String value of a KeyFor, this will throw an exception */
  private Set<String> getKeys(final AnnotationMirror keyFor) {
    if (keyFor.getElementValues().size() == 0) {
      return new LinkedHashSet<>();
    }

    return new LinkedHashSet<>(
        AnnotationUtils.getElementValueArray(keyFor, "value", String.class, true));
  }
 private Map<String, Object> getAnnotationElementValues(AnnotationMirror annotation) {
   Map<String, Object> values = new LinkedHashMap<String, Object>();
   for (Map.Entry<? extends ExecutableElement, ? extends AnnotationValue> entry :
       annotation.getElementValues().entrySet()) {
     values.put(entry.getKey().getSimpleName().toString(), entry.getValue().getValue());
   }
   return values;
 }
 @Override
 public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
   for (TypeElement te : ElementFilter.typesIn(roundEnv.getRootElements())) {
     if (isSimpleName(te, "InvalidSource")) {
       for (Element c : te.getEnclosedElements()) {
         for (AnnotationMirror am : c.getAnnotationMirrors()) {
           Element ate = am.getAnnotationType().asElement();
           if (isSimpleName(ate, "ExpectInterfaces")) {
             checkInterfaces((TypeElement) c, getValue(am));
           } else if (isSimpleName(ate, "ExpectSupertype")) {
             checkSupertype((TypeElement) c, getValue(am));
           }
         }
       }
     }
   }
   return true;
 }
    /**
     * Determines the least upper bound of a1 and a2. If a1 and a2 are both the same type of Value
     * annotation, then the LUB is the result of taking all values from both a1 and a2 and removing
     * duplicates. If a1 and a2 are not the same type of Value annotation they may still be
     * mergeable because some values can be implicitly cast as others. If a1 and a2 are both in
     * {DoubleVal, IntVal} then they will be converted upwards: IntVal &rarr; DoubleVal to arrive at
     * a common annotation type.
     *
     * @return the least upper bound of a1 and a2
     */
    @Override
    public AnnotationMirror leastUpperBound(AnnotationMirror a1, AnnotationMirror a2) {
      if (!AnnotationUtils.areSameIgnoringValues(getTopAnnotation(a1), getTopAnnotation(a2))) {
        return null;
      } else if (isSubtype(a1, a2)) {
        return a2;
      } else if (isSubtype(a2, a1)) {
        return a1;
      }
      // If both are the same type, determine the type and merge:
      else if (AnnotationUtils.areSameIgnoringValues(a1, a2)) {
        List<Object> a1Values =
            AnnotationUtils.getElementValueArray(a1, "value", Object.class, true);
        List<Object> a2Values =
            AnnotationUtils.getElementValueArray(a2, "value", Object.class, true);
        HashSet<Object> newValues = new HashSet<Object>(a1Values.size() + a2Values.size());

        newValues.addAll(a1Values);
        newValues.addAll(a2Values);

        return createAnnotation(a1.getAnnotationType().toString(), newValues);
      }
      // Annotations are in this hierarchy, but they are not the same
      else {
        // If either is UNKNOWNVAL, ARRAYLEN, STRINGVAL, or BOOLEAN then
        // the LUB is
        // UnknownVal
        if (!(AnnotationUtils.areSameByClass(a1, IntVal.class)
            || AnnotationUtils.areSameByClass(a1, DoubleVal.class)
            || AnnotationUtils.areSameByClass(a2, IntVal.class)
            || AnnotationUtils.areSameByClass(a2, DoubleVal.class))) {
          return UNKNOWNVAL;
        } else {
          // At this point one of them must be a DoubleVal and one an
          // IntVal
          AnnotationMirror doubleAnno;
          AnnotationMirror intAnno;

          if (AnnotationUtils.areSameByClass(a2, DoubleVal.class)) {
            doubleAnno = a2;
            intAnno = a1;
          } else {
            doubleAnno = a1;
            intAnno = a2;
          }
          List<Long> intVals = getIntValues(intAnno);
          List<Double> doubleVals = getDoubleValues(doubleAnno);

          for (Long n : intVals) {
            doubleVals.add(n.doubleValue());
          }

          return createDoubleValAnnotation(doubleVals);
        }
      }
    }
Beispiel #21
0
 public static Optional<AnnotationValue> findProperty(
     AnnotationMirror annotation, String propertyName) {
   for (Entry<? extends ExecutableElement, ? extends AnnotationValue> element :
       annotation.getElementValues().entrySet()) {
     if (element.getKey().getSimpleName().contentEquals(propertyName)) {
       return Optional.<AnnotationValue>of(element.getValue());
     }
   }
   return Optional.absent();
 }
  /** @inheritDoc */
  @Override
  public Slot getSlot(final AnnotationMirror annotationMirror) {

    final int id;
    if (InferenceQualifierHierarchy.isVarAnnot(annotationMirror)) {
      if (annotationMirror.getElementValues().isEmpty()) {
        return null; // TODO: should we instead throw an exception?
      } else {
        final AnnotationValue annoValue =
            annotationMirror.getElementValues().values().iterator().next();
        id = Integer.valueOf(annoValue.toString());
      }

      return getVariable(id);

    } else {

      if (constantStore != null) {
        return constantStore.get(AnnotationUtils.annotationName(annotationMirror));

      } else {
        for (Class<? extends Annotation> realAnno : realQualifiers) {
          if (AnnotationUtils.areSameByClass(annotationMirror, realAnno)) {
            return new ConstantSlot(annotationMirror, nextId());
          }
        }
      }
    }

    if (InferenceMain.isHackMode()) {
      return new ConstantSlot(
          InferenceMain.getInstance()
              .getRealTypeFactory()
              .getQualifierHierarchy()
              .getTopAnnotations()
              .iterator()
              .next(),
          nextId());
    }
    ErrorReporter.errorAbort(
        annotationMirror + " is a type of AnnotationMirror not handled by getVariableSlot.");
    return null; // Dead
  }
Beispiel #23
0
 String gwtCompatibleAnnotationString() {
   if (gwtCompatibleAnnotation.isPresent()) {
     AnnotationMirror annotation = gwtCompatibleAnnotation.get();
     TypeElement annotationElement = (TypeElement) annotation.getAnnotationType().asElement();
     String annotationArguments;
     if (annotation.getElementValues().isEmpty()) {
       annotationArguments = "";
     } else {
       List<String> elements = Lists.newArrayList();
       for (Map.Entry<ExecutableElement, AnnotationValue> entry :
           Collections.unmodifiableMap(annotation.getElementValues()).entrySet()) {
         elements.add(entry.getKey().getSimpleName() + " = " + entry.getValue());
       }
       annotationArguments = "(" + Joiner.on(", ").join(elements) + ")";
     }
     return "@" + annotationElement.getQualifiedName() + annotationArguments;
   } else {
     return "";
   }
 }
 private String getAnnotationValue(AnnotationMirror am) {
   for (Map.Entry<? extends ExecutableElement, ? extends AnnotationValue> e :
       am.getElementValues().entrySet()) {
     if (e.getKey().getSimpleName().contentEquals("value")) {
       Object value = e.getValue().getValue();
       if (value instanceof String) {
         return (String) value;
       }
     }
   }
   return "";
 }
Beispiel #25
0
 private static VariableElement getAutoTypeParameter(
     ExecutableElement method, VariableElement target_parameter) {
   for (VariableElement param : method.getParameters()) {
     AnnotationMirror auto_annotation = Utils.getParameterAutoAnnotation(param);
     if (auto_annotation != null) {
       Class annotation_type =
           NativeTypeTranslator.getClassFromType(auto_annotation.getAnnotationType());
       String parameter_name;
       if (annotation_type.equals(AutoType.class)) {
         parameter_name = param.getAnnotation(AutoType.class).value();
       } else if (annotation_type.equals(AutoSize.class)) {
         parameter_name = param.getAnnotation(AutoSize.class).value();
       } else {
         throw new RuntimeException("Unknown annotation type " + annotation_type);
       }
       if (target_parameter.getSimpleName().toString().equals(parameter_name)) {
         return param;
       }
     }
   }
   return null;
 }
  /** Returns whether the field {@code f} is unused, given the annotations on the receiver. */
  private boolean isUnused(
      VariableTree field, Collection<? extends AnnotationMirror> receiverAnnos) {
    if (receiverAnnos.isEmpty()) {
      return false;
    }

    AnnotationMirror unused =
        getDeclAnnotation(TreeUtils.elementFromDeclaration(field), Unused.class);
    if (unused == null) {
      return false;
    }

    Name when = AnnotationUtils.getElementValueClassName(unused, "when", false);
    for (AnnotationMirror anno : receiverAnnos) {
      Name annoName = ((TypeElement) anno.getAnnotationType().asElement()).getQualifiedName();
      if (annoName.contentEquals(when)) {
        return true;
      }
    }

    return false;
  }
  /**
   * INTERNAL: The pre-processing stages requires some knowledge of the annotation values (e.g.
   * targetEntity) so we will visit the annotation values and build complete MetadataAnnotation from
   * the mirrors.
   */
  protected void buildMetadataAnnotations(
      MetadataAnnotatedElement annotatedElement,
      List<? extends AnnotationMirror> annotationMirrors) {
    AnnotationValueVisitor<Object, Object> visitor = new AnnotationValueVisitor<Object, Object>();

    for (AnnotationMirror annotationMirror : annotationMirrors) {
      String annotation = annotationMirror.getAnnotationType().toString();

      // Only add annotations that we care about. Be nice to have API
      // that we could call into with the annotation mirror to the
      // processor to see if it is a supported annotation. That is, it
      // would tie into the  @SupportedAnnotationTypes({"javax.persistence.*",
      // "org.eclipse.persistence.annotations.*"})
      // declaration from CanonicalModelProcessor, but I couldn't find a
      // way to do this. For now we'll check the strings (similar to what
      // is done with our ASM factory).
      if (annotation.contains(JPA_PERSISTENCE_PACKAGE_PREFIX)
          || annotation.contains(ECLIPSELINK_PERSISTENCE_PACKAGE_PREFIX)) {
        annotatedElement.addAnnotation(
            (MetadataAnnotation) visitor.visitAnnotation(annotationMirror, null));
      }
    }
  }
Beispiel #28
0
  private void verifyExclusiveMethodAnnotation(Template template, Class<?>... annotationTypes) {
    List<ExecutableElement> methods =
        ElementFilter.methodsIn(template.getTemplateType().getEnclosedElements());
    for (ExecutableElement method : methods) {
      List<AnnotationMirror> foundAnnotations = new ArrayList<>();
      for (int i = 0; i < annotationTypes.length; i++) {
        Class<?> annotationType = annotationTypes[i];
        AnnotationMirror mirror =
            ElementUtils.findAnnotationMirror(context.getEnvironment(), method, annotationType);
        if (mirror != null) {
          foundAnnotations.add(mirror);
        }
      }
      if (foundAnnotations.size() > 1) {
        List<String> annotationNames = new ArrayList<>();
        for (AnnotationMirror mirror : foundAnnotations) {
          annotationNames.add("@" + ElementUtils.getSimpleName(mirror.getAnnotationType()));
        }

        template.addError("Non exclusive usage of annotations %s.", annotationNames);
      }
    }
  }
  /**
   * Inject extra bound fields into a classInfo.
   *
   * @param extraBoundFields a list that represents the extra fields defined inside a @{@link
   *     BoundBox} annotation.
   * @param classInfo representation of the class whose BoundBox will receive the extra fields.
   */
  private void injectExtraBoundFields(
      List<? extends AnnotationValue> extraBoundFields, ClassInfo classInfo) {
    if (extraBoundFields == null || extraBoundFields.isEmpty()) {
      return;
    }

    List<FieldInfo> listFieldInfos = classInfo.getListFieldInfos();
    TypeMirror fieldClass = null;
    String fieldName = null;
    for (AnnotationValue annotationValue : extraBoundFields) {
      AnnotationMirror annotationMirror = (AnnotationMirror) annotationValue.getValue();
      log.info("mirror " + annotationMirror.getAnnotationType());

      Map<? extends ExecutableElement, ? extends AnnotationValue>
          mapExecutableElementToAnnotationValue = annotationMirror.getElementValues();
      for (Map.Entry<? extends ExecutableElement, ? extends AnnotationValue> entry :
          mapExecutableElementToAnnotationValue.entrySet()) {
        if (BOUNDBOX_ANNOTATION_PARAMETER_EXTRA_BOUND_FIELDS_FIELD_NAME.equals(
            entry.getKey().getSimpleName().toString())) {
          fieldName = getAnnotationValueAsString(entry.getValue());
          // TODO shoot an error if its null or not a valid field name in java
        }
        if (BOUNDBOX_ANNOTATION_PARAMETER_EXTRA_BOUND_FIELDS_FIELD_CLASS.equals(
            entry.getKey().getSimpleName().toString())) {
          fieldClass = (TypeMirror) entry.getValue().getValue();
        }
      }
      FieldInfo fieldInfo = new FieldInfo(fieldName, fieldClass);

      // TODO we should add a warning to the developer here.
      // TODO there can even be an error if a field of the same name but with a different type
      // exists.
      if (!listFieldInfos.contains(fieldInfo)) {
        listFieldInfos.add(fieldInfo);
      }
    }
  }
  private void processLabels(TypeElement resourcesType, List<LabelTemplateMethod> methods) {
    for (Element element : resourcesType.getEnclosedElements()) {
      if (element.getKind() != ElementKind.METHOD) {
        continue;
      }
      final ExecutableElement method = (ExecutableElement) element;
      Message labelAnnotation = element.getAnnotation(Message.class);
      final TemplateParam returnType = new TemplateParam(method.getReturnType().toString());
      final boolean deprecated = method.getAnnotation(Deprecated.class) != null;
      final LabelTemplateMethod labelMethod;
      try {
        labelMethod =
            new LabelTemplateMethod(
                method.getSimpleName().toString(),
                deprecated,
                returnType,
                labelAnnotation.value(),
                labelAnnotation.mobile());
      } catch (Throwable t) {
        processingEnv.getMessager().printMessage(Kind.WARNING, t.getMessage(), resourcesType);
        continue;
      }

      for (VariableElement variable : method.getParameters()) {
        final String paramName = variable.getSimpleName().toString();
        final String paramType = variable.asType().toString();

        List<TemplateAnnotation> annotations = new ArrayList<TemplateAnnotation>();
        for (AnnotationMirror annotationMirrors : variable.getAnnotationMirrors()) {
          annotations.add(new TemplateAnnotation(annotationMirrors.getAnnotationType().toString()));
        }

        labelMethod.getParams().add(new TemplateParam(paramType, paramName, annotations));
      }
      methods.add(labelMethod);
    }
  }