javax.lang.model.AnnotatedConstruct Java Examples

public static <A extends Annotation> A createOrGetUnderlying(
    TreeBackedAnnotatedConstruct annotatedConstruct,
    AnnotatedConstruct underlyingConstruct,
    Class<A> annotationType) {
  for (AnnotationMirror mirror : underlyingConstruct.getAnnotationMirrors()) {
    if (mirror.getAnnotationType().toString().equals(annotationType.getName()))
      return annotationType.cast(
          Proxy.newProxyInstance(
              annotationType.getClassLoader(),
              new Class[] {annotationType},
              new Handler(annotatedConstruct, annotationType, mirror)));
  }
  // Either the annotation doesn't exist or name comparison failed in some weird way.
  // Either way, fall back to the underlying construct.
  return annotatedConstruct.getAnnotationWithBetterErrors(annotationType);
}
 

/**
 * Get a specific annotation mirror from an annotated construct.
 */
static AnnotationMirror getAnnotation(AnnotatedConstruct e, String name) {
    for (AnnotationMirror m: e.getAnnotationMirrors()) {
        TypeElement te = (TypeElement) m.getAnnotationType().asElement();
        if (te.getQualifiedName().contentEquals(name)) {
            return m;
        }
    }
    return null;
}
 

/**
 * Constructs a human readable representation of the supplied element or type mirror. Note that in some cases
 * the representation might be "surprising". Especially for {@link ExecutableType} for which there is no way
 * of getting reliably at the method name or the type declaring the method.
 *
 * @param construct the element or type mirror to render
 * @return a human readable representation of the construct
 */
@Nonnull
public static String toHumanReadableString(@Nonnull AnnotatedConstruct construct) {
    StringBuilderAndState<TypeMirror> state = new StringBuilderAndState<>();

    if (construct instanceof Element) {
        ((Element) construct).accept(toHumanReadableStringElementVisitor, state);
    } else if (construct instanceof TypeMirror) {
        ((TypeMirror) construct).accept(toHumanReadableStringVisitor, state);
    }
    return state.bld.toString();
}
 

/** Similar to the above but matches against a pattern. */
public static boolean hasNamedAnnotation(AnnotatedConstruct ac, Pattern pattern) {
  for (AnnotationMirror annotation : getAllAnnotations(ac)) {
    if (pattern.matcher(getName(annotation.getAnnotationType().asElement())).matches()) {
      return true;
    }
  }
  return false;
}
 

/**
 * Less strict version of the above where we don't care about the annotation's package.
 */
public static boolean hasNamedAnnotation(AnnotatedConstruct ac, String name) {
  for (AnnotationMirror annotation : getAllAnnotations(ac)) {
    if (getName(annotation.getAnnotationType().asElement()).equals(name)) {
      return true;
    }
  }
  return false;
}
 

/**
 * Get a specific annotation mirror from an annotated construct.
 */
static AnnotationMirror getAnnotation(AnnotatedConstruct e, String name) {
    for (AnnotationMirror m: e.getAnnotationMirrors()) {
        TypeElement te = (TypeElement) m.getAnnotationType().asElement();
        if (te.getQualifiedName().contentEquals(name)) {
            return m;
        }
    }
    return null;
}
 

/**
 * Get a specific annotation mirror from an annotated construct.
 */
static AnnotationMirror getAnnotation(AnnotatedConstruct e, String name) {
    for (AnnotationMirror m: e.getAnnotationMirrors()) {
        TypeElement te = (TypeElement) m.getAnnotationType().asElement();
        if (te.getQualifiedName().contentEquals(name)) {
            return m;
        }
    }
    return null;
}
 

/**
 * Get a specific annotation mirror from an annotated construct.
 */
static AnnotationMirror getAnnotation(AnnotatedConstruct e, String name) {
    for (AnnotationMirror m: e.getAnnotationMirrors()) {
        TypeElement te = (TypeElement) m.getAnnotationType().asElement();
        if (te.getQualifiedName().contentEquals(name)) {
            return m;
        }
    }
    return null;
}
 

/**
 * Get a specific annotation mirror from an annotated construct.
 */
static AnnotationMirror getAnnotation(AnnotatedConstruct e, String name) {
    for (AnnotationMirror m: e.getAnnotationMirrors()) {
        TypeElement te = (TypeElement) m.getAnnotationType().asElement();
        if (te.getQualifiedName().contentEquals(name)) {
            return m;
        }
    }
    return null;
}
 

@Override @DefinedBy(Api.LANGUAGE_MODEL)
public Origin getOrigin(AnnotatedConstruct c, AnnotationMirror a) {
    Compound ac = cast(Compound.class, a);
    if (ac.isSynthesized())
        return Origin.MANDATED;
    return Origin.EXPLICIT;
}
 

/** The namespace specified on a package, type, method or field. */
public static String getJsNamespace(AnnotatedConstruct typeBinding) {
  AnnotationMirror annotation = getJsTypeAnnotation(typeBinding);
  if (annotation == null) {
    annotation = getJsEnumAnnotation(typeBinding);
  }
  if (annotation == null) {
    annotation = getJsPackageAnnotation(typeBinding);
  }
  return getJsNamespace(annotation);
}
 

