use of com.oracle.svm.core.annotate.Alias in project graal by oracle.
the class AnnotationSubstitutionProcessor method handleFieldInAliasClass.
private void handleFieldInAliasClass(Field annotatedField, Class<?> originalClass) {
if (!NativeImageGenerator.includedIn(ImageSingletons.lookup(Platform.class), lookupAnnotation(annotatedField, Platforms.class))) {
return;
}
ResolvedJavaField annotated = metaAccess.lookupJavaField(annotatedField);
Delete deleteAnnotation = lookupAnnotation(annotatedField, Delete.class);
Alias aliasAnnotation = lookupAnnotation(annotatedField, Alias.class);
Inject injectAnnotation = lookupAnnotation(annotatedField, Inject.class);
int numAnnotations = (deleteAnnotation != null ? 1 : 0) + (aliasAnnotation != null ? 1 : 0) + (injectAnnotation != null ? 1 : 0);
if (numAnnotations == 0) {
guarantee(annotatedField.getName().equals("$assertionsDisabled"), "One of @Delete, @Alias, or @Inject must be used: %s", annotatedField);
/*
* The field $assertionsDisabled can be present in the original class, but does not have
* to. We treat it like an optional @Alias fields without field value recomputation.
*/
ResolvedJavaField original = findOriginalField(annotatedField, originalClass, true);
if (original != null) {
register(fieldSubstitutions, annotated, null, original);
}
return;
}
guarantee(numAnnotations == 1, "Only one of @Delete, @Alias, or @Inject can be used: %s", annotatedField);
if (injectAnnotation != null) {
guarantee(!annotated.isStatic(), "@Inject field must not be static: %s", annotated);
ResolvedJavaField injected = fieldValueRecomputation(originalClass, annotated, annotated, annotatedField);
register(fieldSubstitutions, annotated, null, injected);
ResolvedJavaType original = metaAccess.lookupJavaType(originalClass);
InjectedFieldsType substitution;
if (typeSubstitutions.get(original) instanceof InjectedFieldsType) {
substitution = (InjectedFieldsType) typeSubstitutions.get(original);
register(typeSubstitutions, annotated.getDeclaringClass(), original, substitution);
} else {
substitution = new InjectedFieldsType(original);
register(typeSubstitutions, annotated.getDeclaringClass(), original, substitution);
}
substitution.addInjectedField(injected);
} else {
ResolvedJavaField original = findOriginalField(annotatedField, originalClass, false);
if (original == null) {
return;
}
guarantee(annotated.isStatic() == original.isStatic(), "Static modifier mismatch: %s, %s", annotated, original);
guarantee(annotated.getJavaKind() == original.getJavaKind(), "Type mismatch: %s, %s", annotated, original);
if (deleteAnnotation != null) {
registerAsDeleted(annotated, original, deleteAnnotation);
} else {
ResolvedJavaField alias = fieldValueRecomputation(originalClass, original, annotated, annotatedField);
register(fieldSubstitutions, annotated, original, alias);
}
}
}
use of com.oracle.svm.core.annotate.Alias in project graal by oracle.
the class AnnotationSubstitutionProcessor method handleMethodInAliasClass.
private void handleMethodInAliasClass(Executable annotatedMethod, Class<?> originalClass) {
if (!NativeImageGenerator.includedIn(ImageSingletons.lookup(Platform.class), lookupAnnotation(annotatedMethod, Platforms.class))) {
return;
}
Delete deleteAnnotation = lookupAnnotation(annotatedMethod, Delete.class);
Substitute substituteAnnotation = lookupAnnotation(annotatedMethod, Substitute.class);
AnnotateOriginal annotateOriginalAnnotation = lookupAnnotation(annotatedMethod, AnnotateOriginal.class);
Alias aliasAnnotation = lookupAnnotation(annotatedMethod, Alias.class);
int numAnnotations = (deleteAnnotation != null ? 1 : 0) + (substituteAnnotation != null ? 1 : 0) + (annotateOriginalAnnotation != null ? 1 : 0) + (aliasAnnotation != null ? 1 : 0);
if (numAnnotations == 0) {
guarantee(annotatedMethod instanceof Constructor, "One of @Delete, @Substitute, @AnnotateOriginal, or @Alias must be used: %s", annotatedMethod);
return;
}
guarantee(numAnnotations == 1, "Only one of @Delete, @Substitute, @AnnotateOriginal, or @Alias can be used: %s", annotatedMethod);
ResolvedJavaMethod annotated = metaAccess.lookupJavaMethod(annotatedMethod);
ResolvedJavaMethod original = findOriginalMethod(annotatedMethod, originalClass);
if (original == null) {
/* Optional target that is not present, so nothing to do. */
} else if (deleteAnnotation != null) {
registerAsDeleted(annotated, original, deleteAnnotation);
} else if (substituteAnnotation != null) {
SubstitutionMethod substitution = new SubstitutionMethod(original, annotated);
register(methodSubstitutions, annotated, original, substitution);
} else if (annotateOriginalAnnotation != null) {
AnnotatedMethod substitution = new AnnotatedMethod(original, annotated);
register(methodSubstitutions, annotated, original, substitution);
} else if (aliasAnnotation != null) {
register(methodSubstitutions, annotated, original, original);
}
}
Aggregations