changeset 3030:286fc9270404

8078093: Severe compiler performance regression Java 7 to 8 for nested method invocations Summary: Add infrastructure to avoid combinatorial explosion of method argument attributions Reviewed-by: jlahoda, vromero, dlsmith
author mcimadamore
date Tue, 15 Sep 2015 13:43:44 +0100
parents 8fa8045bbd4e
children 6b3b94a2ebca
files src/jdk.compiler/share/classes/com/sun/tools/javac/code/Types.java src/jdk.compiler/share/classes/com/sun/tools/javac/comp/ArgumentAttr.java src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Attr.java src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Check.java src/jdk.compiler/share/classes/com/sun/tools/javac/comp/DeferredAttr.java src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Infer.java src/jdk.compiler/share/classes/com/sun/tools/javac/comp/InferenceContext.java src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Resolve.java test/tools/javac/generics/wildcards/neg/Readonly.out test/tools/javac/lambda/8019480/T8019480.out test/tools/javac/lambda/speculative/InferStrict.java test/tools/javac/lambda/speculative/InferWeak.java test/tools/javac/lambda/speculative/NestedLambdaGenerics.java test/tools/javac/lambda/speculative/NestedLambdaNoGenerics.java test/tools/javac/lambda/speculative/T8055984.java test/tools/javac/lambda/speculative/T8077247.java test/tools/javac/lambda/speculative/T8078093.java
diffstat 17 files changed, 1454 insertions(+), 480 deletions(-) [+]
line wrap: on
line diff
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/code/Types.java	Mon Sep 14 11:26:14 2015 +0100
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/code/Types.java	Tue Sep 15 13:43:44 2015 +0100
@@ -3152,10 +3152,20 @@
                 throw new IllegalArgumentException("Not a method type: " + t);
             }
             public Type visitMethodType(MethodType t, Type newReturn) {
-                return new MethodType(t.argtypes, newReturn, t.thrown, t.tsym);
+                return new MethodType(t.argtypes, newReturn, t.thrown, t.tsym) {
+                    @Override
+                    public Type baseType() {
+                        return t;
+                    }
+                };
             }
             public Type visitForAll(ForAll t, Type newReturn) {
-                return new ForAll(t.tvars, t.qtype.accept(this, newReturn));
+                return new ForAll(t.tvars, t.qtype.accept(this, newReturn)) {
+                    @Override
+                    public Type baseType() {
+                        return t;
+                    }
+                };
             }
         };
 
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/ArgumentAttr.java	Tue Sep 15 13:43:44 2015 +0100
@@ -0,0 +1,679 @@
+/*
+ * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package com.sun.tools.javac.comp;
+
+import com.sun.source.tree.LambdaExpressionTree.BodyKind;
+import com.sun.tools.javac.code.Flags;
+import com.sun.tools.javac.code.Symbol;
+import com.sun.tools.javac.code.Symtab;
+import com.sun.tools.javac.code.Type;
+import com.sun.tools.javac.code.Types.FunctionDescriptorLookupError;
+import com.sun.tools.javac.comp.Attr.ResultInfo;
+import com.sun.tools.javac.comp.Attr.TargetInfo;
+import com.sun.tools.javac.comp.Check.CheckContext;
+import com.sun.tools.javac.comp.DeferredAttr.AttrMode;
+import com.sun.tools.javac.comp.DeferredAttr.DeferredAttrContext;
+import com.sun.tools.javac.comp.DeferredAttr.DeferredType;
+import com.sun.tools.javac.comp.DeferredAttr.DeferredTypeCompleter;
+import com.sun.tools.javac.comp.DeferredAttr.LambdaReturnScanner;
+import com.sun.tools.javac.comp.Infer.PartiallyInferredMethodType;
+import com.sun.tools.javac.comp.Resolve.MethodResolutionPhase;
+import com.sun.tools.javac.tree.JCTree;
+import com.sun.tools.javac.tree.JCTree.JCConditional;
+import com.sun.tools.javac.tree.JCTree.JCExpression;
+import com.sun.tools.javac.tree.JCTree.JCLambda;
+import com.sun.tools.javac.tree.JCTree.JCLambda.ParameterKind;
+import com.sun.tools.javac.tree.JCTree.JCMemberReference;
+import com.sun.tools.javac.tree.JCTree.JCMethodInvocation;
+import com.sun.tools.javac.tree.JCTree.JCNewClass;
+import com.sun.tools.javac.tree.JCTree.JCParens;
+import com.sun.tools.javac.tree.JCTree.JCReturn;
+import com.sun.tools.javac.tree.TreeCopier;
+import com.sun.tools.javac.tree.TreeInfo;
+import com.sun.tools.javac.util.Assert;
+import com.sun.tools.javac.util.Context;
+import com.sun.tools.javac.util.DiagnosticSource;
+import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;
+import com.sun.tools.javac.util.List;
+import com.sun.tools.javac.util.ListBuffer;
+import com.sun.tools.javac.util.Log;
+
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Optional;
+import java.util.function.Function;
+import java.util.function.Supplier;
+
+import static com.sun.tools.javac.code.TypeTag.DEFERRED;
+import static com.sun.tools.javac.code.TypeTag.FORALL;
+import static com.sun.tools.javac.code.TypeTag.METHOD;
+import static com.sun.tools.javac.code.TypeTag.VOID;
+
+/**
+ * This class performs attribution of method/constructor arguments when target-typing is enabled
+ * (source >= 8); for each argument that is potentially a poly expression, this class builds
+ * a rich representation (see {@link ArgumentType} which can then be used for performing fast overload
+ * checks without requiring multiple attribution passes over the same code.
+ *
+ * The attribution strategy for a given method/constructor argument A is as follows:
+ *
+ * - if A is potentially a poly expression (i.e. diamond instance creation expression), a speculative
+ * pass over A is performed; the results of such speculative attribution are then saved in a special
+ * type, so that enclosing overload resolution can be carried by simply checking compatibility against the
+ * type determined during this speculative pass.
+ *
+ * - if A is a standalone expression, regular atributtion takes place.
+ *
+ * To minimize the speculative work, a cache is used, so that already computed argument types
+ * associated with a given unique source location are never recomputed multiple times.
+ */
+public class ArgumentAttr extends JCTree.Visitor {
+
+    protected static final Context.Key<ArgumentAttr> methodAttrKey = new Context.Key<>();
+
+    private final DeferredAttr deferredAttr;
+    private final Attr attr;
+    private final Symtab syms;
+    private final Log log;
+
+    /** Attribution environment to be used. */
+    private Env<AttrContext> env;
+
+    /** Result of method attribution. */
+    private Type result;
+
+    /** Cache for argument types; behavior is influences by the currrently selected cache policy. */
+    Map<UniquePos, ArgumentType<?>> argumentTypeCache = new LinkedHashMap<>();
+
+    /** Cache policy: should argument types be cached? */
+    private CachePolicy cachePolicy = CachePolicy.CACHE;
+
+    public static ArgumentAttr instance(Context context) {
+        ArgumentAttr instance = context.get(methodAttrKey);
+        if (instance == null)
+            instance = new ArgumentAttr(context);
+        return instance;
+    }
+
+    protected ArgumentAttr(Context context) {
+        context.put(methodAttrKey, this);
+        deferredAttr = DeferredAttr.instance(context);
+        attr = Attr.instance(context);
+        syms = Symtab.instance(context);
+        log = Log.instance(context);
+    }
+
+    /**
+     * Set the results of method attribution.
+     */
+    void setResult(JCExpression tree, Type type) {
+        result = type;
+        if (env.info.isSpeculative) {
+            //if we are in a speculative branch we can save the type in the tree itself
+            //as there's no risk of polluting the original tree.
+            tree.type = result;
+        }
+    }
+
+    /**
+     * Checks a type in the speculative tree against a given result; the type can be either a plain
+     * type or an argument type,in which case a more complex check is required.
+     */
+    Type checkSpeculative(JCExpression expr, ResultInfo resultInfo) {
+        return checkSpeculative(expr, expr.type, resultInfo);
+    }
+
+    /**
+     * Checks a type in the speculative tree against a given result; the type can be either a plain
+     * type or an argument type,in which case a more complex check is required.
+     */
+    Type checkSpeculative(DiagnosticPosition pos, Type t, ResultInfo resultInfo) {
+        if (t.hasTag(DEFERRED)) {
+            return ((DeferredType)t).check(resultInfo);
+        } else {
+            return resultInfo.check(pos, t);
+        }
+    }
+
+    /**
+     * Sets given ache policy and returns current policy.
+     */
+    CachePolicy withCachePolicy(CachePolicy newPolicy) {
+        CachePolicy oldPolicy = this.cachePolicy;
+        this.cachePolicy = newPolicy;
+        return oldPolicy;
+    }
+
+    /**
+     * Main entry point for attributing an argument with given tree and attribution environment.
+     */
+    Type attribArg(JCTree tree, Env<AttrContext> env) {
+        Env<AttrContext> prevEnv = this.env;
+        try {
+            this.env = env;
+            tree.accept(this);
+            return result;
+        } finally {
+            this.env = prevEnv;
+        }
+    }
+
+    @Override
+    public void visitTree(JCTree that) {
+        //delegates to Attr
+        that.accept(attr);
+        result = attr.result;
+    }
+
+    /**
+     * Process a method argument; this method takes care of performing a speculative pass over the
+     * argument tree and calling a well-defined entry point to build the argument type associated
+     * with such tree.
+     */
+    @SuppressWarnings("unchecked")
+    <T extends JCExpression, Z extends ArgumentType<T>> void processArg(T that, Function<T, Z> argumentTypeFactory) {
+        UniquePos pos = new UniquePos(that);
+        processArg(that, () -> {
+            T speculativeTree = (T)deferredAttr.attribSpeculative(that, env, attr.new MethodAttrInfo() {
+                @Override
+                protected void attr(JCTree tree, Env<AttrContext> env) {
+                    //avoid speculative attribution loops
+                    if (!new UniquePos(tree).equals(pos)) {
+                        super.attr(tree, env);
+                    } else {
+                        visitTree(tree);
+                    }
+                }
+            });
+            return argumentTypeFactory.apply(speculativeTree);
+        });
+    }
+
+    /**
+     * Process a method argument; this method allows the caller to specify a custom speculative attribution
+     * logic (this is used e.g. for lambdas).
+     */
+    @SuppressWarnings("unchecked")
+    <T extends JCExpression, Z extends ArgumentType<T>> void processArg(T that, Supplier<Z> argumentTypeFactory) {
+        UniquePos pos = new UniquePos(that);
+        Z cached = (Z)argumentTypeCache.get(pos);
+        if (cached != null) {
+            //dup existing speculative type
+            setResult(that, cached.dup(that, env));
+        } else {
+            Z res = argumentTypeFactory.get();
+            if (cachePolicy == CachePolicy.CACHE) {
+                argumentTypeCache.put(pos, res);
+            }
+            setResult(that, res);
+        }
+    }
+
+    @Override
+    public void visitParens(JCParens that) {
+        processArg(that, speculativeTree -> new ParensType(that, env, speculativeTree));
+    }
+
+    @Override
+    public void visitConditional(JCConditional that) {
+        processArg(that, speculativeTree -> new ConditionalType(that, env, speculativeTree));
+    }
+
+    @Override
+    public void visitReference(JCMemberReference tree) {
+        //perform arity-based check
+        Env<AttrContext> localEnv = env.dup(tree);
+        JCExpression exprTree = (JCExpression)deferredAttr.attribSpeculative(tree.getQualifierExpression(), localEnv,
+                attr.memberReferenceQualifierResult(tree));
+        JCMemberReference mref2 = new TreeCopier<Void>(attr.make).copy(tree);
+        mref2.expr = exprTree;
+        Symbol res =
+                attr.rs.getMemberReference(tree, localEnv, mref2,
+                        exprTree.type, tree.name);
+        if (!res.kind.isResolutionError()) {
+            tree.sym = res;
+        }
+        if (res.kind.isResolutionTargetError() ||
+                res.type != null && res.type.hasTag(FORALL) ||
+                (res.flags() & Flags.VARARGS) != 0 ||
+                (TreeInfo.isStaticSelector(exprTree, tree.name.table.names) &&
+                exprTree.type.isRaw())) {
+            tree.overloadKind = JCMemberReference.OverloadKind.OVERLOADED;
+        } else {
+            tree.overloadKind = JCMemberReference.OverloadKind.UNOVERLOADED;
+        }
+        //return a plain old deferred type for this
+        setResult(tree, deferredAttr.new DeferredType(tree, env));
+    }
+
+    @Override
+    public void visitLambda(JCLambda that) {
+        if (that.paramKind == ParameterKind.EXPLICIT) {
+            //if lambda is explicit, we can save info in the corresponding argument type
+            processArg(that, () -> {
+                JCLambda speculativeLambda =
+                        deferredAttr.attribSpeculativeLambda(that, env, attr.methodAttrInfo);
+                return new ExplicitLambdaType(that, env, speculativeLambda);
+            });
+        } else {
+            //otherwise just use a deferred type
+            setResult(that, deferredAttr.new DeferredType(that, env));
+        }
+    }
+
+    @Override
+    public void visitApply(JCMethodInvocation that) {
+        if (that.getTypeArguments().isEmpty()) {
+            processArg(that, speculativeTree -> new ResolvedMethodType(that, env, speculativeTree));
+        } else {
+            //not a poly expression, just call Attr
+            setResult(that, attr.attribTree(that, env, attr.unknownExprInfo));
+        }
+    }
+
+    @Override
+    public void visitNewClass(JCNewClass that) {
+        if (TreeInfo.isDiamond(that)) {
+            processArg(that, speculativeTree -> new ResolvedConstructorType(that, env, speculativeTree));
+        } else {
+            //not a poly expression, just call Attr
+            setResult(that, attr.attribTree(that, env, attr.unknownExprInfo));
+        }
+    }
+
+    /**
+     * An argument type is similar to a plain deferred type; the most important difference is that
+     * the completion logic associated with argument types allows speculative attribution to be skipped
+     * during overload resolution - that is, an argument type always has enough information to
+     * perform an overload check without the need of calling back to Attr. This extra information
+     * is typically stored in the form of a speculative tree.
+     */
+    abstract class ArgumentType<T extends JCExpression> extends DeferredType implements DeferredTypeCompleter {
+
+        /** The speculative tree carrying type information. */
+        T speculativeTree;
+
+        /** Types associated with this argument (one type per possible target result). */
+        Map<ResultInfo, Type> speculativeTypes;
+
+        public ArgumentType(JCExpression tree, Env<AttrContext> env, T speculativeTree, Map<ResultInfo, Type> speculativeTypes) {
+            deferredAttr.super(tree, env);
+            this.speculativeTree = speculativeTree;
+            this.speculativeTypes = speculativeTypes;
+        }
+
+        @Override
+        final DeferredTypeCompleter completer() {
+            return this;
+        }
+
+        @Override
+        final public Type complete(DeferredType dt, ResultInfo resultInfo, DeferredAttrContext deferredAttrContext) {
+            Assert.check(dt == this);
+            if (deferredAttrContext.mode == AttrMode.SPECULATIVE) {
+                Type t = (resultInfo.pt == Type.recoveryType) ?
+                        deferredAttr.basicCompleter.complete(dt, resultInfo, deferredAttrContext) :
+                        overloadCheck(resultInfo, deferredAttrContext);
+                speculativeTypes.put(resultInfo, t);
+                return t;
+            } else {
+                if (!env.info.isSpeculative && cachePolicy == CachePolicy.CACHE) {
+                    argumentTypeCache.remove(new UniquePos(dt.tree));
+                }
+                return deferredAttr.basicCompleter.complete(dt, resultInfo, deferredAttrContext);
+            }
+        }
+
+        @Override
+        Type speculativeType(Symbol msym, MethodResolutionPhase phase) {
+            for (Map.Entry<ResultInfo, Type> _entry : speculativeTypes.entrySet()) {
+                DeferredAttrContext deferredAttrContext = _entry.getKey().checkContext.deferredAttrContext();
+                if (deferredAttrContext.phase == phase && deferredAttrContext.msym == msym) {
+                    return _entry.getValue();
+                }
+            }
+            return Type.noType;
+        }
+
+        @Override
+        JCTree speculativeTree(DeferredAttrContext deferredAttrContext) {
+            return speculativeTree;
+        }
+
+        /**
+         * Performs an overload check against a given target result.
+         */
+        abstract Type overloadCheck(ResultInfo resultInfo, DeferredAttrContext deferredAttrContext);
+
+        /**
+         * Creates a copy of this argument type with given tree and environment.
+         */
+        abstract ArgumentType<T> dup(T tree, Env<AttrContext> env);
+    }
+
+    /**
+     * Argument type for parenthesized expression.
+     */
+    class ParensType extends ArgumentType<JCParens> {
+        ParensType(JCExpression tree, Env<AttrContext> env, JCParens speculativeParens) {
+            this(tree, env, speculativeParens, new HashMap<>());
+        }
+
+        ParensType(JCExpression tree, Env<AttrContext> env, JCParens speculativeParens, Map<ResultInfo, Type> speculativeTypes) {
+           super(tree, env, speculativeParens, speculativeTypes);
+        }
+
+        @Override
+        Type overloadCheck(ResultInfo resultInfo, DeferredAttrContext deferredAttrContext) {
+            return checkSpeculative(speculativeTree.expr, resultInfo);
+        }
+
+        @Override
+        ArgumentType<JCParens> dup(JCParens tree, Env<AttrContext> env) {
+            return new ParensType(tree, env, speculativeTree, speculativeTypes);
+        }
+    }
+
+    /**
+     * Argument type for conditionals.
+     */
+    class ConditionalType extends ArgumentType<JCConditional> {
+        ConditionalType(JCExpression tree, Env<AttrContext> env, JCConditional speculativeCond) {
+            this(tree, env, speculativeCond, new HashMap<>());
+        }
+
+        ConditionalType(JCExpression tree, Env<AttrContext> env, JCConditional speculativeCond, Map<ResultInfo, Type> speculativeTypes) {
+           super(tree, env, speculativeCond, speculativeTypes);
+        }
+
+        @Override
+        Type overloadCheck(ResultInfo resultInfo, DeferredAttrContext deferredAttrContext) {
+            ResultInfo localInfo = resultInfo.dup(attr.conditionalContext(resultInfo.checkContext));
+            if (speculativeTree.isStandalone()) {
+                return localInfo.check(speculativeTree, speculativeTree.type);
+            } else if (resultInfo.pt.hasTag(VOID)) {
+                //this means we are returning a poly conditional from void-compatible lambda expression
+                resultInfo.checkContext.report(tree, attr.diags.fragment("conditional.target.cant.be.void"));
+                return attr.types.createErrorType(resultInfo.pt);
+            } else {
+                //poly
+                checkSpeculative(speculativeTree.truepart, localInfo);
+                checkSpeculative(speculativeTree.falsepart, localInfo);
+                return localInfo.pt;
+            }
+        }
+
+        @Override
+        ArgumentType<JCConditional> dup(JCConditional tree, Env<AttrContext> env) {
+            return new ConditionalType(tree, env, speculativeTree, speculativeTypes);
+        }
+    }
+
+    /**
+     * Argument type for explicit lambdas.
+     */
+    class ExplicitLambdaType extends ArgumentType<JCLambda> {
+
+        /** List of argument types (lazily populated). */
+        Optional<List<Type>> argtypes = Optional.empty();
+
+        /** List of return expressions (lazily populated). */
+        Optional<List<JCReturn>> returnExpressions = Optional.empty();
+
+        ExplicitLambdaType(JCLambda originalLambda, Env<AttrContext> env, JCLambda speculativeLambda) {
+            this(originalLambda, env, speculativeLambda, new HashMap<>());
+        }
+
+        ExplicitLambdaType(JCLambda originalLambda, Env<AttrContext> env, JCLambda speculativeLambda, Map<ResultInfo, Type> speculativeTypes) {
+            super(originalLambda, env, speculativeLambda, speculativeTypes);
+        }
+
+        /** Compute argument types (if needed). */
+        List<Type> argtypes() {
+            return argtypes.orElseGet(() -> {
+                List<Type> res = TreeInfo.types(speculativeTree.params);
+                argtypes = Optional.of(res);
+                return res;
+            });
+        }
+
+        /** Compute return expressions (if needed). */
+        List<JCReturn> returnExpressions() {
+            return returnExpressions.orElseGet(() -> {
+                final List<JCReturn> res;
+                if (speculativeTree.getBodyKind() == BodyKind.EXPRESSION) {
+                    res = List.of(attr.make.Return((JCExpression)speculativeTree.body));
+                } else {
+                    ListBuffer<JCReturn> returnExpressions = new ListBuffer<>();
+                    new LambdaReturnScanner() {
+                        @Override
+                        public void visitReturn(JCReturn tree) {
+                            returnExpressions.add(tree);
+                        }
+                    }.scan(speculativeTree.body);
+                    res = returnExpressions.toList();
+                }
+                returnExpressions = Optional.of(res);
+                return res;
+            });
+        }
+
+        @Override
+        Type overloadCheck(ResultInfo resultInfo, DeferredAttrContext deferredAttrContext) {
+            try {
+                //compute target-type; this logic could be shared with Attr
+                TargetInfo targetInfo = attr.getTargetInfo(speculativeTree, resultInfo, argtypes());
+                Type lambdaType = targetInfo.descriptor;
+                Type currentTarget = targetInfo.target;
+                //check compatibility
+                checkLambdaCompatible(lambdaType, resultInfo);
+                return currentTarget;
+            } catch (FunctionDescriptorLookupError ex) {
+                resultInfo.checkContext.report(null, ex.getDiagnostic());
+                return null; //cannot get here
+            }
+        }
+
+        /** Check lambda against given target result */
+        private void checkLambdaCompatible(Type descriptor, ResultInfo resultInfo) {
+            CheckContext checkContext = resultInfo.checkContext;
+            ResultInfo bodyResultInfo = attr.lambdaBodyResult(speculativeTree, descriptor, resultInfo);
+            for (JCReturn ret : returnExpressions()) {
+                Type t = getReturnType(ret);
+                if (speculativeTree.getBodyKind() == BodyKind.EXPRESSION || !t.hasTag(VOID)) {
+                    checkSpeculative(ret.expr, t, bodyResultInfo);
+                }
+            }
+
+            attr.checkLambdaCompatible(speculativeTree, descriptor, checkContext);
+        }
+
+        /** Get the type associated with given return expression. */
+        Type getReturnType(JCReturn ret) {
+            if (ret.expr == null) {
+                return syms.voidType;
+            } else {
+                return ret.expr.type;
+            }
+        }
+
+        @Override
+        ArgumentType<JCLambda> dup(JCLambda tree, Env<AttrContext> env) {
+            return new ExplicitLambdaType(tree, env, speculativeTree, speculativeTypes);
+        }
+    }
+
+    /**
+     * Argument type for methods/constructors.
+     */
+    abstract class ResolvedMemberType<E extends JCExpression> extends ArgumentType<E> {
+
+        public ResolvedMemberType(JCExpression tree, Env<AttrContext> env, E speculativeMethod, Map<ResultInfo, Type> speculativeTypes) {
+            super(tree, env, speculativeMethod, speculativeTypes);
+        }
+
+        @Override
+        Type overloadCheck(ResultInfo resultInfo, DeferredAttrContext deferredAttrContext) {
+            Type mtype = methodType();
+            ResultInfo localInfo = resultInfo(resultInfo);
+            if (mtype != null && mtype.hasTag(METHOD) && mtype.isPartial()) {
+                Type t = ((PartiallyInferredMethodType)mtype).check(localInfo);
+                if (!deferredAttrContext.inferenceContext.free(localInfo.pt)) {
+                    speculativeTypes.put(localInfo, t);
+                    return localInfo.check(tree.pos(), t);
+                } else {
+                    return t;
+                }
+            } else {
+                Type t = localInfo.check(tree.pos(), speculativeTree.type);
+                speculativeTypes.put(localInfo, t);
+                return t;
+            }
+        }
+
+        /**
+         * Get the result info to be used for performing an overload check.
+         */
+        abstract ResultInfo resultInfo(ResultInfo resultInfo);
+
+        /**
+         * Get the method type to be used for performing an overload check.
+         */
+        abstract Type methodType();
+    }
+
+    /**
+     * Argument type for methods.
+     */
+    class ResolvedMethodType extends ResolvedMemberType<JCMethodInvocation> {
+
+        public ResolvedMethodType(JCExpression tree, Env<AttrContext> env, JCMethodInvocation speculativeTree) {
+            this(tree, env, speculativeTree, new HashMap<>());
+        }
+
+        public ResolvedMethodType(JCExpression tree, Env<AttrContext> env, JCMethodInvocation speculativeTree, Map<ResultInfo, Type> speculativeTypes) {
+            super(tree, env, speculativeTree, speculativeTypes);
+        }
+
+        @Override
+        ResultInfo resultInfo(ResultInfo resultInfo) {
+            return resultInfo;
+        }
+
+        @Override
+        Type methodType() {
+            return speculativeTree.meth.type;
+        }
+
+        @Override
+        ArgumentType<JCMethodInvocation> dup(JCMethodInvocation tree, Env<AttrContext> env) {
+            return new ResolvedMethodType(tree, env, speculativeTree, speculativeTypes);
+        }
+    }
+
+    /**
+     * Argument type for constructors.
+     */
+    class ResolvedConstructorType extends ResolvedMemberType<JCNewClass> {
+
+        public ResolvedConstructorType(JCExpression tree, Env<AttrContext> env, JCNewClass speculativeTree) {
+            this(tree, env, speculativeTree, new HashMap<>());
+        }
+
+        public ResolvedConstructorType(JCExpression tree, Env<AttrContext> env, JCNewClass speculativeTree, Map<ResultInfo, Type> speculativeTypes) {
+            super(tree, env, speculativeTree, speculativeTypes);
+        }
+
+        @Override
+        ResultInfo resultInfo(ResultInfo resultInfo) {
+            return resultInfo.dup(attr.diamondContext(speculativeTree, speculativeTree.clazz.type.tsym, resultInfo.checkContext));
+        }
+
+        @Override
+        Type methodType() {
+            return (speculativeTree.constructorType != null) ?
+                    speculativeTree.constructorType.baseType() : syms.errType;
+        }
+
+        @Override
+        ArgumentType<JCNewClass> dup(JCNewClass tree, Env<AttrContext> env) {
+            return new ResolvedConstructorType(tree, env, speculativeTree, speculativeTypes);
+        }
+    }
+
+    /**
+     * An instance of this class represents a unique position in a compilation unit. A unique
+     * position is made up of (i) a unique position in a source file (char offset) and (ii)
+     * a source file info.
+     */
+    class UniquePos {
+
+        /** Char offset. */
+        int pos;
+
+        /** Source info. */
+        DiagnosticSource source;
+
+        UniquePos(JCTree tree) {
+            this.pos = tree.pos;
+            this.source = log.currentSource();
+        }
+
+        @Override
+        public int hashCode() {
+            return pos << 16 + source.hashCode();
+        }
+
+        @Override
+        public boolean equals(Object obj) {
+            if (obj instanceof UniquePos) {
+                UniquePos that = (UniquePos)obj;
+                return pos == that.pos && source == that.source;
+            } else {
+                return false;
+            }
+        }
+
+        @Override
+        public String toString() {
+            return source.getFile().getName() + " @ " + source.getLineNumber(pos);
+        }
+    }
+
+    /**
+     * Argument type caching policy.
+     */
+    enum CachePolicy {
+        /** Cache argument types. */
+        CACHE,
+        /**
+         * Don't cache argument types. This is useful when performing speculative attribution on
+         * a tree that is known to contain erroneous info.
+         */
+        NO_CACHE;
+    }
+}
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Attr.java	Mon Sep 14 11:26:14 2015 +0100
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Attr.java	Tue Sep 15 13:43:44 2015 +0100
@@ -108,6 +108,7 @@
     final TypeEnvs typeEnvs;
     final Dependencies dependencies;
     final Annotate annotate;
