com.oracle.truffle.api.interop

Annotation Type MessageResolution

@Target(value=TYPE)
 @Retention(value=SOURCE)
public @interface MessageResolution

Annotation to put on your node to simplify handling of incoming inter-operability messages. This class contains the node implementations for all messages that the receiver object should resolve. Use Resolve to annotate Node implementations of messages. Those messages for which no Resolve is provided are either left unsupported, or in case of HAS/IS messages they get a default boolean value depending on presence of corresponding messages. E.g. HAS_SIZE is true if and only if GET_SIZE is provided, IS_EXECUTABLE is true if and only if EXECUTE is provided, etc. If objects support some messages conditionally, they should provide their own implementation of HAS/IS messages. Elements in the super class that are annotated with Resolve will be ignored. For example:

@MessageResolution(receiverType = ExampleTruffleObject.class)
public static class ExampleTruffleObjectMR {

     @Resolve(message = "READ")
     public abstract static class ExampleReadNode extends Node {

         protected Object access(ExampleTruffleObject receiver,
                                 String name) {
             if (ExampleTruffleObject.MEMBER_NAME.equals(name)) {
                 return receiver.getValue();
             }
             throw UnknownIdentifierException.raise(name);
         }
     }

    @Resolve(message = "WRITE")
    public abstract static class ExampleWriteNode extends Node {

        protected static int access(ExampleTruffleObject receiver,
                                    String name, int value) {
            if (ExampleTruffleObject.MEMBER_NAME.equals(name)) {
                receiver.setValue(value);
                return value;
            }
            throw UnknownIdentifierException.raise(name);
        }
    }

    @CanResolve
    public abstract static class Check extends Node {

        protected static boolean test(TruffleObject receiver) {
            return receiver instanceof ExampleTruffleObject;
        }
    }

}

The receiver object needs to implement a static method isInstance, which checks if a given foreign object is an instance of the given receiver type and can therefore be accessed by this node. For example:

public static boolean isInstance(TruffleObject obj) {
    return obj instanceof ExampleTruffleObject;
}

Alternatively, one can also define a language check node (see CanResolve. From this class a ForeignAccess will be generated. The receiver object can then return a singleton instance of this access. For example:

public ForeignAccess getForeignAccess() {
    return ExampleTruffleObjectMRForeign.ACCESS;
}

Since:

0.13

Required Element Summary

Required Elements

Modifier and Type	Required Element and Description
Class<?>	receiverType The receiver object class that this message implementation belongs to.

Element Detail

receiverType

public abstract Class<?> receiverType

The receiver object class that this message implementation belongs to. An annotation processor generates a ForeignAccess class, which the TruffleObject can use to implement TruffleObject.getForeignAccess().

Returns:

class of the receiver object

Since:

0.13