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

Merge

Browse Source
This commit is contained in:
Alejandro Murillo 2016-04-05 20:02:21 -07:00
commit 0fd0374c4f
4 changed files with 49 additions and 33 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
langtools/src/jdk.compiler/share/classes/com/sun/tools/javac/code/Symtab.java
View File

@ -167,6 +167,7 @@ public class Symtab {
public final Type cloneableType;
public final Type serializableType;
public final Type serializedLambdaType;
public final Type varHandleType;
public final Type methodHandleType;
public final Type methodHandleLookupType;
public final Type methodTypeType;
@ -468,6 +469,7 @@ public class Symtab {
throwableType = enterClass("java.lang.Throwable");
serializableType = enterClass("java.io.Serializable");
serializedLambdaType = enterClass("java.lang.invoke.SerializedLambda");
varHandleType = enterClass("java.lang.invoke.VarHandle");
methodHandleType = enterClass("java.lang.invoke.MethodHandle");
methodHandleLookupType = enterClass("java.lang.invoke.MethodHandles$Lookup");
methodTypeType = enterClass("java.lang.invoke.MethodType");

13
langtools/src/jdk.compiler/share/classes/com/sun/tools/javac/code/Types.java
View File

@ -1062,18 +1062,19 @@ public class Types {
}
/**
* A polymorphic signature method (JLS 15.12.3) is a method that
* (i) is declared in the java.lang.invoke.MethodHandle class, (ii) takes
* a single variable arity parameter (iii) whose declared type is Object[],
* (iv) has a return type of Object and (v) is native.
* A polymorphic signature method (JLS 15.12.3) is a method that
* (i) is declared in the java.lang.invoke.MethodHandle/VarHandle classes;
* (ii) takes a single variable arity parameter;
* (iii) whose declared type is Object[];
* (iv) has any return type, Object signifying a polymorphic return type; and
* (v) is native.
*/
public boolean isSignaturePolymorphic(MethodSymbol msym) {
List<Type> argtypes = msym.type.getParameterTypes();
return (msym.flags_field & NATIVE) != 0 &&
msym.owner == syms.methodHandleType.tsym &&
(msym.owner == syms.methodHandleType.tsym || msym.owner == syms.varHandleType.tsym) &&
argtypes.tail.tail == null &&
argtypes.head.hasTag(TypeTag.ARRAY) &&
msym.type.getReturnType().tsym == syms.objectType.tsym &&
((ArrayType)argtypes.head).elemtype.tsym == syms.objectType.tsym;
}

53
langtools/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Infer.java
View File

@ -560,30 +560,37 @@ public class Infer {
List<Type> argtypes) {
final Type restype;
//The return type for a polymorphic signature call is computed from
//the enclosing tree E, as follows: if E is a cast, then use the
//target type of the cast expression as a return type; if E is an
//expression statement, the return type is 'void' - otherwise the
//return type is simply 'Object'. A correctness check ensures that
//env.next refers to the lexically enclosing environment in which
//the polymorphic signature call environment is nested.
if (spMethod == null || types.isSameType(spMethod.getReturnType(), syms.objectType, true)) {
// The return type of the polymorphic signature is polymorphic,
// and is computed from the enclosing tree E, as follows:
// if E is a cast, then use the target type of the cast expression
// as a return type; if E is an expression statement, the return
// type is 'void'; otherwise
// the return type is simply 'Object'. A correctness check ensures
// that env.next refers to the lexically enclosing environment in
// which the polymorphic signature call environment is nested.
switch (env.next.tree.getTag()) {
case TYPECAST:
JCTypeCast castTree = (JCTypeCast)env.next.tree;
restype = (TreeInfo.skipParens(castTree.expr) == env.tree) ?
castTree.clazz.type :
syms.objectType;
break;
case EXEC:
JCTree.JCExpressionStatement execTree =
(JCTree.JCExpressionStatement)env.next.tree;
restype = (TreeInfo.skipParens(execTree.expr) == env.tree) ?
syms.voidType :
syms.objectType;
break;
default:
restype = syms.objectType;
switch (env.next.tree.getTag()) {
case TYPECAST:
JCTypeCast castTree = (JCTypeCast)env.next.tree;
restype = (TreeInfo.skipParens(castTree.expr) == env.tree) ?
castTree.clazz.type :
syms.objectType;
break;
case EXEC:
JCTree.JCExpressionStatement execTree =
(JCTree.JCExpressionStatement)env.next.tree;
restype = (TreeInfo.skipParens(execTree.expr) == env.tree) ?
syms.voidType :
syms.objectType;
break;
default:
restype = syms.objectType;
}
} else {
// The return type of the polymorphic signature is fixed
// (not polymorphic)
restype = spMethod.getReturnType();
}
List<Type> paramtypes = argtypes.map(new ImplicitArgType(spMethod, resolveContext.step));

14
langtools/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Resolve.java
View File

@ -2492,13 +2492,19 @@ public class Resolve {
Type mtype = infer.instantiatePolymorphicSignatureInstance(env,
(MethodSymbol)spMethod, currentResolutionContext, argtypes);
for (Symbol sym : polymorphicSignatureScope.getSymbolsByName(spMethod.name)) {
if (types.isSameType(mtype, sym.type)) {
return sym;
// Check that there is already a method symbol for the method
// type and owner
if (types.isSameType(mtype, sym.type) &&
spMethod.owner == sym.owner) {
return sym;
}
}
// create the desired method
long flags = ABSTRACT | HYPOTHETICAL | spMethod.flags() & Flags.AccessFlags;
// Create the desired method
// Retain static modifier is to support invocations to
// MethodHandle.linkTo* methods
long flags = ABSTRACT | HYPOTHETICAL |
spMethod.flags() & (Flags.AccessFlags | Flags.STATIC);
Symbol msym = new MethodSymbol(flags, spMethod.name, mtype, spMethod.owner) {
@Override
public Symbol baseSymbol() {