+    final ArgumentAttr argumentAttr;
 
     public static Attr instance(Context context) {
         Attr instance = context.get(attrKey);
@@ -142,6 +143,7 @@
         deferredLintHandler = DeferredLintHandler.instance(context);
         typeEnvs = TypeEnvs.instance(context);
         dependencies = Dependencies.instance(context);
+        argumentAttr = ArgumentAttr.instance(context);
 
         Options options = Options.instance(context);
 
@@ -160,7 +162,7 @@
         statInfo = new ResultInfo(KindSelector.NIL, Type.noType);
         varAssignmentInfo = new ResultInfo(KindSelector.ASG, Type.noType);
         unknownExprInfo = new ResultInfo(KindSelector.VAL, Type.noType);
-        unknownAnyPolyInfo = new ResultInfo(KindSelector.VAL, Infer.anyPoly);
+        methodAttrInfo = new MethodAttrInfo();
         unknownTypeInfo = new ResultInfo(KindSelector.TYP, Type.noType);
         unknownTypeExprInfo = new ResultInfo(KindSelector.VAL_TYP, Type.noType);
         recoveryInfo = new RecoveryInfo(deferredAttr.emptyDeferredAttrContext);
@@ -488,6 +490,10 @@
             this.checkMode = checkMode;
         }
 
