jdk-sandbox: comparison langtools/src/share/classes/com/sun/tools/javac/comp/LambdaToMethod.java

equal deleted inserted replaced

-:89ecb9d4d654
+:95354d510139
 public static final int FLAG_SERIALIZABLE = 1 << 0;
 /** Flag for alternate metafactories indicating the lambda object has multiple targets */
 public static final int FLAG_MARKERS = 1 << 1;
+/** Flag for alternate metafactories indicating the lambda object requires multiple bridges */
+public static final int FLAG_BRIDGES = 1 << 2;
 private class KlassInfo {
 /**
 * list of methods to append
 */
 //build a sam instance using an indy call to the meta-factory
 int refKind = referenceKind(sym);
 //convert to an invokedynamic call
-result = makeMetaFactoryIndyCall(tree, context.needsAltMetafactory(), context.isSerializable(), refKind, sym, indy_args);
+result = makeMetafactoryIndyCall(context, refKind, sym, indy_args);
 }
 private JCIdent makeThis(Type type, Symbol owner) {
 VarSymbol _this = new VarSymbol(PARAMETER | FINAL | SYNTHETIC,
 names._this,
 List<JCExpression> indy_args = init==null? List.<JCExpression>nil() : translate(List.of(init), localContext.prev);
 //build a sam instance using an indy call to the meta-factory
-result = makeMetaFactoryIndyCall(tree, localContext.needsAltMetafactory(), localContext.isSerializable(), localContext.referenceKind(), refSym, indy_args);
+result = makeMetafactoryIndyCall(localContext, localContext.referenceKind(), refSym, indy_args);
 }
 /**
 * Translate identifiers within a lambda to the mapped identifier
 * @param tree
 "getImplClass", implClass),
 "getImplMethodSignature", implMethodSignature),
 make.Return(makeIndyCall(
 pos,
 syms.lambdaMetafactory,
-names.altMetaFactory,
+names.altMetafactory,
-staticArgs, indyType, serArgs.toList())),
+staticArgs, indyType, serArgs.toList(), samSym.name)),
 null);
 ListBuffer<JCStatement> stmts = kInfo.deserializeCases.get(implMethodName);
 if (stmts == null) {
 stmts = ListBuffer.lb();
 kInfo.deserializeCases.put(implMethodName, stmts);
 */
 private void bridgeMemberReference(JCMemberReference tree, ReferenceTranslationContext localContext) {
 kInfo.addMethod(new MemberReferenceBridger(tree, localContext).bridge());
 }
+private MethodType typeToMethodType(Type mt) {
+Type type = types.erasure(mt);
+return new MethodType(type.getParameterTypes(),
+type.getReturnType(),
+type.getThrownTypes(),
+syms.methodClass);
+}
 /**
 * Generate an indy method call to the meta factory
 */
-private JCExpression makeMetaFactoryIndyCall(JCFunctionalExpression tree, boolean needsAltMetafactory,
+private JCExpression makeMetafactoryIndyCall(TranslationContext<?> context,
-boolean isSerializable, int refKind, Symbol refSym, List<JCExpression> indy_args) {
+int refKind, Symbol refSym, List<JCExpression> indy_args) {
+JCFunctionalExpression tree = context.tree;
 //determine the static bsm args
-Type mtype = types.erasure(tree.descriptorType);
 MethodSymbol samSym = (MethodSymbol) types.findDescriptorSymbol(tree.type.tsym);
 List<Object> staticArgs = List.<Object>of(
-new Pool.MethodHandle(ClassFile.REF_invokeInterface,
+typeToMethodType(samSym.type),
-types.findDescriptorSymbol(tree.type.tsym), types),
 new Pool.MethodHandle(refKind, refSym, types),
-new MethodType(mtype.getParameterTypes(),
+typeToMethodType(tree.getDescriptorType(types)));
-mtype.getReturnType(),
-mtype.getThrownTypes(),
-syms.methodClass));
 //computed indy arg types
 ListBuffer<Type> indy_args_types = ListBuffer.lb();
 for (JCExpression arg : indy_args) {
 indy_args_types.append(arg.type);
 MethodType indyType = new MethodType(indy_args_types.toList(),
 tree.type,
 List.<Type>nil(),
 syms.methodClass);
-Name metafactoryName = needsAltMetafactory ?
+Name metafactoryName = context.needsAltMetafactory() ?
-names.altMetaFactory : names.metaFactory;
+names.altMetafactory : names.metafactory;
-if (needsAltMetafactory) {
+if (context.needsAltMetafactory()) {
 ListBuffer<Object> markers = ListBuffer.lb();
-for (Symbol t : tree.targets.tail) {
+for (Type t : tree.targets.tail) {
-if (t != syms.serializableType.tsym) {
+if (t.tsym != syms.serializableType.tsym) {
-markers.append(t);
+markers.append(t.tsym);
 }
 }
-int flags = isSerializable? FLAG_SERIALIZABLE : 0;
+int flags = context.isSerializable() ? FLAG_SERIALIZABLE : 0;
 boolean hasMarkers = markers.nonEmpty();
-flags |= hasMarkers ? FLAG_MARKERS : 0;
+boolean hasBridges = context.bridges.nonEmpty();
+if (hasMarkers) {
+flags |= FLAG_MARKERS;
+}
+if (hasBridges) {
+flags |= FLAG_BRIDGES;
+}
 staticArgs = staticArgs.append(flags);
 if (hasMarkers) {
 staticArgs = staticArgs.append(markers.length());
 staticArgs = staticArgs.appendList(markers.toList());
 }
-if (isSerializable) {
+if (hasBridges) {
+staticArgs = staticArgs.append(context.bridges.length() - 1);
+for (Symbol s : context.bridges) {
+Type s_erasure = s.erasure(types);
+if (!types.isSameType(s_erasure, samSym.erasure(types))) {
+staticArgs = staticArgs.append(s.erasure(types));
+}
+}
+}
+if (context.isSerializable()) {
 addDeserializationCase(refKind, refSym, tree.type, samSym,
 tree, staticArgs, indyType);
 }
 }
-return makeIndyCall(tree, syms.lambdaMetafactory, metafactoryName, staticArgs, indyType, indy_args);
+return makeIndyCall(tree, syms.lambdaMetafactory, metafactoryName, staticArgs, indyType, indy_args, samSym.name);
 }
 /**
 * Generate an indy method call with given name, type and static bootstrap
 * arguments types
 */
 private JCExpression makeIndyCall(DiagnosticPosition pos, Type site, Name bsmName,
-List<Object> staticArgs, MethodType indyType, List<JCExpression> indyArgs) {
+List<Object> staticArgs, MethodType indyType, List<JCExpression> indyArgs,
+Name methName) {
 int prevPos = make.pos;
 try {
 make.at(pos);
 List<Type> bsm_staticArgs = List.of(syms.methodHandleLookupType,
 syms.stringType,
 Symbol bsm = rs.resolveInternalMethod(pos, attrEnv, site,
 bsmName, bsm_staticArgs, List.<Type>nil());
 DynamicMethodSymbol dynSym =
-new DynamicMethodSymbol(names.lambda,
+new DynamicMethodSymbol(methName,
 syms.noSymbol,
 bsm.isStatic() ?
 ClassFile.REF_invokeStatic :
 ClassFile.REF_invokeVirtual,
 (MethodSymbol)bsm,
 JCNewClass nc = makeNewClass(classType, make.Idents(params));
 nc.pos = tree.pos;
 // Make lambda holding the new-class call
 JCLambda slam = make.Lambda(params, nc);
-slam.descriptorType = tree.descriptorType;
 slam.targets = tree.targets;
 slam.type = tree.type;
 slam.pos = tree.pos;
 // Now it is a lambda, process as such
 int depth;
 /** the enclosing translation context (set for nested lambdas/mref) */
 TranslationContext<?> prev;
+/** list of methods to be bridged by the meta-factory */
+List<Symbol> bridges;
 TranslationContext(T tree) {
 this.tree = tree;
 this.owner = owner();
 this.depth = frameStack.size() - 1;
 this.prev = context();
+ClassSymbol csym =
+types.makeFunctionalInterfaceClass(attrEnv, names.empty, tree.targets, ABSTRACT | INTERFACE);
+this.bridges = types.functionalInterfaceBridges(csym);
 }
 /** does this functional expression need to be created using alternate metafactory? */
 boolean needsAltMetafactory() {
-return (tree.targets.length() > 1 ||
+return tree.targets.length() > 1 ||
-isSerializable());
+isSerializable() ||
+bridges.length() > 1;
 }
 /** does this functional expression require serialization support? */
 boolean isSerializable() {
-for (Symbol target : tree.targets) {
+for (Type target : tree.targets) {
-if (types.asSuper(target.type, syms.serializableType.tsym) != null) {
+if (types.asSuper(target, syms.serializableType.tsym) != null) {
 return true;
 }
 }
 return false;
 }
 generatedLambdaSig(),
 TreeInfo.types(syntheticParams));
 }
 Type generatedLambdaSig() {
-return types.erasure(tree.descriptorType);
+return types.erasure(tree.getDescriptorType(types));
 }
 }
 /**
 * This class retains all the useful information about a method reference;
 Type generatedRefSig() {
 return types.erasure(tree.sym.type);
 }
 Type bridgedRefSig() {
-return types.erasure(types.findDescriptorSymbol(tree.targets.head).type);
+return types.erasure(types.findDescriptorSymbol(tree.targets.head.tsym).type);
 }
 }
 }
 // </editor-fold>

changeset 18730	95354d510139
parent 18412	d0e713f5cabd
child 19487	9097d88f5e1f