8335159: Move method reference to lambda desugaring before Lower

8336320: NullPointerException: Cannot invoke Type.getTag because type is null after JDK-8334037

Reviewed-by: jlahoda, vromero

Author: mcimadamore

src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Lower.java

@@ -29,7 +29,6 @@
 import java.util.stream.Collectors;
 
 import com.sun.source.tree.LambdaExpressionTree.BodyKind;
-import com.sun.source.tree.MemberReferenceTree.ReferenceMode;
 import com.sun.tools.javac.code.*;
 import com.sun.tools.javac.code.Kinds.KindSelector;
 import com.sun.tools.javac.code.Scope.WriteableScope;
@@ -39,7 +38,6 @@
 import com.sun.tools.javac.resources.CompilerProperties.Fragments;
 import com.sun.tools.javac.resources.CompilerProperties.Notes;
 import com.sun.tools.javac.tree.*;
-import com.sun.tools.javac.tree.JCTree.JCMemberReference.ReferenceKind;
 import com.sun.tools.javac.util.*;
 import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;
 import com.sun.tools.javac.util.List;
@@ -67,8 +65,6 @@
 import static com.sun.tools.javac.tree.JCTree.JCOperatorExpression.OperandPos.LEFT;
 import com.sun.tools.javac.tree.JCTree.JCSwitchExpression;
 
