stan/jdk-24
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

8005983: JavaAdapterFactory generated proxy classes should take extra constructor arguments at the end

Browse Source 
Reviewed-by: lagergren, sundar
This commit is contained in:
Attila Szegedi 2013-01-10 15:28:05 +01:00
parent 164350cecf
commit ddf4b86c57
4 changed files with 74 additions and 35 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

47
nashorn/src/jdk/nashorn/internal/runtime/linker/JavaAdapterFactory.java
View File

@ -91,7 +91,7 @@ import org.dynalang.dynalink.support.LinkRequestImpl;
* For every protected or public constructor in the extended class (which is either the original class, or Object when
* an interface is implemented), the adapter class will have one or two public constructors (visibility of protected
* constructors in the extended class is promoted to public). In every case, for every original constructor, a new
* constructor taking an initial ScriptObject argument followed by original constructor arguments is present on the
* constructor taking a trailing ScriptObject argument preceded by original constructor arguments is present on the
* adapter class. When such a constructor is invoked, the passed ScriptObject's member functions are used to implement
* and/or override methods on the original class, dispatched by name. A single JavaScript function will act as the
* implementation for all overloaded methods of the same name. When methods on an adapter instance are invoked, the
@ -106,17 +106,24 @@ import org.dynalang.dynalink.support.LinkRequestImpl;
* </p><p>
* For abstract classes or interfaces that only have one abstract method, or have several of them, but all share the
* same name, an additional constructor is provided for every original constructor; this one takes a ScriptFunction as
* its first argument followed by original constructor arguments. This constructor will use the passed function as the
* its last argument preceded by original constructor arguments. This constructor will use the passed function as the
* implementation for all abstract methods. For consistency, any concrete methods sharing the single abstract method
* name will also be overridden by the function. When methods on the adapter instance are invoked, the ScriptFunction is
* invoked with {@code null} as its "this".
* </p><p>If the superclass has a protected or public default constructor, then a generated constructor that only takes
* a ScriptFunction is also implicitly used as an automatic conversion whenever a ScriptFunction is passed in an
* </p><p>
* If the superclass has a protected or public default constructor, then a generated constructor that only takes a
* ScriptFunction is also implicitly used as an automatic conversion whenever a ScriptFunction is passed in an
* invocation of any Java method that expects such SAM type.
* </p><p>
* For adapter methods that return values, all the JavaScript-to-Java conversions supported by Nashorn will be in effect
* to coerce the JavaScript function return value to the expected Java return type.
* </p><p>
* Since we are adding a trailing argument to the generated constructors in the adapter class, they will never be
* declared as variable arity, even if the original constructor in the superclass was declared as variable arity. The
* reason we are passing the additional argument at the end of the argument list instead at the front is that the
* source-level script expression <code>new X(a, b) { ... }</code> (which is a proprietary syntax extension Nashorn uses
* to resemble Java anonymous classes) is actually equivalent to <code>new X(a, b, { ... })</code>.
* </p><p>
* You normally don't use this class directly, but rather either create adapters from script using
* {@link NativeJava#extend(Object, Object)}, using the {@code new} operator on abstract classes and interfaces (see
* {@link NativeJava#type(Object, Object)}), or implicitly when passing script functions to Java methods expecting SAM
@ -504,12 +511,15 @@ public class JavaAdapterFactory {
* {@link #getHandle(ScriptFunction, MethodType, boolean)} or {@link #getHandle(ScriptObject, String, MethodType,
* boolean)} to obtain the method handles; these methods make sure to add the necessary conversions and arity
* adjustments so that the resulting method handles can be invoked from generated methods using {@code invokeExact}.
* The constructor that takes a script function will only initialize the abstract methods
* The constructor will also store the Nashorn global that was current at the constructor invocation time in a
* field named "global". The generated constructor will be public, regardless of whether the supertype constructor
* was public or protected.
* The constructor that takes a script function will only initialize the methods with the same name as the single
* abstract method. The constructor will also store the Nashorn global that was current at the constructor
* invocation time in a field named "global". The generated constructor will be public, regardless of whether the
* supertype constructor was public or protected. The generated constructor will not be variable arity, even if the
* supertype constructor was.
* @param ctor the supertype constructor that is serving as the base for the generated constructor.
* @param fromFunction true if a
* @param fromFunction true if we're generating a constructor that initializes SAM types from a single
* ScriptFunction passed to it, false if we're generating a constructor that initializes an arbitrary type from a
* ScriptObject passed to it.
*/
private void generateConstructor(final Constructor<?> ctor, final boolean fromFunction) {
final Type originalCtorType = Type.getType(ctor);
@ -517,23 +527,22 @@ public class JavaAdapterFactory {
final int argLen = originalArgTypes.length;
final Type[] newArgTypes = new Type[argLen + 1];
// Insert ScriptFunction|ScriptObject as the frontmost argument to the constructor
// Insert ScriptFunction|ScriptObject as the last argument to the constructor
final Type extraArgumentType = fromFunction ? SCRIPT_FUNCTION_TYPE : SCRIPT_OBJECT_TYPE;
newArgTypes[0] = extraArgumentType;
System.arraycopy(originalArgTypes, 0, newArgTypes, 1, argLen);
newArgTypes[argLen] = extraArgumentType;
System.arraycopy(originalArgTypes, 0, newArgTypes, 0, argLen);
// All constructors must be public, even if in the superclass they were protected.
// Existing super constructor <init>(this, args...) triggers generating <init>(this, scriptObj, args...).
final InstructionAdapter mv = new InstructionAdapter(cw.visitMethod(ACC_PUBLIC | (ctor.isVarArgs() ?
ACC_VARARGS : 0), INIT, Type.getMethodDescriptor(originalCtorType.getReturnType(), newArgTypes),
null, null));
final InstructionAdapter mv = new InstructionAdapter(cw.visitMethod(ACC_PUBLIC, INIT,
Type.getMethodDescriptor(originalCtorType.getReturnType(), newArgTypes), null, null));
mv.visitCode();
// First, invoke super constructor with shifted arguments. If the form of the constructor we're generating is
// <init>(this, scriptFn, args...), then we're invoking super.<init>(this, args...).
// First, invoke super constructor with original arguments. If the form of the constructor we're generating is
// <init>(this, args..., scriptFn), then we're invoking super.<init>(this, args...).
mv.visitVarInsn(ALOAD, 0);
final Class<?>[] argTypes = ctor.getParameterTypes();
int offset = 2; // First arg is at position 2, after this and scriptFn.
int offset = 1; // First arg is at position 1, after this.
for (int i = 0; i < argLen; ++i) {
final Type argType = Type.getType(argTypes[i]);
mv.load(offset, argType);
@ -553,7 +562,7 @@ public class JavaAdapterFactory {
// is a deliberate design choice. All other method handles are initialized to null.
mv.visitInsn(ACONST_NULL);
} else {
mv.visitVarInsn(ALOAD, 1);
mv.visitVarInsn(ALOAD, offset);
if(!fromFunction) {
mv.aconst(mi.getName());
}

55
nashorn/src/jdk/nashorn/internal/runtime/linker/NashornLinker.java
View File

@ -85,24 +85,49 @@ public class NashornLinker implements TypeBasedGuardingDynamicLinker, GuardingTy
@Override
public GuardedInvocation convertToType(final Class<?> sourceType, final Class<?> targetType) throws Exception {
final GuardedInvocation gi = convertToTypeNoCast(sourceType, targetType);
return gi == null ? null : gi.asType(MH.type(targetType, sourceType));
}
/**
* Main part of the implementation of {@link GuardingTypeConverterFactory#convertToType(Class, Class)} that doesn't
* care about adapting the method signature; that's done by the invoking method. Returns either a built-in
* conversion to primitive (or primitive wrapper) Java types or to String, or a just-in-time generated converter to
* a SAM type (if the target type is a SAM type).
* @param sourceType the source type
* @param targetType the target type
* @return a guarded invocation that converts from the source type to the target type.
* @throws Exception if something goes wrong
*/
private static GuardedInvocation convertToTypeNoCast(final Class<?> sourceType, final Class<?> targetType) throws Exception {
final MethodHandle mh = JavaArgumentConverters.getConverter(targetType);
final GuardedInvocation gi;
if (mh != null) {
gi = new GuardedInvocation(mh, canLinkTypeStatic(sourceType) ? null : IS_NASHORN_OR_UNDEFINED_TYPE);
} else if (isAutoConvertibleFromFunction(targetType)) {
final MethodHandle ctor = JavaAdapterFactory.getConstructor(ScriptFunction.class, targetType);
assert ctor != null; // if JavaAdapterFactory.isAutoConvertible() returned true, then ctor must exist.
if(ScriptFunction.class.isAssignableFrom(sourceType)) {
gi = new GuardedInvocation(ctor, null);
} else if(sourceType == Object.class) {
gi = new GuardedInvocation(ctor, IS_SCRIPT_FUNCTION);
} else {
return null;
}
} else {
return null;
return new GuardedInvocation(mh, canLinkTypeStatic(sourceType) ? null : IS_NASHORN_OR_UNDEFINED_TYPE);
}
return gi.asType(MH.type(targetType, sourceType));
return getSamTypeConverter(sourceType, targetType);
}
/**
* Returns a guarded invocation that converts from a source type that is ScriptFunction, or a subclass or a
* superclass of it) to a SAM type.
* @param sourceType the source type (presumably ScriptFunction or a subclass or a superclass of it)
* @param targetType the target type (presumably a SAM type)
* @return a guarded invocation that converts from the source type to the target SAM type. null is returned if
* either the source type is neither ScriptFunction, nor a subclass, nor a superclass of it, or if the target type
* is not a SAM type.
* @throws Exception if something goes wrong; generally, if there's an issue with creation of the SAM proxy type
* constructor.
*/
private static GuardedInvocation getSamTypeConverter(final Class<?> sourceType, final Class<?> targetType) throws Exception {
// If source type is more generic than ScriptFunction class, we'll need to use a guard
final boolean isSourceTypeGeneric = sourceType.isAssignableFrom(ScriptFunction.class);
if ((isSourceTypeGeneric || ScriptFunction.class.isAssignableFrom(sourceType)) && isAutoConvertibleFromFunction(targetType)) {
final MethodHandle ctor = JavaAdapterFactory.getConstructor(ScriptFunction.class, targetType);
assert ctor != null; // if isAutoConvertibleFromFunction() returned true, then ctor must exist.
return new GuardedInvocation(ctor, isSourceTypeGeneric ? IS_SCRIPT_FUNCTION : null);
}
return null;
}
private static boolean isAutoConvertibleFromFunction(final Class<?> clazz) {

6
nashorn/test/script/sandbox/javaextend.js
View File

@ -98,5 +98,9 @@ print("oo-proto-overridden-equals : " + (new oo(new Proto())).equals({}))
// additional constructor arguments (a token). Also demonstrates how can
// you access the Java adapter instance from the script (just store it in the
// scope, in this example, "cwa") to retrieve the token later on.
var cwa = new (Java.extend(model("ConstructorWithArgument")))(function() { print(cwa.token) }, "cwa-token")
var cwa = new (Java.extend(model("ConstructorWithArgument")))("cwa-token", function() { print(cwa.token) })
cwa.doSomething()
// Do the same thing with proprietary syntax and object literal
var cwa2 = new (model("ConstructorWithArgument"))("cwa2-token") { doSomething: function() { print("cwa2-" + cwa2.token ) } }
cwa2.doSomething()

1
nashorn/test/script/sandbox/javaextend.js.EXPECTED
View File

@ -17,3 +17,4 @@ oo-proto-overridden-hashCode: 7
oo-proto-overridden-toString: override-object
oo-proto-overridden-equals : true
cwa-token
cwa2-cwa2-token