public static boolean isUnusableByJsSuppressed(AnnotatedConstruct binding) {
  AnnotationMirror suppressWarningsBinding =
      AnnotationUtils.findAnnotationBindingByName(
          binding.getAnnotationMirrors(), SUPPRESS_WARNINGS_ANNOTATION_NAME);
  if (suppressWarningsBinding == null) {
    return false;
  }
  List<?> suppressions =
      AnnotationUtils.getAnnotationParameterArray(suppressWarningsBinding, "value");
  return suppressions.stream().map(Object::toString).anyMatch("\"unusable-by-js\""::equals);
}
 

/**
 * Get a specific annotation mirror from an annotated construct.
 */
static AnnotationMirror getAnnotation(AnnotatedConstruct e, String name) {
    for (AnnotationMirror m: e.getAnnotationMirrors()) {
        TypeElement te = (TypeElement) m.getAnnotationType().asElement();
        if (te.getQualifiedName().contentEquals(name)) {
            return m;
        }
    }
    return null;
}
 

/**
 * Get a specific annotation mirror from an annotated construct.
 */
static AnnotationMirror getAnnotation(AnnotatedConstruct e, String name) {
    for (AnnotationMirror m: e.getAnnotationMirrors()) {
        TypeElement te = (TypeElement) m.getAnnotationType().asElement();
        if (te.getQualifiedName().contentEquals(name)) {
            return m;
        }
    }
    return null;
}
 

@Override @DefinedBy(Api.LANGUAGE_MODEL)
public Origin getOrigin(AnnotatedConstruct c, AnnotationMirror a) {
    Compound ac = cast(Compound.class, a);
    if (ac.isSynthesized())
        return Origin.MANDATED;
    return Origin.EXPLICIT;
}
 

/**
 * Get a specific annotation mirror from an annotated construct.
 */
static AnnotationMirror getAnnotation(AnnotatedConstruct e, String name) {
    for (AnnotationMirror m: e.getAnnotationMirrors()) {
        TypeElement te = (TypeElement) m.getAnnotationType().asElement();
        if (te.getQualifiedName().contentEquals(name)) {
            return m;
        }
    }
    return null;
}
 

public static boolean hasCustomValue(AnnotatedConstruct typeBinding) {
  return hasCustomValue(getJsEnumAnnotation(typeBinding));
}
 

public TreeBackedAnnotatedConstruct(AnnotatedConstruct underlyingConstruct) {
  this.underlyingConstruct = underlyingConstruct;
}
 

public static List<GeneratedAnnotationMirror> get(AnnotatedConstruct construct) {
  return annotations.getOrDefault(construct, ImmutableList.of());
}
 

public static void add(AnnotatedConstruct construct, GeneratedAnnotationMirror annotation) {
  annotations.computeIfAbsent(construct, k -> new ArrayList<>()).add(annotation);
}
 

private static Iterable<? extends AnnotationMirror> getAllAnnotations(AnnotatedConstruct ac) {
  return Iterables.concat(ac.getAnnotationMirrors(), ExternalAnnotations.get(ac));
}
 

private void recordAnnotations(AnnotatedConstruct construct, Set<Annotation> annotations) {
  for (Annotation annotation : annotations) {
    ExternalAnnotations.add(construct, generateAnnotationMirror(annotation));
  }
}
 

/** Returns true if the construct is annotated with {@code annotationSourceName}. */
static boolean hasAnnotation(AnnotatedConstruct construct, String annotationSourceName) {
  return findAnnotationBindingByName(construct.getAnnotationMirrors(), annotationSourceName)
      != null;
}
 

public static boolean isJsAsync(AnnotatedConstruct method) {
  return JsInteropAnnotationUtils.getJsAsyncAnnotation(method) != null;
}
 

public static boolean isJsOverlay(AnnotatedConstruct method) {
  return JsInteropAnnotationUtils.getJsOverlayAnnotation(method) != null;
}
 

public static boolean isJsType(AnnotatedConstruct type) {
  return JsInteropAnnotationUtils.getJsTypeAnnotation(type) != null;
}
 

private static boolean isDeprecated(AnnotatedConstruct binding) {
  return AnnotationUtils.hasAnnotation(binding, Deprecated.class.getName());
}
 

public static boolean isJsFunction(AnnotatedConstruct type) {
  return JsInteropAnnotationUtils.getJsFunctionAnnotation(type) != null;
}
 

public static AnnotationMirror getJsPackageAnnotation(AnnotatedConstruct methodBinding) {
  return AnnotationUtils.findAnnotationBindingByName(
      methodBinding.getAnnotationMirrors(), JS_PACKAGE_ANNOTATION_NAME);
}
 

public static AnnotationMirror getJsAsyncAnnotation(AnnotatedConstruct methodBinding) {
  return AnnotationUtils.findAnnotationBindingByName(
      methodBinding.getAnnotationMirrors(), JS_ASYNC_ANNOTATION_NAME);
}