-import javax.lang.model.type.TypeKind;
-
 import static com.sun.tools.javac.tree.JCTree.Tag.*;
 
 /** This pass translates away some syntactic sugar: inner classes,
@@ -3903,337 +3899,6 @@ public void visitLambda(JCLambda tree) {
         result = tree;
     }
 
-    @Override
-    public void visitReference(JCMemberReference tree) {
-        if (needsConversionToLambda(tree)) {
-            // Convert to a lambda, and process as such
-            MemberReferenceToLambda conv = new MemberReferenceToLambda(tree);
-            result = translate(conv.lambda());
-        } else {
-            super.visitReference(tree);
-        }
-    }
-    // where
-        boolean needsVarArgsConversion(JCMemberReference tree) {
-            return tree.varargsElement != null;
-        }
-
-        /**
-         * @return Is this an array operation like clone()
-         */
-        boolean isArrayOp(JCMemberReference tree) {
-            return tree.sym.owner == syms.arrayClass;
-        }
-
-        boolean receiverAccessible(JCMemberReference tree) {
-            //hack needed to workaround 292 bug (7087658)
-            //when 292 issue is fixed we should remove this and change the backend
-            //code to always generate a method handle to an accessible method
-            return tree.ownerAccessible;
-        }
-
-        /**
-         * Erasure destroys the implementation parameter subtype
-         * relationship for intersection types.
-         * Have similar problems for union types too.
-         */
-        boolean interfaceParameterIsIntersectionOrUnionType(JCMemberReference tree) {
-            List<Type> tl = tree.getDescriptorType(types).getParameterTypes();
-            for (; tl.nonEmpty(); tl = tl.tail) {
-                Type pt = tl.head;
-                if (isIntersectionOrUnionType(pt))
-                    return true;
-            }
-            return false;
-        }
-
-        boolean isIntersectionOrUnionType(Type t) {
-            switch (t.getKind()) {
-                case INTERSECTION:
-                case UNION:
-                    return true;
-                case TYPEVAR:
-                    TypeVar tv = (TypeVar) t;
-                    return isIntersectionOrUnionType(tv.getUpperBound());
-            }
-            return false;
-        }
-
-        private boolean isProtectedInSuperClassOfEnclosingClassInOtherPackage(Symbol targetReference,
-                                                                              Symbol currentClass) {
-            return ((targetReference.flags() & PROTECTED) != 0 &&
-                    targetReference.packge() != currentClass.packge());
-        }
-
-        /**
-         * This method should be called only when target release <= 14
-         * where LambdaMetaFactory does not spin nestmate classes.
-         *
-         * This method should be removed when --release 14 is not supported.
-         */
-        boolean isPrivateInOtherClass(JCMemberReference tree) {
-            assert !target.runtimeUseNestAccess();
-            return  (tree.sym.flags() & PRIVATE) != 0 &&
-                    !types.isSameType(
-                            types.erasure(tree.sym.enclClass().asType()),
-                            types.erasure(currentClass.asType()));
-        }
-
-        /**
-         * Does this reference need to be converted to a lambda
-         * (i.e. var args need to be expanded or "super" is used)
-         */
-        boolean needsConversionToLambda(JCMemberReference tree) {
-            return interfaceParameterIsIntersectionOrUnionType(tree) ||
-                    tree.hasKind(ReferenceKind.SUPER) ||
-                    needsVarArgsConversion(tree) ||
-                    isArrayOp(tree) ||
-                    (!target.runtimeUseNestAccess() && isPrivateInOtherClass(tree)) ||
-                    isProtectedInSuperClassOfEnclosingClassInOtherPackage(tree.sym, currentClass) ||
-                    !receiverAccessible(tree) ||
-                    (tree.getMode() == ReferenceMode.NEW &&
-                            tree.kind != ReferenceKind.ARRAY_CTOR &&
-                            (tree.sym.owner.isDirectlyOrIndirectlyLocal() || tree.sym.owner.isInner()));
-        }
-
-    /**
-     * Converts a method reference which cannot be used directly into a lambda
-     */
-    private class MemberReferenceToLambda {
-
-        private final JCMemberReference tree;
-        private final ListBuffer<JCExpression> args = new ListBuffer<>();
-        private final ListBuffer<JCVariableDecl> params = new ListBuffer<>();
-        private final MethodSymbol owner = new MethodSymbol(0, names.empty, Type.noType, currentClass);
-
-        private JCExpression receiverExpression = null;
-
-        MemberReferenceToLambda(JCMemberReference tree) {
-            this.tree = tree;
-        }
-
-        JCExpression lambda() {
-            int prevPos = make.pos;
-            try {
-                make.at(tree);
-
-                //body generation - this can be either a method call or a
-                //new instance creation expression, depending on the member reference kind
-                VarSymbol rcvr = addParametersReturnReceiver();
-                JCExpression expr = (tree.getMode() == ReferenceMode.INVOKE)
-                        ? expressionInvoke(rcvr)
-                        : expressionNew();
-
-                JCLambda slam = make.Lambda(params.toList(), expr);
-                slam.target = tree.target;
-                slam.type = tree.type;
-                slam.pos = tree.pos;
-                slam.wasMethodReference = true;
-                if (receiverExpression != null) {
-                    // use a let expression so that the receiver expression is evaluated eagerly
-                    return make.at(tree.pos).LetExpr(
-                            make.VarDef(rcvr, translate(receiverExpression)), slam).setType(tree.type);
-                } else {
-                    return slam;
-                }
-            } finally {
-                make.at(prevPos);
-            }
-        }
-
-        /**
-         * Generate the parameter list for the converted member reference.
-         *
-         * @return The receiver variable symbol, if any
-         */
-        VarSymbol addParametersReturnReceiver() {
-            Type samDesc = types.erasure(types.findDescriptorSymbol(tree.target.tsym).type);
-            List<Type> samPTypes = samDesc.getParameterTypes();
-            List<Type> descPTypes = tree.getDescriptorType(types).getParameterTypes();
-
-            // Determine the receiver, if any
-            VarSymbol rcvr;
-            switch (tree.kind) {
-                case BOUND:
-                    // The receiver is explicit in the method reference
-                    rcvr = new VarSymbol(SYNTHETIC, names.fromString("rec$"), tree.getQualifierExpression().type, owner);
-                    rcvr.pos = tree.pos;
-                    receiverExpression = attr.makeNullCheck(tree.getQualifierExpression());
-                    break;
-                case UNBOUND:
-                    // The receiver is the first parameter, extract it and
-                    // adjust the SAM and unerased type lists accordingly
-                    rcvr = addParameter("rec$", samDesc.getParameterTypes().head, false);
-                    samPTypes = samPTypes.tail;
-                    descPTypes = descPTypes.tail;
-                    break;
-                default:
-                    rcvr = null;
-                    break;
-            }
-            List<Type> implPTypes = tree.sym.type.getParameterTypes();
-            int implSize = implPTypes.size();
-            int samSize = samPTypes.size();
-            // Last parameter to copy from referenced method, exclude final var args
-            int last = needsVarArgsConversion(tree) ? implSize - 1 : implSize;
-
-            // Failsafe -- assure match-up
-            boolean checkForIntersection = tree.varargsElement != null || implSize == descPTypes.size();
-
-            // Use parameter types of the implementation method unless the unerased
-            // SAM parameter type is an intersection type, in that case use the
-            // erased SAM parameter type so that the supertype relationship
-            // the implementation method parameters is not obscured.
-            // Note: in this loop, the lists implPTypes, samPTypes, and descPTypes
-            // are used as pointers to the current parameter type information
-            // and are thus not usable afterwards.
-            for (int i = 0; implPTypes.nonEmpty() && i < last; ++i) {
-                // By default use the implementation method parameter type
-                Type parmType = implPTypes.head;
-                if (checkForIntersection) {
-                    if (descPTypes.head.getKind() == TypeKind.INTERSECTION) {
-                        parmType = samPTypes.head;
-                    }
-                    // If the unerased parameter type is a type variable whose
-                    // bound is an intersection (eg. <T extends A & B>) then
-                    // use the SAM parameter type
-                    if (descPTypes.head.getKind() == TypeKind.TYPEVAR) {
-                        TypeVar tv = (TypeVar) descPTypes.head;
-                        if (tv.getUpperBound().getKind() == TypeKind.INTERSECTION) {
-                            parmType = samPTypes.head;
-                        }
-                    }
-                }
-                addParameter("x$" + i, parmType, true);
-
-                // Advance to the next parameter
-                implPTypes = implPTypes.tail;
-                samPTypes = samPTypes.tail;
-                descPTypes = descPTypes.tail;
-            }
-            // Flatten out the var args
-            for (int i = last; i < samSize; ++i) {
-                addParameter("xva$" + i, tree.varargsElement, true);
-            }
-
-            return rcvr;
-        }
-
-        private JCExpression makeReceiver(VarSymbol rcvr) {
-            if (rcvr == null) return null;
-            JCExpression rcvrExpr = make.Ident(rcvr);
-            boolean protAccess =
-                    isProtectedInSuperClassOfEnclosingClassInOtherPackage(tree.sym, currentClass);
-            Type rcvrType = tree.ownerAccessible && !protAccess ? tree.sym.enclClass().type
-                    : tree.expr.type;
-            if (rcvrType == syms.arrayClass.type) {
-                // Map the receiver type to the actually type, not just "array"
-                rcvrType = tree.getQualifierExpression().type;
-            }
-            if (!rcvr.type.tsym.isSubClass(rcvrType.tsym, types)) {
-                rcvrExpr = make.TypeCast(make.Type(rcvrType), rcvrExpr).setType(rcvrType);
-            }
-            return rcvrExpr;
-        }
-
-        /**
-         * determine the receiver of the method call - the receiver can
-         * be a type qualifier, the synthetic receiver parameter or 'super'.
-         */
-        private JCExpression expressionInvoke(VarSymbol rcvr) {
-            JCExpression qualifier =
-                    (rcvr != null) ?
-                            makeReceiver(rcvr) :
-                            tree.getQualifierExpression();
-
-            //create the qualifier expression
-            JCFieldAccess select = make.Select(qualifier, tree.sym.name);
-            select.sym = tree.sym;
-            select.type = tree.sym.erasure(types);
-
-            //create the method call expression
-            JCExpression apply = make.Apply(List.nil(), select,
-                            convertArgs(tree.sym, args.toList(), tree.varargsElement)).
-                    setType(tree.sym.erasure(types).getReturnType());
-
-            apply = transTypes.coerce(attrEnv, apply,
-                    types.erasure(tree.referentType.getReturnType()));
-
-            setVarargsIfNeeded(apply, tree.varargsElement);
-            return apply;
-        }
-
-        /**
-         * Lambda body to use for a 'new'.
-         */
-        private JCExpression expressionNew() {
-            if (tree.kind == ReferenceKind.ARRAY_CTOR) {
-                //create the array creation expression
-                JCNewArray newArr = make.NewArray(
-                        make.Type(types.elemtype(tree.getQualifierExpression().type)),
-                        List.of(make.Ident(params.first())),
-                        null);
-                newArr.type = tree.getQualifierExpression().type;
-                return newArr;
-            } else {
-                //create the instance creation expression
-                //note that method reference syntax does not allow an explicit
-                //enclosing class (so the enclosing class is null)
-                // but this may need to be patched up later with the proxy for the outer this
-                JCNewClass newClass = make.NewClass(null,
-                        List.nil(),
-                        make.Type(tree.getQualifierExpression().type),
-                        convertArgs(tree.sym, args.toList(), tree.varargsElement),
-                        null);
-                newClass.constructor = tree.sym;
-                newClass.constructorType = tree.sym.erasure(types);
-                newClass.type = tree.getQualifierExpression().type;
-                setVarargsIfNeeded(newClass, tree.varargsElement);
-                return newClass;
-            }
-        }
-
-        private VarSymbol addParameter(String name, Type p, boolean genArg) {
-            VarSymbol vsym = new VarSymbol(PARAMETER | SYNTHETIC, names.fromString(name), p, owner);
-            vsym.pos = tree.pos;
-            params.append(make.VarDef(vsym, null));
-            if (genArg) {
-                args.append(make.Ident(vsym));
-            }
-            return vsym;
-        }
-    }
-
-    /**
-     * Convert method/constructor arguments by inserting appropriate cast
-     * as required by type-erasure - this is needed when bridging a lambda/method
-     * reference, as the bridged signature might require downcast to be compatible
-     * with the generated signature.
-     */
-    private List<JCExpression> convertArgs(Symbol meth, List<JCExpression> args, Type varargsElement) {
-        Assert.check(meth.kind == MTH);
-        List<Type> formals = types.erasure(meth.type).getParameterTypes();
-        if (varargsElement != null) {
-            Assert.check((meth.flags() & VARARGS) != 0);
-        }
-        return transTypes.translateArgs(args, formals, varargsElement, attrEnv);
-    }
-
-    /**
-     * Set varargsElement field on a given tree (must be either a new class tree
-     * or a method call tree)
-     */
-    private void setVarargsIfNeeded(JCTree tree, Type varargsElement) {
-        if (varargsElement != null) {
-            switch (tree.getTag()) {
-                case APPLY: ((JCMethodInvocation)tree).varargsElement = varargsElement; break;
-                case NEWCLASS: ((JCNewClass)tree).varargsElement = varargsElement; break;
-                case TYPECAST: setVarargsIfNeeded(((JCTypeCast) tree).expr, varargsElement); break;
-                default: throw new AssertionError();
-            }
-        }
-    }
-
     public void visitSwitch(JCSwitch tree) {
         List<JCCase> cases = tree.patternSwitch ? addDefaultIfNeeded(tree.patternSwitch,
                                                                      tree.wasEnumSelector,