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

Example 1 with Delete

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

Example 2 with Delete

use of com.oracle.svm.core.annotate.Delete in project graal by oracle.

the class DeletedFieldsPlugin method handleField.

private static boolean handleField(GraphBuilderContext b, ResolvedJavaField field) {
    Delete deleteAnnotation = field.getAnnotation(Delete.class);
    if (deleteAnnotation == null) {
        return false;
    }
    String msg = AnnotationSubstitutionProcessor.deleteErrorMessage(field, deleteAnnotation, false);
    ValueNode msgNode = ConstantNode.forConstant(SubstrateObjectConstant.forObject(msg), b.getMetaAccess(), b.getGraph());
    b.handleReplacedInvoke(InvokeKind.Static, b.getMetaAccess().lookupJavaMethod(DeletedMethod.reportErrorMethod), new ValueNode[] { msgNode }, false);
    return true;
}

Example 3 with Delete

use of com.oracle.svm.core.annotate.Delete in project graal by oracle.

the class AnnotationSubstitutionProcessor method lookup.

@Override
public ResolvedJavaType lookup(ResolvedJavaType type) {
    Delete deleteAnnotation = deleteAnnotations.get(type);
    if (deleteAnnotation != null) {
        throw new UnsupportedFeatureException(deleteErrorMessage(type, deleteAnnotation, true));
    }
    ResolvedJavaType substitution = typeSubstitutions.get(type);
    if (substitution != null) {
        return substitution;
    }
    return type;
}

Example 4 with Delete

use of com.oracle.svm.core.annotate.Delete in project graal by oracle.

the class AnnotationSubstitutionProcessor method lookup.

@Override
public ResolvedJavaField lookup(ResolvedJavaField field) {
    Delete deleteAnnotation = deleteAnnotations.get(field);
    if (deleteAnnotation != null) {
        throw new UnsupportedFeatureException(deleteErrorMessage(field, deleteAnnotation, true));
    }
    ResolvedJavaField substitution = fieldSubstitutions.get(field);
    if (substitution != null) {
        return substitution;
    }
    return field;
}

Example 5 with Delete

use of com.oracle.svm.core.annotate.Delete in project graal by oracle.

the class AnnotationSubstitutionProcessor method lookup.

@Override
public ResolvedJavaMethod lookup(ResolvedJavaMethod method) {
    Delete deleteAnnotation = deleteAnnotations.get(method);
    if (deleteAnnotation != null) {
        throw new UnsupportedFeatureException(deleteErrorMessage(method, deleteAnnotation, true));
    }
    ResolvedJavaMethod substitution = methodSubstitutions.get(method);
    if (substitution != null) {
        return substitution;
    }
    return method;
}