+        protected void attr(JCTree tree, Env<AttrContext> env) {
+            tree.accept(Attr.this);
+        }
+
         protected Type check(final DiagnosticPosition pos, final Type found) {
             return chk.checkType(pos, found, pt, checkContext);
         }
@@ -522,6 +528,41 @@
         }
     }
 
+    class MethodAttrInfo extends ResultInfo {
+        public MethodAttrInfo() {
+            this(chk.basicHandler);
+        }
+
+        public MethodAttrInfo(CheckContext checkContext) {
+            super(KindSelector.VAL, Infer.anyPoly, checkContext);
+        }
+
+        @Override
+        protected void attr(JCTree tree, Env<AttrContext> env) {
+            result = argumentAttr.attribArg(tree, env);
+        }
+
+        protected ResultInfo dup(Type newPt) {
+            throw new IllegalStateException();
+        }
+
+        protected ResultInfo dup(CheckContext newContext) {
+            return new MethodAttrInfo(newContext);
+        }
+
+        protected ResultInfo dup(Type newPt, CheckContext newContext) {
+            throw new IllegalStateException();
+        }
+
+        protected ResultInfo dup(Type newPt, CheckContext newContext, CheckMode newMode) {
+            throw new IllegalStateException();
+        }
+
+        protected ResultInfo dup(CheckMode newMode) {
+            throw new IllegalStateException();
+        }
+    }
+
     class RecoveryInfo extends ResultInfo {
 
         public RecoveryInfo(final DeferredAttr.DeferredAttrContext deferredAttrContext) {
@@ -545,7 +586,7 @@
 
     final ResultInfo statInfo;
     final ResultInfo varAssignmentInfo;
-    final ResultInfo unknownAnyPolyInfo;
+    final ResultInfo methodAttrInfo;
     final ResultInfo unknownExprInfo;
     final ResultInfo unknownTypeInfo;
     final ResultInfo unknownTypeExprInfo;
@@ -588,7 +629,7 @@
         try {
             this.env = env;
             this.resultInfo = resultInfo;
-            tree.accept(this);
+            resultInfo.attr(tree, env);
             if (tree == breakTree &&
                     resultInfo.checkContext.deferredAttrContext().mode == AttrMode.CHECK) {
                 throw new BreakAttr(copyEnv(env));
@@ -684,12 +725,9 @@
     KindSelector attribArgs(KindSelector initialKind, List<JCExpression> trees, Env<AttrContext> env, ListBuffer<Type> argtypes) {
         KindSelector kind = initialKind;
         for (JCExpression arg : trees) {
-            Type argtype;
-            if (allowPoly && deferredAttr.isDeferred(env, arg)) {
-                argtype = deferredAttr.new DeferredType(arg, env);
+            Type argtype = chk.checkNonVoid(arg, attribTree(arg, env, allowPoly ? methodAttrInfo : unknownExprInfo));
+            if (argtype.hasTag(DEFERRED)) {
                 kind = KindSelector.of(KindSelector.POLY, kind);
-            } else {
-                argtype = chk.checkNonVoid(arg, attribTree(arg, env, unknownAnyPolyInfo));
             }
             argtypes.append(argtype);
         }
@@ -1426,12 +1464,12 @@
         Type condtype = attribExpr(tree.cond, env, syms.booleanType);
 
         tree.polyKind = (!allowPoly ||
-                pt().hasTag(NONE) && pt() != Type.recoveryType ||
+                pt().hasTag(NONE) && pt() != Type.recoveryType && pt() != Infer.anyPoly ||
                 isBooleanOrNumeric(env, tree)) ?
                 PolyKind.STANDALONE : PolyKind.POLY;
 
         if (tree.polyKind == PolyKind.POLY && resultInfo.pt.hasTag(VOID)) {
-            //cannot get here (i.e. it means we are returning from void method - which is already an error)
+            //this means we are returning a poly conditional from void-compatible lambda expression
             resultInfo.checkContext.report(tree, diags.fragment("conditional.target.cant.be.void"));
             result = tree.type = types.createErrorType(resultInfo.pt);
             return;
@@ -1439,15 +1477,7 @@
 
         ResultInfo condInfo = tree.polyKind == PolyKind.STANDALONE ?
                 unknownExprInfo :
-                resultInfo.dup(new Check.NestedCheckContext(resultInfo.checkContext) {
-                    //this will use enclosing check context to check compatibility of
-                    //subexpression against target type; if we are in a method check context,
-                    //depending on whether boxing is allowed, we could have incompatibilities
-                    @Override
-                    public void report(DiagnosticPosition pos, JCDiagnostic details) {
-                        enclosingContext.report(pos, diags.fragment("incompatible.type.in.conditional", details));
-                    }
-                });
+                resultInfo.dup(conditionalContext(resultInfo.checkContext));
 
         Type truetype = attribTree(tree.truepart, env, condInfo);
         Type falsetype = attribTree(tree.falsepart, env, condInfo);
@@ -1506,6 +1536,18 @@
                 }
             };
 
+        CheckContext conditionalContext(CheckContext checkContext) {
+            return new Check.NestedCheckContext(checkContext) {
+                //this will use enclosing check context to check compatibility of
+                //subexpression against target type; if we are in a method check context,
+                //depending on whether boxing is allowed, we could have incompatibilities
+                @Override
+                public void report(DiagnosticPosition pos, JCDiagnostic details) {
+                    enclosingContext.report(pos, diags.fragment("incompatible.type.in.conditional", details));
+                }
+            };
+        }
+
         /** Compute the type of a conditional expression, after
          *  checking that it exists.  See JLS 15.25. Does not take into
          *  account the special case where condition and both arms
@@ -2070,13 +2112,8 @@
                 tree.constructor = constructor.baseSymbol();
 
                 final TypeSymbol csym = clazztype.tsym;
-                ResultInfo diamondResult = new ResultInfo(pkind, newMethodTemplate(resultInfo.pt, argtypes, typeargtypes), new Check.NestedCheckContext(resultInfo.checkContext) {
-                    @Override
-                    public void report(DiagnosticPosition _unused, JCDiagnostic details) {
-                        enclosingContext.report(tree.clazz,
-                                diags.fragment("cant.apply.diamond.1", diags.fragment("diamond", csym), details));
-                    }
-                }, CheckMode.NO_TREE_UPDATE);
+                ResultInfo diamondResult = new ResultInfo(pkind, newMethodTemplate(resultInfo.pt, argtypes, typeargtypes),
+                        diamondContext(tree, csym, resultInfo.checkContext), CheckMode.NO_TREE_UPDATE);
                 Type constructorType = tree.constructorType = types.createErrorType(clazztype);
                 constructorType = checkId(tree, site,
                         constructor,
@@ -2261,6 +2298,16 @@
             chk.validate(tree.typeargs, localEnv);
         }
 
+        CheckContext diamondContext(JCNewClass clazz, TypeSymbol tsym, CheckContext checkContext) {
+            return new Check.NestedCheckContext(checkContext) {
+                @Override
+                public void report(DiagnosticPosition _unused, JCDiagnostic details) {
+                    enclosingContext.report(clazz.clazz,
+                            diags.fragment("cant.apply.diamond.1", diags.fragment("diamond", tsym), details));
+                }
+            };
+        }
+
     /** Make an attributed null check tree.
      */
     public JCExpression makeNullCheck(JCExpression arg) {
@@ -2330,8 +2377,7 @@
         boolean needsRecovery =
                 resultInfo.checkContext.deferredAttrContext().mode == DeferredAttr.AttrMode.CHECK;
         try {
-            Type currentTarget = pt();
-            if (needsRecovery && isSerializable(currentTarget)) {
+            if (needsRecovery && isSerializable(pt())) {
                 localEnv.info.isSerializable = true;
             }
             List<Type> explicitParamTypes = null;
@@ -2341,22 +2387,13 @@
                 explicitParamTypes = TreeInfo.types(that.params);
             }
 
-            Type lambdaType;
-            if (pt() != Type.recoveryType) {
-                /* We need to adjust the target. If the target is an
-                 * intersection type, for example: SAM & I1 & I2 ...
-                 * the target will be updated to SAM
-                 */
-                currentTarget = targetChecker.visit(currentTarget, that);
-                if (explicitParamTypes != null) {
-                    currentTarget = infer.instantiateFunctionalInterface(that,
-                            currentTarget, explicitParamTypes, resultInfo.checkContext);
-                }
-                currentTarget = types.removeWildcards(currentTarget);
-                lambdaType = types.findDescriptorType(currentTarget);
-            } else {
-                currentTarget = Type.recoveryType;
-                lambdaType = fallbackDescriptorType(that);
+            TargetInfo targetInfo = getTargetInfo(that, resultInfo, explicitParamTypes);
+            Type currentTarget = targetInfo.target;
+            Type lambdaType = targetInfo.descriptor;
+
+            if (currentTarget.isErroneous()) {
+                result = that.type = currentTarget;
+                return;
             }
 
             setFunctionalInfo(localEnv, that, pt(), lambdaType, currentTarget, resultInfo.checkContext);
@@ -2409,15 +2446,8 @@
             //with the target-type, it will be recovered anyway in Attr.checkId
             needsRecovery = false;
 
-            FunctionalReturnContext funcContext = that.getBodyKind() == JCLambda.BodyKind.EXPRESSION ?
-                    new ExpressionLambdaReturnContext((JCExpression)that.getBody(), resultInfo.checkContext) :
-                    new FunctionalReturnContext(resultInfo.checkContext);
-
-            ResultInfo bodyResultInfo = lambdaType.getReturnType() == Type.recoveryType ?
-                recoveryInfo :
-                new ResultInfo(KindSelector.VAL,
-                               lambdaType.getReturnType(), funcContext);
-            localEnv.info.returnResult = bodyResultInfo;
+            ResultInfo bodyResultInfo = localEnv.info.returnResult =
+                    lambdaBodyResult(that, lambdaType, resultInfo);
 
             if (that.getBodyKind() == JCLambda.BodyKind.EXPRESSION) {
                 attribTree(that.getBody(), localEnv, bodyResultInfo);
@@ -2467,6 +2497,44 @@
         }
     }
     //where
+        class TargetInfo {
+            Type target;
+            Type descriptor;
+
+            public TargetInfo(Type target, Type descriptor) {
+                this.target = target;
+                this.descriptor = descriptor;
+            }
+        }
+
+        TargetInfo getTargetInfo(JCPolyExpression that, ResultInfo resultInfo, List<Type> explicitParamTypes) {
+            Type lambdaType;
+            Type currentTarget = resultInfo.pt;
+            if (resultInfo.pt != Type.recoveryType) {
+                /* We need to adjust the target. If the target is an
+                 * intersection type, for example: SAM & I1 & I2 ...
+                 * the target will be updated to SAM
+                 */
+                currentTarget = targetChecker.visit(currentTarget, that);
+                if (explicitParamTypes != null) {
+                    currentTarget = infer.instantiateFunctionalInterface(that,
+                            currentTarget, explicitParamTypes, resultInfo.checkContext);
+                }
+                currentTarget = types.removeWildcards(currentTarget);
+                lambdaType = types.findDescriptorType(currentTarget);
+            } else {
+                currentTarget = Type.recoveryType;
+                lambdaType = fallbackDescriptorType(that);
+            }
+            if (that.hasTag(LAMBDA) && lambdaType.hasTag(FORALL)) {
+                //lambda expression target desc cannot be a generic method
+                resultInfo.checkContext.report(that, diags.fragment("invalid.generic.lambda.target",
+                        lambdaType, kindName(currentTarget.tsym), currentTarget.tsym));
+                currentTarget = types.createErrorType(pt());
+            }
+            return new TargetInfo(currentTarget, lambdaType);
+        }
+
         void preFlow(JCLambda tree) {
             new PostAttrAnalyzer() {
                 @Override
@@ -2612,13 +2680,24 @@
             }
         }
 
+        ResultInfo lambdaBodyResult(JCLambda that, Type descriptor, ResultInfo resultInfo) {
+            FunctionalReturnContext funcContext = that.getBodyKind() == JCLambda.BodyKind.EXPRESSION ?
+                    new ExpressionLambdaReturnContext((JCExpression)that.getBody(), resultInfo.checkContext) :
+                    new FunctionalReturnContext(resultInfo.checkContext);
+
+            return descriptor.getReturnType() == Type.recoveryType ?
+                    recoveryInfo :
+                    new ResultInfo(KindSelector.VAL,
+                            descriptor.getReturnType(), funcContext);
+        }
+
         /**
         * Lambda compatibility. Check that given return types, thrown types, parameter types
         * are compatible with the expected functional interface descriptor. This means that:
         * (i) parameter types must be identical to those of the target descriptor; (ii) return
         * types must be compatible with the return type of the expected descriptor.
         */
-        private void checkLambdaCompatible(JCLambda tree, Type descriptor, CheckContext checkContext) {
+        void checkLambdaCompatible(JCLambda tree, Type descriptor, CheckContext checkContext) {
             Type returnType = checkContext.inferenceContext().asUndetVar(descriptor.getReturnType());
 
             //return values have already been checked - but if lambda has no return
@@ -2746,18 +2825,12 @@
                 typeargtypes = attribTypes(that.typeargs, localEnv);
             }
 
-            Type desc;
-            Type currentTarget = pt();
             boolean isTargetSerializable =
                     resultInfo.checkContext.deferredAttrContext().mode == DeferredAttr.AttrMode.CHECK &&
-                    isSerializable(currentTarget);
-            if (currentTarget != Type.recoveryType) {
-                currentTarget = types.removeWildcards(targetChecker.visit(currentTarget, that));
-                desc = types.findDescriptorType(currentTarget);
-            } else {
-                currentTarget = Type.recoveryType;
-                desc = fallbackDescriptorType(that);
-            }
+                    isSerializable(pt());
+            TargetInfo targetInfo = getTargetInfo(that, resultInfo, null);
+            Type currentTarget = targetInfo.target;
+            Type desc = targetInfo.descriptor;
 
             setFunctionalInfo(localEnv, that, pt(), desc, currentTarget, resultInfo.checkContext);
             List<Type> argtypes = desc.getParameterTypes();
@@ -3279,7 +3352,7 @@
         }
 
         // Attribute the qualifier expression, and determine its symbol (if any).
-        Type site = attribTree(tree.selected, env, new ResultInfo(skind, Infer.anyPoly));
+        Type site = attribTree(tree.selected, env, new ResultInfo(skind, Type.noType));
         if (!pkind().contains(KindSelector.TYP_PCK))
             site = capture(site); // Capture field access
 
@@ -3884,8 +3957,15 @@
                        syms.methodClass);
             }
 
-            return chk.checkMethod(owntype, sym, env, argtrees, argtypes, env.info.lastResolveVarargs(),
-                    resultInfo.checkContext.inferenceContext());
+            PolyKind pkind = (sym.type.hasTag(FORALL) &&
+                 sym.type.getReturnType().containsAny(((ForAll)sym.type).tvars)) ?
+                 PolyKind.POLY : PolyKind.STANDALONE;
+            TreeInfo.setPolyKind(env.tree, pkind);
+
+            return (resultInfo.pt == Infer.anyPoly) ?
+                    owntype :
+                    chk.checkMethod(owntype, sym, env, argtrees, argtypes, env.info.lastResolveVarargs(),
+                            resultInfo.checkContext.inferenceContext());
         } catch (Infer.InferenceException ex) {
             //invalid target type - propagate exception outwards or report error
             //depending on the current check context
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Check.java	Mon Sep 14 11:26:14 2015 +0100
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Check.java	Tue Sep 15 13:43:44 2015 +0100
@@ -49,7 +49,6 @@
 import com.sun.tools.javac.comp.DeferredAttr.DeferredAttrContext;
 import com.sun.tools.javac.comp.Infer.FreeTypeListener;
 import com.sun.tools.javac.tree.JCTree.*;
-import com.sun.tools.javac.tree.JCTree.JCPolyExpression.*;
 
 import static com.sun.tools.javac.code.Flags.*;
 import static com.sun.tools.javac.code.Flags.ANNOTATION;
@@ -976,10 +975,6 @@
                 TreeInfo.setVarargsElement(env.tree, types.elemtype(argtype));
             }
          }
-         PolyKind pkind = (sym.type.hasTag(FORALL) &&
-                 sym.type.getReturnType().containsAny(((ForAll)sym.type).tvars)) ?
-                 PolyKind.POLY : PolyKind.STANDALONE;
-         TreeInfo.setPolyKind(env.tree, pkind);
          return owntype;
     }
     //where
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/DeferredAttr.java	Mon Sep 14 11:26:14 2015 +0100
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/DeferredAttr.java	Tue Sep 15 13:43:44 2015 +0100
@@ -29,6 +29,7 @@
 import com.sun.source.tree.NewClassTree;
 import com.sun.tools.javac.code.*;
 import com.sun.tools.javac.code.Type.TypeMapping;
+import com.sun.tools.javac.comp.ArgumentAttr.CachePolicy;
 import com.sun.tools.javac.comp.Resolve.ResolveError;
 import com.sun.tools.javac.resources.CompilerProperties.Fragments;
 import com.sun.tools.javac.tree.*;
@@ -36,7 +37,6 @@
 import com.sun.tools.javac.util.DefinedBy.Api;
 import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;
 import com.sun.tools.javac.code.Symbol.*;
-import com.sun.tools.javac.code.Type.*;
 import com.sun.tools.javac.comp.Attr.ResultInfo;
 import com.sun.tools.javac.comp.Resolve.MethodResolutionPhase;
 import com.sun.tools.javac.tree.JCTree.*;
@@ -55,8 +55,6 @@
 
 import static com.sun.tools.javac.code.TypeTag.*;
 import static com.sun.tools.javac.tree.JCTree.Tag.*;
-import static com.sun.tools.javac.code.Kinds.*;
-import static com.sun.tools.javac.code.Kinds.Kind.*;
 
 /**
  * This is an helper class that is used to perform deferred type-analysis.
@@ -73,6 +71,7 @@
     protected static final Context.Key<DeferredAttr> deferredAttrKey = new Context.Key<>();
 
     final Attr attr;
+    final ArgumentAttr argumentAttr;
     final Check chk;
     final JCDiagnostic.Factory diags;
     final Enter enter;
@@ -98,6 +97,7 @@
     protected DeferredAttr(Context context) {
         context.put(deferredAttrKey, this);
         attr = Attr.instance(context);
+        argumentAttr = ArgumentAttr.instance(context);
         chk = Check.instance(context);
         diags = JCDiagnostic.Factory.instance(context);
         enter = Enter.instance(context);
@@ -255,6 +255,15 @@
             return e != null ? e.speculativeTree.type : Type.noType;
         }
 
+        JCTree speculativeTree(DeferredAttrContext deferredAttrContext) {
+            DeferredType.SpeculativeCache.Entry e = speculativeCache.get(deferredAttrContext.msym, deferredAttrContext.phase);
+            return e != null ? e.speculativeTree : stuckTree;
+        }
+
+        DeferredTypeCompleter completer() {
+            return basicCompleter;
+        }
+
         /**
          * Check a deferred type against a potential target-type. Depending on
          * the current attribution mode, a normal vs. speculative attribution
@@ -272,7 +281,7 @@
             } else {
                 deferredStuckPolicy = new CheckStuckPolicy(resultInfo, this);
             }
-            return check(resultInfo, deferredStuckPolicy, basicCompleter);
+            return check(resultInfo, deferredStuckPolicy, completer());
         }
 
         private Type check(ResultInfo resultInfo, DeferredStuckPolicy deferredStuckPolicy,
@@ -389,6 +398,42 @@
     }
 
     /**
+     * Performs speculative attribution of a lambda body and returns the speculative lambda tree,
+     * in the absence of a target-type. Since {@link Attr#visitLambda(JCLambda)} cannot type-check
+     * lambda bodies w/o a suitable target-type, this routine 'unrolls' the lambda by turning it
+     * into a regular block, speculatively type-checks the block and then puts back the pieces.
+     */
+    JCLambda attribSpeculativeLambda(JCLambda that, Env<AttrContext> env, ResultInfo resultInfo) {
+        ListBuffer<JCStatement> stats = new ListBuffer<>();
+        stats.addAll(that.params);
+        if (that.getBodyKind() == JCLambda.BodyKind.EXPRESSION) {
+            stats.add(make.Return((JCExpression)that.body));
+        } else {
+            stats.add((JCBlock)that.body);
+        }
+        JCBlock lambdaBlock = make.Block(0, stats.toList());
+        Env<AttrContext> localEnv = attr.lambdaEnv(that, env);
+        try {
+            localEnv.info.returnResult = resultInfo;
+            JCBlock speculativeTree = (JCBlock)attribSpeculative(lambdaBlock, localEnv, resultInfo);
+            List<JCVariableDecl> args = speculativeTree.getStatements().stream()
+                    .filter(s -> s.hasTag(Tag.VARDEF))
+                    .map(t -> (JCVariableDecl)t)
+                    .collect(List.collector());
+            JCTree lambdaBody = speculativeTree.getStatements().last();
+            if (lambdaBody.hasTag(Tag.RETURN)) {
+                lambdaBody = ((JCReturn)lambdaBody).expr;
+            }
+            JCLambda speculativeLambda = make.Lambda(args, lambdaBody);
+            attr.preFlow(speculativeLambda);
+            flow.analyzeLambda(env, speculativeLambda, make, false);
+            return speculativeLambda;
+        } finally {
+            localEnv.info.scope.leave();
+        }
+    }
+
+    /**
      * Routine that performs speculative type-checking; the input AST node is
      * cloned (to avoid side-effects cause by Attr) and compiler state is
      * restored after type-checking. All diagnostics (but critical ones) are
@@ -572,7 +617,7 @@
             }
         }
 
-        private boolean insideOverloadPhase() {
+        public boolean insideOverloadPhase() {
             DeferredAttrContext dac = this;
             if (dac == emptyDeferredAttrContext) {
                 return false;
@@ -731,56 +776,16 @@
             }
 
             boolean canLambdaBodyCompleteNormally(JCLambda tree) {
-                JCLambda newTree = new TreeCopier<>(make).copy(tree);
-                /* attr.lambdaEnv will create a meaningful env for the
-                 * lambda expression. This is specially useful when the
-                 * lambda is used as the init of a field. But we need to
-                 * remove any added symbol.
-                 */
-                Env<AttrContext> localEnv = attr.lambdaEnv(newTree, env);
+                List<JCVariableDecl> oldParams = tree.params;
+                CachePolicy prevPolicy = argumentAttr.withCachePolicy(CachePolicy.NO_CACHE);
                 try {
-                    List<JCVariableDecl> tmpParams = newTree.params;
-                    while (tmpParams.nonEmpty()) {
-                        tmpParams.head.vartype = make.at(tmpParams.head).Type(syms.errType);
-                        tmpParams = tmpParams.tail;
-                    }
-
-                    attr.attribStats(newTree.params, localEnv);
-
-                    /* set pt to Type.noType to avoid generating any bound
-                     * which may happen if lambda's return type is an
-                     * inference variable
-                     */
-                    Attr.ResultInfo bodyResultInfo = attr.new ResultInfo(KindSelector.VAL, Type.noType);
-                    localEnv.info.returnResult = bodyResultInfo;
-
-                    // discard any log output
-                    Log.DiagnosticHandler diagHandler = new Log.DiscardDiagnosticHandler(log);
-                    try {
-                        JCBlock body = (JCBlock)newTree.body;
-                        /* we need to attribute the lambda body before
-                         * doing the aliveness analysis. This is because
-                         * constant folding occurs during attribution
-                         * and the reachability of some statements depends
-                         * on constant values, for example:
-                         *
-                         *     while (true) {...}
-                         */
-                        attr.attribStats(body.stats, localEnv);
-
-                        attr.preFlow(newTree);
-                        /* make an aliveness / reachability analysis of the lambda
-                         * to determine if it can complete normally
-                         */
-                        flow.analyzeLambda(localEnv, newTree, make, true);
-                    } finally {
-                        log.popDiagnosticHandler(diagHandler);
-                    }
-                    return newTree.canCompleteNormally;
+                    tree.params = tree.params.stream()
+                            .map(vd -> make.VarDef(vd.mods, vd.name, make.Erroneous(), null))
+                            .collect(List.collector());
+                    return attribSpeculativeLambda(tree, env, attr.unknownExprInfo).canCompleteNormally;
                 } finally {
-                    JCBlock body = (JCBlock)newTree.body;
-                    unenterScanner.scan(body.stats);
-                    localEnv.info.scope.leave();
+                    argumentAttr.withCachePolicy(prevPolicy);
+                    tree.params = oldParams;
                 }
             }
 
@@ -951,7 +956,7 @@
      * A special tree scanner that would only visit portions of a given tree.
      * The set of nodes visited by the scanner can be customized at construction-time.
      */
-    abstract static class FilterScanner extends TreeScanner {
+    abstract static class FilterScanner extends com.sun.tools.javac.tree.TreeScanner {
 
         final Filter<JCTree> treeFilter;
 
@@ -1148,330 +1153,4 @@
             }
         }
     }
