TruffleListCache(Class<?> receiverClass, Class<?> valueClass, Type valueType) { this.receiverClass = receiverClass; this.valueClass = valueClass; this.valueType = valueType; this.get = initializeCall(new Get(this)); this.size = initializeCall(new Size(this)); this.set = initializeCall(new Set(this)); this.remove = initializeCall(new Remove(this)); this.apply = initializeCall(new Apply(this)); }
private static Object doInvoke(SingleMethodDesc method, Object obj, Object[] arguments, Object languageContext) { assert arguments.length == method.getParameterCount(); Object ret; try { ret = method.invoke(obj, arguments); } catch (Throwable e) { throw JavaInteropReflect.rethrow(JavaInterop.wrapHostException(languageContext, e)); } return JavaInterop.toGuestValue(ret, languageContext); }
public Object access(JavaObject receiver) { if (TruffleOptions.AOT) { return false; } return receiver.isClass() && lookupConstructor().execute(receiver.asClass()) != null; }
TruffleMapCache(Class<?> receiverClass, Class<?> keyClass, Class<?> valueClass, Type valueType) { this.receiverClass = receiverClass; this.keyClass = keyClass; this.valueClass = valueClass; this.valueType = valueType; this.memberKey = keyClass == Object.class || keyClass == String.class || keyClass == CharSequence.class; this.numberKey = keyClass == Object.class || keyClass == Number.class || keyClass == Integer.class || keyClass == Long.class || keyClass == Short.class || keyClass == Byte.class; this.get = initializeCall(new Get(this)); this.containsKey = initializeCall(new ContainsKey(this)); this.entrySet = initializeCall(new EntrySet(this)); this.put = initializeCall(new Put(this)); this.remove = initializeCall(new Remove(this)); this.removeBoolean = initializeCall(new RemoveBoolean(this)); this.apply = initializeCall(new Apply(this)); }
public int access(JavaObject receiver, String name) { if (receiver.isNull()) { throw UnsupportedMessageException.raise(Message.KEY_INFO); } if (TruffleOptions.AOT) { return 0; } return keyInfoCache().execute(receiver.getLookupClass(), name, receiver.isStaticClass()); }
@Override protected Object executeImpl(Object languageContext, TruffleObject function, Object[] args, int offset) { if (executeNode == null) { CompilerDirectives.transferToInterpreterAndInvalidate(); this.returnClass = JavaInteropReflect.getMethodReturnType(method); this.returnType = JavaInteropReflect.getMethodGenericReturnType(method); this.executeNode = insert(new TruffleExecuteNode()); } return executeNode.execute(languageContext, function, args[offset], returnClass, returnType); }
static SingleMethodDesc unreflect(Constructor<?> reflectionConstructor) { assert isAccessible(reflectionConstructor); if (TruffleOptions.AOT || isCallerSensitive(reflectionConstructor)) { return new ConstructorReflectImpl(reflectionConstructor); } else { return new ConstructorMHImpl(reflectionConstructor); } }
static SingleMethodDesc unreflect(Method reflectionMethod) { assert isAccessible(reflectionMethod); if (TruffleOptions.AOT || isCallerSensitive(reflectionMethod)) { return new MethodReflectImpl(reflectionMethod); } else { return new MethodMHImpl(reflectionMethod); } }
private JavaMethodDesc lookupFunctionalInterfaceMethod(JavaObject receiver) { if (lookupMethod == null) { CompilerDirectives.transferToInterpreterAndInvalidate(); lookupMethod = insert(LookupFunctionalMethodNode.create()); } return lookupMethod.execute(receiver.getLookupClass()); } }
private JavaMethodDesc lookupFunctionalInterfaceMethod(JavaObject receiver) { if (lookupMethod == null) { CompilerDirectives.transferToInterpreterAndInvalidate(); lookupMethod = insert(LookupFunctionalMethodNode.create()); } return lookupMethod.execute(receiver.getLookupClass()); } }
boolean canConvertStrict(Object value, Class<?> targetType) { if (isAssignableFromTrufflePrimitiveType(targetType)) { Object convertedValue = primitive.toPrimitive(value, targetType); if (convertedValue != null) { return true; } } if (JavaObject.isJavaInstance(targetType, value)) { return true; } return false; }
static JavaFieldDesc unreflect(Field reflectionField) { assert isAccessible(reflectionField); if (TruffleOptions.AOT) { return new ReflectImpl(reflectionField); } else { return new MHImpl(reflectionField); } }
static <T> TruffleObject asTruffleFunction(Class<T> functionalInterface, T implementation, Object languageContext) { final Method method = functionalInterfaceMethod(functionalInterface); if (method == null) { throw new IllegalArgumentException(); } return new JavaFunctionObject(SingleMethodDesc.unreflect(method), implementation, languageContext); }
@Override public Object execute(VirtualFrame frame) { return node.execute(value, type, null, currentPolyglotContext()); } }
static TruffleObject asTruffleViaReflection(Object obj, Object languageContext) { if (obj instanceof Proxy) { return asTruffleObjectProxy(obj, languageContext); } return JavaObject.forObject(obj, languageContext); }
public Object access(JavaObject receiver) { if (TruffleOptions.AOT) { return false; } return receiver.obj != null && !receiver.isClass() && lookupFunctionalInterfaceMethod(receiver) != null; }
static <K, V> Map<K, V> create(Object languageContext, TruffleObject foreignObject, boolean implementsFunction, Class<K> keyClass, Class<V> valueClass, Type valueType) { if (implementsFunction) { return new FunctionTruffleMap<>(languageContext, foreignObject, keyClass, valueClass, valueType); } else { return new TruffleMap<>(languageContext, foreignObject, keyClass, valueClass, valueType); } }
public boolean isMethod() { return getOverloads()[0].isMethod(); }
public boolean isConstructor() { return getOverloads()[0].isConstructor(); }
@Override public String getName() { return getOverloads()[0].getName(); }