jdk8-mips64-public/langtools: comparison src/share/classes/com/sun/tools/javac/comp/LambdaToMethod.java

-:792c40d5185a
+:be62183f938a
 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(context, refKind, sym, indy_args);
+result = makeMetaFactoryIndyCall(tree, context.needsAltMetafactory(), context.isSerializable(), 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(localContext, localContext.referenceKind(), refSym, indy_args);
+result = makeMetaFactoryIndyCall(tree, localContext.needsAltMetafactory(), localContext.isSerializable(), localContext.referenceKind(), refSym, indy_args);
 }
 /**
 * Translate identifiers within a lambda to the mapped identifier
 * @param tree
 }
 /**
 * Generate an indy method call to the meta factory
 */
-private JCExpression makeMetaFactoryIndyCall(TranslationContext<?> context,
+private JCExpression makeMetaFactoryIndyCall(JCFunctionalExpression tree, boolean needsAltMetafactory,
-int refKind, Symbol refSym, List<JCExpression> indy_args) {
+boolean isSerializable, int refKind, Symbol refSym, List<JCExpression> indy_args) {
-JCFunctionalExpression tree = context.tree;
 //determine the static bsm args
-Type mtype = types.erasure(tree.getDescriptorType(types));
+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,
 types.findDescriptorSymbol(tree.type.tsym), types),
 new Pool.MethodHandle(refKind, refSym, types),
 MethodType indyType = new MethodType(indy_args_types.toList(),
 tree.type,
 List.<Type>nil(),
 syms.methodClass);
-Name metafactoryName = context.needsAltMetafactory() ?
+Name metafactoryName = needsAltMetafactory ?
 names.altMetaFactory : names.metaFactory;
-if (context.needsAltMetafactory()) {
+if (needsAltMetafactory) {
 ListBuffer<Object> markers = ListBuffer.lb();
-for (Type t : tree.targets.tail) {
+for (Symbol t : tree.targets.tail) {
-if (t.tsym != syms.serializableType.tsym) {
+if (t != syms.serializableType.tsym) {
-markers.append(t.tsym);
+markers.append(t);
 }
 }
-int flags = context.isSerializable() ? FLAG_SERIALIZABLE : 0;
+int flags = isSerializable? FLAG_SERIALIZABLE : 0;
 boolean hasMarkers = markers.nonEmpty();
-boolean hasBridges = context.bridges.nonEmpty();
+flags |= hasMarkers ? FLAG_MARKERS : 0;
-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 (hasBridges) {
+if (isSerializable) {
-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);
 }
 }
 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 (Type target : tree.targets) {
+for (Symbol target : tree.targets) {
-if (types.asSuper(target, syms.serializableType.tsym) != null) {
+if (types.asSuper(target.type, syms.serializableType.tsym) != null) {
 return true;
 }
 }
 return false;
 }
 generatedLambdaSig(),
 TreeInfo.types(syntheticParams));
 }
 Type generatedLambdaSig() {
-return types.erasure(tree.getDescriptorType(types));
+return types.erasure(tree.descriptorType);
 }
 }
 /**
 * 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.tsym).type);
+return types.erasure(types.findDescriptorSymbol(tree.targets.head).type);
 }
 }
 }
 // </editor-fold>

Mercurial > jdk8-mips64-public > langtools / file comparison

comparison: src/share/classes/com/sun/tools/javac/comp/LambdaToMethod.java

src/share/classes/com/sun/tools/javac/comp/LambdaToMethod.java