-
-    /**
-     * Does the argument expression {@code expr} need speculative type-checking?
-     */
-    boolean isDeferred(Env<AttrContext> env, JCExpression expr) {
-        DeferredChecker dc = new DeferredChecker(env);
-        dc.scan(expr);
-        return dc.result.isPoly();
-    }
-
-    /**
-     * The kind of an argument expression. This is used by the analysis that
-     * determines as to whether speculative attribution is necessary.
-     */
-    enum ArgumentExpressionKind {
-
-        /** kind that denotes poly argument expression */
-        POLY,
-        /** kind that denotes a standalone expression */
-        NO_POLY,
-        /** kind that denotes a primitive/boxed standalone expression */
-        PRIMITIVE;
-
-        /**
-         * Does this kind denote a poly argument expression
-         */
-        public final boolean isPoly() {
-            return this == POLY;
-        }
-
-        /**
-         * Does this kind denote a primitive standalone expression
-         */
-        public final boolean isPrimitive() {
-            return this == PRIMITIVE;
-        }
-
-        /**
-         * Compute the kind of a standalone expression of a given type
-         */
-        static ArgumentExpressionKind standaloneKind(Type type, Types types) {
-            return types.unboxedTypeOrType(type).isPrimitive() ?
-                    ArgumentExpressionKind.PRIMITIVE :
-                    ArgumentExpressionKind.NO_POLY;
-        }
-
-        /**
-         * Compute the kind of a method argument expression given its symbol
-         */
-        static ArgumentExpressionKind methodKind(Symbol sym, Types types) {
-            Type restype = sym.type.getReturnType();
-            if (sym.type.hasTag(FORALL) &&
-                    restype.containsAny(((ForAll)sym.type).tvars)) {
-                return ArgumentExpressionKind.POLY;
-            } else {
-                return ArgumentExpressionKind.standaloneKind(restype, types);
-            }
-        }
-    }
-
-    /**
-     * Tree scanner used for checking as to whether an argument expression
-     * requires speculative attribution
-     */
-    final class DeferredChecker extends FilterScanner {
-
-        Env<AttrContext> env;
-        ArgumentExpressionKind result;
-
-        public DeferredChecker(Env<AttrContext> env) {
-            super(deferredCheckerTags);
-            this.env = env;
-        }
-
-        @Override
-        public void visitLambda(JCLambda tree) {
-            //a lambda is always a poly expression
-            result = ArgumentExpressionKind.POLY;
-        }
-
-        @Override
-        public void visitReference(JCMemberReference tree) {
-            //perform arity-based check
-            Env<AttrContext> localEnv = env.dup(tree);
-            JCExpression exprTree = (JCExpression)attribSpeculative(tree.getQualifierExpression(), localEnv,
-                    attr.memberReferenceQualifierResult(tree));
-            JCMemberReference mref2 = new TreeCopier<Void>(make).copy(tree);
-            mref2.expr = exprTree;
-            Symbol res =
-                    rs.getMemberReference(tree, localEnv, mref2,
-                        exprTree.type, tree.name);
-            tree.sym = res;
-            if (res.kind.isResolutionTargetError() ||
-                    res.type != null && res.type.hasTag(FORALL) ||
-                    (res.flags() & Flags.VARARGS) != 0 ||
-                    (TreeInfo.isStaticSelector(exprTree, tree.name.table.names) &&
-                    exprTree.type.isRaw())) {
-                tree.overloadKind = JCMemberReference.OverloadKind.OVERLOADED;
-            } else {
-                tree.overloadKind = JCMemberReference.OverloadKind.UNOVERLOADED;
-            }
-            //a method reference is always a poly expression
-            result = ArgumentExpressionKind.POLY;
-        }
-
-        @Override
-        public void visitTypeCast(JCTypeCast tree) {
-            //a cast is always a standalone expression
-            result = ArgumentExpressionKind.NO_POLY;
-        }
-
-        @Override
-        public void visitConditional(JCConditional tree) {
-            scan(tree.truepart);
-            if (!result.isPrimitive()) {
-                result = ArgumentExpressionKind.POLY;
-                return;
-            }
-            scan(tree.falsepart);
-            result = reduce(ArgumentExpressionKind.PRIMITIVE).isPrimitive() ?
-                    ArgumentExpressionKind.PRIMITIVE :
-                    ArgumentExpressionKind.POLY;
-
-        }
-
-        @Override
-        public void visitNewClass(JCNewClass tree) {
-            result = TreeInfo.isDiamond(tree) ?
-                    ArgumentExpressionKind.POLY : ArgumentExpressionKind.NO_POLY;
-        }
-
-        @Override
-        public void visitApply(JCMethodInvocation tree) {
-            Name name = TreeInfo.name(tree.meth);
-
-            //fast path
-            if (tree.typeargs.nonEmpty() ||
-                    name == name.table.names._this ||
-                    name == name.table.names._super) {
-                result = ArgumentExpressionKind.NO_POLY;
-                return;
-            }
-
-            //slow path
-            Symbol sym = quicklyResolveMethod(env, tree);
-
-            if (sym == null) {
-                result = ArgumentExpressionKind.POLY;
-                return;
-            }
-
-            result = analyzeCandidateMethods(sym, ArgumentExpressionKind.PRIMITIVE,
-                    argumentKindAnalyzer);
-        }
-        //where
-            private boolean isSimpleReceiver(JCTree rec) {
-                switch (rec.getTag()) {
-                    case IDENT:
-                        return true;
-                    case SELECT:
-                        return isSimpleReceiver(((JCFieldAccess)rec).selected);
-                    case TYPEAPPLY:
-                    case TYPEARRAY:
-                        return true;
-                    case ANNOTATED_TYPE:
-                        return isSimpleReceiver(((JCAnnotatedType)rec).underlyingType);
-                    case APPLY:
-                        return true;
-                    case NEWCLASS:
-                        JCNewClass nc = (JCNewClass) rec;
-                        return nc.encl == null && nc.def == null && !TreeInfo.isDiamond(nc);
-                    default:
-                        return false;
-                }
-            }
-            private ArgumentExpressionKind reduce(ArgumentExpressionKind kind) {
-                return argumentKindAnalyzer.reduce(result, kind);
-            }
-            MethodAnalyzer<ArgumentExpressionKind> argumentKindAnalyzer =
-                    new MethodAnalyzer<ArgumentExpressionKind>() {
-                @Override
-                public ArgumentExpressionKind process(MethodSymbol ms) {
-                    return ArgumentExpressionKind.methodKind(ms, types);
-                }
-                @Override
-                public ArgumentExpressionKind reduce(ArgumentExpressionKind kind1,
-                                                     ArgumentExpressionKind kind2) {
-                    switch (kind1) {
-                        case PRIMITIVE: return kind2;
-                        case NO_POLY: return kind2.isPoly() ? kind2 : kind1;
-                        case POLY: return kind1;
-                        default:
-                            Assert.error();
-                            return null;
-                    }
-                }
-                @Override
-                public boolean shouldStop(ArgumentExpressionKind result) {
-                    return result.isPoly();
-                }
-            };
-
-        @Override
-        public void visitLiteral(JCLiteral tree) {
-            Type litType = attr.litType(tree.typetag);
-            result = ArgumentExpressionKind.standaloneKind(litType, types);
-        }
-
-        @Override
-        void skip(JCTree tree) {
-            result = ArgumentExpressionKind.NO_POLY;
-        }
-
-        private Symbol quicklyResolveMethod(Env<AttrContext> env, final JCMethodInvocation tree) {
-            final JCExpression rec = tree.meth.hasTag(SELECT) ?
-                    ((JCFieldAccess)tree.meth).selected :
-                    null;
-
-            if (rec != null && !isSimpleReceiver(rec)) {
-                return null;
-            }
-
-            Type site;
-
-            if (rec != null) {
-                switch (rec.getTag()) {
-                    case APPLY:
-                        Symbol recSym = quicklyResolveMethod(env, (JCMethodInvocation) rec);
-                        if (recSym == null)
-                            return null;
-                        Symbol resolvedReturnType =
-                                analyzeCandidateMethods(recSym, syms.errSymbol, returnSymbolAnalyzer);
-                        if (resolvedReturnType == null)
-                            return null;
-                        site = resolvedReturnType.type;
-                        break;
-                    case NEWCLASS:
-                        JCNewClass nc = (JCNewClass) rec;
-                        site = attribSpeculative(nc.clazz, env, attr.unknownTypeExprInfo).type;
-                        break;
-                    default:
-                        site = attribSpeculative(rec, env, attr.unknownTypeExprInfo).type;
-                        break;
-                }
-            } else {
-                site = env.enclClass.sym.type;
-            }
-
-            site = types.skipTypeVars(site, true);
-
-            List<Type> args = rs.dummyArgs(tree.args.length());
-            Name name = TreeInfo.name(tree.meth);
-
-            Resolve.LookupHelper lh = rs.new LookupHelper(name, site, args, List.<Type>nil(), MethodResolutionPhase.VARARITY) {
-                @Override
-                Symbol lookup(Env<AttrContext> env, MethodResolutionPhase phase) {
-                    return rec == null ?
-                        rs.findFun(env, name, argtypes, typeargtypes, phase.isBoxingRequired(), phase.isVarargsRequired()) :
-                        rs.findMethod(env, site, name, argtypes, typeargtypes, phase.isBoxingRequired(), phase.isVarargsRequired());
-                }
-                @Override
-                Symbol access(Env<AttrContext> env, DiagnosticPosition pos, Symbol location, Symbol sym) {
-                    return sym;
-                }
-            };
-
-            return rs.lookupMethod(env, tree, site.tsym, rs.arityMethodCheck, lh);
-        }
-        //where:
-            MethodAnalyzer<Symbol> returnSymbolAnalyzer = new MethodAnalyzer<Symbol>() {
-                @Override
-                public Symbol process(MethodSymbol ms) {
-                    ArgumentExpressionKind kind = ArgumentExpressionKind.methodKind(ms, types);
-                    if (kind == ArgumentExpressionKind.POLY || ms.getReturnType().hasTag(TYPEVAR))
-                        return null;
-                    return ms.getReturnType().tsym;
-                }
-                @Override
-                public Symbol reduce(Symbol s1, Symbol s2) {
-                    return s1 == syms.errSymbol ? s2 : s1 == s2 ? s1 : null;
-                }
-                @Override
-                public boolean shouldStop(Symbol result) {
-                    return result == null;
-                }
-            };
-
-        /**
-         * Process the result of Resolve.lookupMethod. If sym is a method symbol, the result of
-         * MethodAnalyzer.process is returned. If sym is an ambiguous symbol, all the candidate
-         * methods are inspected one by one, using MethodAnalyzer.process. The outcomes are
-         * reduced using MethodAnalyzer.reduce (using defaultValue as the first value over which
-         * the reduction runs). MethodAnalyzer.shouldStop can be used to stop the inspection early.
-         */
-        <E> E analyzeCandidateMethods(Symbol sym, E defaultValue, MethodAnalyzer<E> analyzer) {
-            switch (sym.kind) {
-                case MTH:
-                    return analyzer.process((MethodSymbol) sym);
-                case AMBIGUOUS:
-                    Resolve.AmbiguityError err = (Resolve.AmbiguityError)sym.baseSymbol();
-                    E res = defaultValue;
-                    for (Symbol s : err.ambiguousSyms) {
-                        if (s.kind == MTH) {
-                            res = analyzer.reduce(res, analyzer.process((MethodSymbol) s));
-                            if (analyzer.shouldStop(res))
-                                return res;
-                        }
-                    }
-                    return res;
-                default:
-                    return defaultValue;
-            }
-        }
-    }
-
-    /** Analyzer for methods - used by analyzeCandidateMethods. */
-    interface MethodAnalyzer<E> {
-        E process(MethodSymbol ms);
-        E reduce(E e1, E e2);
-        boolean shouldStop(E result);
-    }
-
-    //where
-    private EnumSet<JCTree.Tag> deferredCheckerTags =
-            EnumSet.of(LAMBDA, REFERENCE, PARENS, TYPECAST,
-                    CONDEXPR, NEWCLASS, APPLY, LITERAL);
 }
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Infer.java	Mon Sep 14 11:26:14 2015 +0100
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Infer.java	Tue Sep 15 13:43:44 2015 +0100
@@ -37,6 +37,7 @@
 import com.sun.tools.javac.code.Type.UndetVar.InferenceBound;
 import com.sun.tools.javac.code.Symbol.*;
 import com.sun.tools.javac.comp.DeferredAttr.AttrMode;
