Examples with Inject com.oracle.svm.core.annotate.Inject used on opensource projects

Example 1 with Inject

use of com.oracle.svm.core.annotate.Inject 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);
        }
    }
}