+import com.sun.tools.javac.comp.DeferredAttr.DeferredAttrContext;
 import com.sun.tools.javac.comp.Infer.GraphSolver.InferenceGraph;
 import com.sun.tools.javac.comp.Infer.GraphSolver.InferenceGraph.Node;
 import com.sun.tools.javac.comp.Resolve.InapplicableMethodException;
@@ -179,7 +180,11 @@
 
             resolveContext.methodCheck.argumentsAcceptable(env, deferredAttrContext,   //B2
                     argtypes, mt.getParameterTypes(), warn);
-            if (allowGraphInference &&
+
+            if (allowGraphInference && resultInfo != null && resultInfo.pt == anyPoly) {
+                //we are inside method attribution - just return a partially inferred type
+                return new PartiallyInferredMethodType(mt, inferenceContext, env, warn);
+            } else if (allowGraphInference &&
                     resultInfo != null &&
                     !warn.hasNonSilentLint(Lint.LintCategory.UNCHECKED)) {
                 //inject return constraints earlier
@@ -238,6 +243,73 @@
         }
     }
 
+    /**
+     * A partially infered method/constructor type; such a type can be checked multiple times
+     * against different targets.
+     */
+    public class PartiallyInferredMethodType extends MethodType {
+        public PartiallyInferredMethodType(MethodType mtype, InferenceContext inferenceContext, Env<AttrContext> env, Warner warn) {
+            super(mtype.getParameterTypes(), mtype.getReturnType(), mtype.getThrownTypes(), mtype.tsym);
+            this.inferenceContext = inferenceContext;
+            this.env = env;
+            this.warn = warn;
+        }
+
+        /** The inference context. */
+        final InferenceContext inferenceContext;
+
+        /** The attribution environment. */
+        Env<AttrContext> env;
+
+        /** The warner. */
+        final Warner warn;
+
+        @Override
+        public boolean isPartial() {
+            return true;
+        }
+
+        /**
+         * Checks this type against a target; this means generating return type constraints, solve
+         * and then roll back the results (to avoid poolluting the context).
+         */
+        Type check(Attr.ResultInfo resultInfo) {
+            Warner noWarnings = new Warner(null);
+            inferenceException.clear();
+            List<Type> saved_undet = null;
+            try {
+                /** we need to save the inference context before generating target type constraints.
+                 *  This constraints may pollute the inference context and make it useless in case we
+                 *  need to use it several times: with several targets.
+                 */
+                saved_undet = inferenceContext.save();
+                if (allowGraphInference && !warn.hasNonSilentLint(Lint.LintCategory.UNCHECKED)) {
+                    //inject return constraints earlier
+                    checkWithinBounds(inferenceContext, noWarnings); //propagation
+                    Type res = generateReturnConstraints(env.tree, resultInfo,  //B3
+                        this, inferenceContext);
+
+                    if (resultInfo.checkContext.inferenceContext().free(resultInfo.pt)) {
+                        //propagate inference context outwards and exit
+                        inferenceContext.dupTo(resultInfo.checkContext.inferenceContext(),
+                                resultInfo.checkContext.deferredAttrContext().insideOverloadPhase());
+                        return res;
+                    }
+                }
+                inferenceContext.solve(noWarnings);
+                return inferenceContext.asInstType(this).getReturnType();
+            } catch (InferenceException ex) {
+                resultInfo.checkContext.report(null, ex.getDiagnostic());
+                Assert.error(); //cannot get here (the above should throw)
+                return null;
+            } finally {
+                if (saved_undet != null) {
+                    inferenceContext.rollback(saved_undet);
+                }
+            }
+        }
+    }
+
     private void dumpGraphsIfNeeded(DiagnosticPosition pos, Symbol msym, Resolve.MethodResolutionContext rsContext) {
         int round = 0;
         try {
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/InferenceContext.java	Mon Sep 14 11:26:14 2015 +0100
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/InferenceContext.java	Tue Sep 15 13:43:44 2015 +0100
@@ -315,31 +315,46 @@
         return buf.toList();
     }
 
-    /**
-     * Restore the state of this inference context to the previous known checkpoint
-     */
+    /** Restore the state of this inference context to the previous known checkpoint.
+    *  Consider that the number of saved undetermined variables can be different to the current
+    *  amount. This is because new captured variables could have been added.
+    */
     void rollback(List<Type> saved_undet) {
-         Assert.check(saved_undet != null && saved_undet.length() == undetvars.length());
+        Assert.check(saved_undet != null);
         //restore bounds (note: we need to preserve the old instances)
-        for (Type t : undetvars) {
-            UndetVar uv = (UndetVar)t;
+        ListBuffer<Type> newUndetVars = new ListBuffer<>();
+        ListBuffer<Type> newInferenceVars = new ListBuffer<>();
+        while (saved_undet.nonEmpty() && undetvars.nonEmpty()) {
+            UndetVar uv = (UndetVar)undetvars.head;
             UndetVar uv_saved = (UndetVar)saved_undet.head;
-            for (InferenceBound ib : InferenceBound.values()) {
-                uv.setBounds(ib, uv_saved.getBounds(ib));
+            if (uv.qtype == uv_saved.qtype) {
+                for (InferenceBound ib : InferenceBound.values()) {
+                    uv.setBounds(ib, uv_saved.getBounds(ib));
+                }
+                uv.inst = uv_saved.inst;
+                undetvars = undetvars.tail;
+                saved_undet = saved_undet.tail;
+                newUndetVars.add(uv);
+                newInferenceVars.add(uv.qtype);
+            } else {
+                undetvars = undetvars.tail;
             }
-            uv.inst = uv_saved.inst;
-            saved_undet = saved_undet.tail;
         }
+        undetvars = newUndetVars.toList();
+        inferencevars = newInferenceVars.toList();
     }
 
     /**
      * Copy variable in this inference context to the given context
      */
     void dupTo(final InferenceContext that) {
-        that.inferencevars = that.inferencevars.appendList(
-                inferencevars.diff(that.inferencevars));
-        that.undetvars = that.undetvars.appendList(
-                undetvars.diff(that.undetvars));
+        dupTo(that, false);
+    }
+
+    void dupTo(final InferenceContext that, boolean clone) {
+        that.inferencevars = that.inferencevars.appendList(inferencevars.diff(that.inferencevars));
+        List<Type> undetsToPropagate = clone ? save() : undetvars;
+        that.undetvars = that.undetvars.appendList(undetsToPropagate.diff(that.undetvars)); //propagate cloned undet!!
         //set up listeners to notify original inference contexts as
         //propagated vars are inferred in new context
         for (Type t : inferencevars) {
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Resolve.java	Mon Sep 14 11:26:14 2015 +0100
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Resolve.java	Tue Sep 15 13:43:44 2015 +0100
@@ -588,7 +588,8 @@
         MethodResolutionContext prevContext = currentResolutionContext;
         try {
             currentResolutionContext = new MethodResolutionContext();
-            currentResolutionContext.attrMode = DeferredAttr.AttrMode.CHECK;
+            currentResolutionContext.attrMode = (resultInfo.pt == Infer.anyPoly) ?
+                    AttrMode.SPECULATIVE : DeferredAttr.AttrMode.CHECK;
             if (env.tree.hasTag(JCTree.Tag.REFERENCE)) {
                 //method/constructor references need special check class
                 //to handle inference variables in 'argtypes' (might happen
@@ -1032,6 +1033,11 @@
         protected ResultInfo dup(CheckContext newContext) {
             return new MethodResultInfo(pt, newContext);
         }
+
+        @Override
+        protected ResultInfo dup(Type newPt, CheckContext newContext) {
+            return new MethodResultInfo(newPt, newContext);
+        }
     }
 
     /**
@@ -1092,10 +1098,9 @@
                         unrelatedFunctionalInterfaces(found, req) &&
                         (actual != null && actual.getTag() == DEFERRED)) {
                     DeferredType dt = (DeferredType) actual;
-                    DeferredType.SpeculativeCache.Entry e =
-                            dt.speculativeCache.get(deferredAttrContext.msym, deferredAttrContext.phase);
-                    if (e != null && e.speculativeTree != deferredAttr.stuckTree) {
-                        return functionalInterfaceMostSpecific(found, req, e.speculativeTree);
+                    JCTree speculativeTree = dt.speculativeTree(deferredAttrContext);
+                    if (speculativeTree != deferredAttr.stuckTree) {
+                        return functionalInterfaceMostSpecific(found, req, speculativeTree);
                     }
                 }
                 return compatibleBySubtyping(found, req);
@@ -1147,8 +1152,8 @@
 
                 @Override
                 public void visitConditional(JCConditional tree) {
-                    scan(tree.truepart);
-                    scan(tree.falsepart);
+                    scan(asExpr(tree.truepart));
+                    scan(asExpr(tree.falsepart));
                 }
 
                 @Override
@@ -1180,6 +1185,11 @@
                 }
 
                 @Override
+                public void visitParens(JCParens tree) {
+                    scan(asExpr(tree.expr));
+                }
+
+                @Override
                 public void visitLambda(JCLambda tree) {
                     Type desc_t = types.findDescriptorType(t);
                     Type desc_s = types.findDescriptorType(s);
@@ -1214,7 +1224,7 @@
 
                 private List<JCExpression> lambdaResults(JCLambda lambda) {
                     if (lambda.getBodyKind() == JCTree.JCLambda.BodyKind.EXPRESSION) {
-                        return List.of((JCExpression) lambda.body);
+                        return List.of(asExpr((JCExpression) lambda.body));
                     } else {
                         final ListBuffer<JCExpression> buffer = new ListBuffer<>();
                         DeferredAttr.LambdaReturnScanner lambdaScanner =
@@ -1222,7 +1232,7 @@
                                     @Override
                                     public void visitReturn(JCReturn tree) {
                                         if (tree.expr != null) {
-                                            buffer.append(tree.expr);
+                                            buffer.append(asExpr(tree.expr));
                                         }
                                     }
                                 };
@@ -1230,6 +1240,16 @@
                         return buffer.toList();
                     }
                 }
+
+                private JCExpression asExpr(JCExpression expr) {
+                    if (expr.type.hasTag(DEFERRED)) {
+                        JCTree speculativeTree = ((DeferredType)expr.type).speculativeTree(deferredAttrContext);
+                        if (speculativeTree != deferredAttr.stuckTree) {
+                            expr = (JCExpression)speculativeTree;
+                        }
+                    }
+                    return expr;
+                }
             }
 
         }
--- a/test/tools/javac/generics/wildcards/neg/Readonly.out	Mon Sep 14 11:26:14 2015 +0100
+++ b/test/tools/javac/generics/wildcards/neg/Readonly.out	Tue Sep 15 13:43:44 2015 +0100
@@ -1,2 +1,2 @@
-Readonly.java:15:10: compiler.err.cant.apply.symbol: kindname.method, put, Err<compiler.misc.type.captureof: 1, ? extends java.lang.String>, Err<compiler.misc.type.captureof: 2, ? extends java.lang.String>, kindname.class, Err<T>, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Err<compiler.misc.type.captureof: 2, ? extends java.lang.String>, Err<compiler.misc.type.captureof: 1, ? extends java.lang.String>))
+Readonly.java:15:10: compiler.err.cant.apply.symbol: kindname.method, put, Err<compiler.misc.type.captureof: 1, ? extends java.lang.String>, Err<compiler.misc.type.captureof: 2, ? extends java.lang.String>, kindname.class, Err<T>, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Err<compiler.misc.type.captureof: 3, ? extends java.lang.String>, Err<compiler.misc.type.captureof: 1, ? extends java.lang.String>))
 1 error
--- a/test/tools/javac/lambda/8019480/T8019480.out	Mon Sep 14 11:26:14 2015 +0100
+++ b/test/tools/javac/lambda/8019480/T8019480.out	Tue Sep 15 13:43:44 2015 +0100
@@ -1,3 +1,3 @@
+T8019480.java:21:34: compiler.err.cant.apply.symbols: kindname.method, add, java.lang.Object,{(compiler.misc.inapplicable.method: kindname.method, java.util.Collection, add(U), (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: java.lang.Object, U))),(compiler.misc.inapplicable.method: kindname.method, java.util.List, add(U), (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: java.lang.Object, U))),(compiler.misc.inapplicable.method: kindname.method, java.util.List, add(int,U), (compiler.misc.arg.length.mismatch))}
 T8019480.java:21:46: compiler.err.report.access: clone(), protected, java.lang.Object
-T8019480.java:21:34: compiler.err.cant.apply.symbols: kindname.method, add, java.lang.Object,{(compiler.misc.inapplicable.method: kindname.method, java.util.Collection, add(U), (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: java.lang.Object, U))),(compiler.misc.inapplicable.method: kindname.method, java.util.List, add(U), (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: java.lang.Object, U))),(compiler.misc.inapplicable.method: kindname.method, java.util.List, add(int,U), (compiler.misc.arg.length.mismatch))}
 2 errors
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/lambda/speculative/InferStrict.java	Tue Sep 15 13:43:44 2015 +0100
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+ /*
+  * @test
+  * @bug 8078093
+  * @summary Exponential performance regression Java 8 compiler compared to Java 7 compiler
+  * @compile InferStrict.java
+  */
+import java.util.HashSet;
+import java.util.Set;
+
+class InferStrict {
+    public <T> Set<T> compute(Set<T> t) { return t; }
+    public <T> T join(Set<T> t1, Set<T> t2) { return null; }
+    public <T extends InferStrict> T compute() { return null; }
+    public void test() {
+        join(
+            compute(compute(compute(compute(compute(compute(compute(compute(compute(compute(compute(compute(compute(compute(compute(compute(compute(new HashSet<>()))))))))))))))))),
+            compute(compute(compute(compute(compute(compute(compute(compute(compute(compute(compute(compute(compute(compute(compute(compute(compute(new HashSet<String>())))))))))))))))))
+        ).length();
+     }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/lambda/speculative/InferWeak.java	Tue Sep 15 13:43:44 2015 +0100
@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+ /*
+  * @test
+  * @bug 8078093
+  * @summary Exponential performance regression Java 8 compiler compared to Java 7 compiler
+  * @compile InferWeak.java
+  */
+class InferWeak {
+    private void test() {
+        GroupLayout l = new GroupLayout();
+        l.setHorizontalGroup(
+            l.createParallelGroup().addGroup(l.createParallelGroup().addGroup(
+            l.createParallelGroup().addGroup(l.createParallelGroup().addGroup(
+            l.createParallelGroup().addGroup(l.createParallelGroup().addGroup(
+            l.createParallelGroup().addGroup(l.createParallelGroup().addGroup(
+            l.createParallelGroup().addGroup(l.createParallelGroup().addGroup(
+            l.createParallelGroup().addGroup(l.createParallelGroup().addGroup(
+            l.createParallelGroup().addGroup(l.createParallelGroup().addGroup(
+            l.createParallelGroup().addGroup(l.createParallelGroup().addGroup(
+            l.createParallelGroup().addGroup(l.createParallelGroup().addGroup(
+            l.createParallelGroup().addGap(1).addComponent(new Object()).addGap(1)
+            .addComponent(new Object())).addGap(1).addComponent(new Object()).addGap(1)
+            .addComponent(new Object())).addGap(1).addComponent(new Object()).addGap(1)
+            .addComponent(new Object())).addGap(1).addComponent(new Object()).addGap(1)
+            .addComponent(new Object())).addGap(1).addComponent(new Object()).addGap(1)
+            .addComponent(new Object())).addGap(1).addComponent(new Object()).addGap(1)
+            .addComponent(new Object())).addGap(1).addComponent(new Object()).addGap(1)
+            .addComponent(new Object())).addGap(1).addComponent(new Object()).addGap(1)
+            .addComponent(new Object())).addGap(1).addComponent(new Object()).addGap(1)
+            .addComponent(new Object())).addGap(1).addComponent(new Object()).addGap(1)
+            .addComponent(new Object())).addGap(1).addComponent(new Object()).addGap(1)
+            .addComponent(new Object())).addGap(1).addComponent(new Object()).addGap(1)
+            .addComponent(new Object())).addGap(1).addComponent(new Object()).addGap(1)
+            .addComponent(new Object())).addGap(1).addComponent(new Object()).addGap(1)
+            .addComponent(new Object())).addGap(1).addComponent(new Object()).addGap(1)
+            .addComponent(new Object())).addGap(1).addComponent(new Object()).addGap(1)
+            .addComponent(new Object())).addGap(1).addComponent(new Object()).addGap(1)
+            .addComponent(new Object())).addGap(1).addComponent(new Object()).addGap(1)
+            .addComponent(new Object())).addGap(1).addComponent(new Object()).addGap(1)
+            .addComponent(new Object()));
+    }
+
+    static class GroupLayout {
+        <T extends ParallelGroup> T createParallelGroup() {return null;}
+        <T extends ParallelGroup> T createParallelGroup(int i) {return null;}
+        <T extends ParallelGroup> T createParallelGroup(int i, int j) {return null;}
+        void setHorizontalGroup(ParallelGroup g) { }
+    }
+
+    static class ParallelGroup {
+        <T extends ParallelGroup> T addGroup(ParallelGroup g) { return null; }
+        <T extends ParallelGroup> T addGroup(int i, ParallelGroup g) { return null; }
+        <T extends ParallelGroup> T addGap(int i) { return null; }
+        <T extends ParallelGroup> T addGap(int i, int j) { return null; }
+        <T extends ParallelGroup> T addComponent(Object c) { return null; }
+        <T extends ParallelGroup> T addComponent(int i, Object c) { return null; }
+    }
+ }
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/lambda/speculative/NestedLambdaGenerics.java	Tue Sep 15 13:43:44 2015 +0100
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+ /*
+  * @test
+  * @bug 8078093
+  * @summary Exponential performance regression Java 8 compiler compared to Java 7 compiler
+  * @compile NestedLambdaGenerics.java
+  */
+import java.util.concurrent.Callable;
+
+class NestedLambdaGenerics {
+    void test() {
+        m(null, () -> m(null, () -> m(null, () -> m(null, () -> m(null, () -> m(null, () -> m(null,
+                () -> m(null, () -> m(null, () -> m(null, () -> m(null, () -> m(null, () -> m(null,
+                () -> m(null, () -> m(null, () -> m(null, () -> m(null, () -> m(null, () -> m(null,
+                () -> m(null, () -> m(null, () -> m(null, () -> m(null, () -> m(null, () -> m(null,
+                () -> m(null, () -> m(null, () -> m(null, () -> m(null, () -> m(null, () -> m(null,
+                (Callable<String>)null)))))))))))))))))))))))))))))));
+    }
+    static class A0 { }
+    static class A1 { }
+    static class A2 { }
+    static class A3 { }
+    static class A4 { }
+    <Z extends A0> Z m(A0 t, Callable<Z> ct) { return null; }
+    <Z extends A1> Z m(A1 t, Callable<Z> ct) { return null; }
+    <Z extends A2> Z m(A2 t, Callable<Z> ct) { return null; }
+    <Z extends A3> Z m(A3 t, Callable<Z> ct) { return null; }
+    <Z extends A4> Z m(A4 t, Callable<Z> ct) { return null; }
+    <Z> Z m(Object o, Callable<Z> co) { return null; }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/lambda/speculative/NestedLambdaNoGenerics.java	Tue Sep 15 13:43:44 2015 +0100
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+ /*
+  * @test
+  * @bug 8078093
+  * @summary Exponential performance regression Java 8 compiler compared to Java 7 compiler
+  * @compile NestedLambdaNoGenerics.java
+  */
+import java.util.concurrent.Callable;
+
+class NestedLambdaNoGenerics {
+    void test() {
+        m(null, () -> m(null, () -> m(null, () -> m(null, () -> m(null, () -> m(null, () -> m(null,
+                () -> m(null, () -> m(null, () -> m(null, () -> m(null, () -> m(null, () -> m(null,
+                () -> m(null, () -> m(null, () -> m(null, () -> m(null, () -> m(null, () -> m(null,
+                () -> m(null, () -> m(null, () -> m(null, () -> m(null, () -> m(null, () -> m(null,
+                () -> m(null, () -> m(null, () -> m(null, () -> m(null, () -> m(null, () -> m(null,
+                (Callable<String>)null)))))))))))))))))))))))))))))));
+    }
+    static class A0 { }
+    static class A1 { }
+    static class A2 { }
+    static class A3 { }
+    static class A4 { }
+    String m(A0 t, Callable<A0> ct) { return ""; }
+    String m(A1 t, Callable<A1> ct) { return ""; }
+    String m(A2 t, Callable<A2> ct) { return ""; }
+    String m(A3 t, Callable<A3> ct) { return ""; }
+    String m(A4 t, Callable<A4> ct) { return ""; }
+    String m(Object o, Callable<String> co) { return ""; }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/lambda/speculative/T8055984.java	Tue Sep 15 13:43:44 2015 +0100
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test
+ * @bug 8078093 8055894
+ * @summary Exponential performance regression Java 8 compiler compared to Java 7 compiler
+ * @compile T8055984.java
+ */
+
+class T8055984 {
+    static class C<U> {
+        U fu;
+
+        C() { }
+
+        C(C<U> other) {
+            this.fu = other.fu;
+        }
+
+        C(U fu) {
+            this.fu = fu;
+        }
+    }
+
+    static <U> C<U> m(C<U> src) { return new C<U>(src); }
+
+    static void test() {
+        C<String> c2 = m(new C<>(m(new C<>() )) );
+        C<String> c3 = m(new C<>(m(new C<>(m(new C<>() )) )) );
+        C<String> c4 = m(new C<>(m(new C<>(m(new C<>(m(new C<>() )) )) )) );
+        C<String> c5 = m(new C<>(m(new C<>(m(new C<>(m(new C<>(m(new C<>() )) )) )) )) );
+        C<String> c6 = m(new C<>(m(new C<>(m(new C<>(m(new C<>(m(new C<>(m(new C<>() )) )) )) )) )) );
+        C<String> c7 = m(new C<>(m(new C<>(m(new C<>(m(new C<>(m(new C<>(m(new C<>(m(new C<>() )) )) )) )) )) )) );
+        C<String> c8 = m(new C<>(m(new C<>(m(new C<>(m(new C<>(m(new C<>(m(new C<>(m(new C<>(m(new C<>() )) )) )) )) )) )) )) );
+        C<String> c9 = m(new C<>(m(new C<>(m(new C<>(m(new C<>(m(new C<>(m(new C<>(m(new C<>(m(new C<>(m(new C<>() )) )) )) )) )) )) )) )) );
+        C<String> c10 = m(new C<>(m(new C<>(m(new C<>(m(new C<>(m(new C<>(m(new C<>(m(new C<>(m(new C<>(m(new C<>(m(new C<>())))))))))))))))))));
+    }
+}
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/lambda/speculative/T8077247.java	Tue Sep 15 13:43:44 2015 +0100
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test
+ * @bug 8078093 8077247
+ * @summary Exponential performance regression Java 8 compiler compared to Java 7 compiler
+ * @compile T8077247.java
+ */
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+class T8077247 {
+    public static void test() {
+        int x = add(add(add(add(add(add(add(add(add(add(1, 2), 3), 4), 5), 6), 7), 8), 9), 10), 11);
+    }
+
+    public static int add(int x, int y) {
+        long rslt = (long)x + (long)y;
+        if (Integer.MIN_VALUE <= rslt && rslt <= Integer.MAX_VALUE) {
+            return (int)rslt;
+        }
+
+        String msg = String.format("Integer overflow: %d + %d.", x, y);
+        throw new IllegalArgumentException(msg);
+    }
+
+    public static double add(double x, double y) {
+        double rslt = x + y;
+        if (Double.isInfinite(rslt)) {
+            String msg = String.format("Real overflow: %s + %s.", x, y);
+            throw new IllegalArgumentException(msg);
+        }
+        return (rslt == -0.0) ? 0.0 : rslt;
+    }
+
+    public static <T> List<T> add(List<T> x, List<T> y) {
+        List<T> rslt = new ArrayList<>(x.size() + y.size());
+        rslt.addAll(x);
+        rslt.addAll(y);
+        return rslt;
+    }
+
+    public static String add(String x, String y) {
+        return x + y;
+    }
+
+    public static <K, V> Map<K, V> add(Map<K, V> x, Map<K, V> y) {
+        Map<K, V> rslt = new HashMap<>(x);
+        rslt.putAll(y);
+        return rslt;
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/lambda/speculative/T8078093.java	Tue Sep 15 13:43:44 2015 +0100
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test
+ * @bug 8078093
+ * @summary Exponential performance regression Java 8 compiler compared to Java 7 compiler
+ * @compile T8078093.java
+ */
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+class T8078093 {
+    public static void test() {
+        Map<Integer, String> a = x(x(x(x(x(x(x(x(x(x(x(x(
+                                    new LinkedHashMap<Integer, String>(),
+                                    1, "a"), 2, "b"), 3, "c"), 4, "d"),
+                                    5, "e"), 6, "f"), 7, "g"), 8, "h"),
+                                    9, "i"), 10, "j"), 11, "k"), 12, "l");
+    }
+
+    @SuppressWarnings("unused")
+    public static <K, V> Map<K, V> x(Map<K, V> m, K k, V v) {
+        // Replaced actual code by dummy implementation.
+        return null;
+    }
+}