changeset 2864:816bd88d33a8

8062373: Project Coin: diamond and anonymous classes Summary: Allow diamond inference in combination with anonymous class instance creation Reviewed-by: mcimadamore, vromero Contributed-by: srikanth.adayapalam@oracle.com, maurizio.cimadamore@oracle.com
author sadayapalam
date Mon, 30 Mar 2015 17:09:14 +0530
parents 8e78a3933944
children 82a435ed8d1a
files src/jdk.compiler/share/classes/com/sun/tools/javac/code/Source.java src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Analyzer.java src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Attr.java src/jdk.compiler/share/classes/com/sun/tools/javac/comp/AttrContext.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/Enter.java src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Resolve.java src/jdk.compiler/share/classes/com/sun/tools/javac/resources/compiler.properties src/jdk.compiler/share/classes/com/sun/tools/javac/tree/TreeInfo.java test/tools/javac/classfiles/attributes/innerclasses/InnerClassesInAnonymousClassTest.java test/tools/javac/diags/examples/DiamondAndAnonClass.java test/tools/javac/diags/examples/DiamondAndNonDenotableTypes.java test/tools/javac/failover/CheckAttributedTree.java test/tools/javac/generics/diamond/6939780/T6939780.java test/tools/javac/generics/diamond/6939780/T6939780_7.out test/tools/javac/generics/diamond/6939780/T6939780_8.out test/tools/javac/generics/diamond/6939780/T6939780_9.out test/tools/javac/generics/diamond/6996914/T6996914a.java test/tools/javac/generics/diamond/6996914/T6996914b.java test/tools/javac/generics/diamond/8065986/T8065986b.java test/tools/javac/generics/diamond/8065986/T8065986b.out test/tools/javac/generics/diamond/MultipleInferenceHooksTest.java test/tools/javac/generics/diamond/neg/Neg01.java test/tools/javac/generics/diamond/neg/Neg01.out test/tools/javac/generics/diamond/neg/Neg02.java test/tools/javac/generics/diamond/neg/Neg02.out test/tools/javac/generics/diamond/neg/Neg03.java test/tools/javac/generics/diamond/neg/Neg03.out test/tools/javac/generics/diamond/neg/Neg04.java test/tools/javac/generics/diamond/neg/Neg04.out test/tools/javac/generics/diamond/neg/Neg05.java test/tools/javac/generics/diamond/neg/Neg05.out test/tools/javac/generics/diamond/neg/Neg06.java test/tools/javac/generics/diamond/neg/Neg06.out test/tools/javac/generics/diamond/neg/Neg07.java test/tools/javac/generics/diamond/neg/Neg07.out test/tools/javac/generics/diamond/neg/Neg09.java test/tools/javac/generics/diamond/neg/Neg09.out test/tools/javac/generics/diamond/neg/Neg12.java test/tools/javac/generics/diamond/neg/Neg12.out test/tools/javac/generics/diamond/neg/Neg13.java test/tools/javac/generics/diamond/neg/Neg13.out test/tools/javac/generics/diamond/neg/Neg14.java test/tools/javac/generics/diamond/neg/Neg14.out test/tools/javac/generics/diamond/neg/Neg15.java test/tools/javac/generics/diamond/neg/Neg15.out test/tools/javac/generics/diamond/neg/Neg16.java test/tools/javac/generics/diamond/neg/Neg16.out test/tools/javac/generics/diamond/neg/Neg17.java test/tools/javac/generics/diamond/neg/Neg17.out test/tools/javac/generics/diamond/neg/Neg18.java test/tools/javac/generics/diamond/neg/Neg18.out test/tools/javac/generics/diamond/neg/Neg19.java test/tools/javac/generics/diamond/neg/Neg19.out test/tools/javac/generics/diamond/neg/pkg/Neg18_01.java test/tools/javac/generics/diamond/pos/Pos01.java test/tools/javac/generics/diamond/pos/Pos02.java test/tools/javac/generics/diamond/pos/Pos03.java test/tools/javac/generics/diamond/pos/Pos04.java test/tools/javac/generics/diamond/pos/Pos05.java test/tools/javac/generics/inference/8055963/T8055963.java test/tools/javac/lambda/8066974/T8066974.java test/tools/javac/lambda/8066974/T8066974.out test/tools/javac/lambda/TargetType46.java test/tools/javac/lambda/TargetType46.out test/tools/javac/lambda/TargetType68.java test/tools/javac/lambda/TargetType68.out test/tools/javac/lambda/TargetType69.java test/tools/javac/lambdaShapes/org/openjdk/tests/javac/FDTest.java test/tools/javac/scope/DupUnsharedTest.java
diffstat 71 files changed, 1257 insertions(+), 245 deletions(-) [+]
line wrap: on
line diff
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/code/Source.java	Sat Mar 28 10:18:27 2015 -0700
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/code/Source.java	Mon Mar 30 17:09:14 2015 +0530
@@ -209,6 +209,9 @@
     public boolean allowPrivateSafeVarargs() {
         return compareTo(JDK1_9) >= 0;
     }
+    public boolean allowDiamondWithAnonymousClassCreation() {
+        return compareTo(JDK1_9) >= 0;
+    }
     public boolean allowUnderscoreIdentifier() {
         return compareTo(JDK1_8) <= 0;
     }
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Analyzer.java	Sat Mar 28 10:18:27 2015 -0700
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Analyzer.java	Mon Mar 30 17:09:14 2015 +0530
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2014, 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
@@ -90,6 +90,7 @@
     final DeferredAttr deferredAttr;
     final TreeMaker make;
     final Names names;
+    private final boolean allowDiamondWithAnonymousClassCreation;
 
     final EnumSet<AnalyzerMode> analyzerModes;
 
@@ -112,6 +113,7 @@
         String findOpt = options.get("find");
         //parse modes
         Source source = Source.instance(context);
+        allowDiamondWithAnonymousClassCreation = source.allowDiamondWithAnonymousClassCreation();
         analyzerModes = AnalyzerMode.getAnalyzerModes(findOpt, source);
     }
 
@@ -210,7 +212,7 @@
         boolean match(JCNewClass tree) {
             return tree.clazz.hasTag(TYPEAPPLY) &&
                     !TreeInfo.isDiamond(tree) &&
-                    tree.def == null;
+                    (tree.def == null || allowDiamondWithAnonymousClassCreation);
         }
 
         @Override
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Attr.java	Sat Mar 28 10:18:27 2015 -0700
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Attr.java	Mon Mar 30 17:09:14 2015 +0530
@@ -46,6 +46,10 @@
 import com.sun.tools.javac.comp.Infer.InferenceContext;
 import com.sun.tools.javac.comp.Infer.FreeTypeListener;
 import com.sun.tools.javac.jvm.*;
+import static com.sun.tools.javac.resources.CompilerProperties.Fragments.Diamond;
+import static com.sun.tools.javac.resources.CompilerProperties.Fragments.DiamondInvalidArg;
+import static com.sun.tools.javac.resources.CompilerProperties.Fragments.DiamondInvalidArgs;
+import com.sun.tools.javac.resources.CompilerProperties.Errors;
 import com.sun.tools.javac.resources.CompilerProperties.Fragments;
 import com.sun.tools.javac.tree.*;
 import com.sun.tools.javac.tree.JCTree.*;
@@ -54,6 +58,7 @@
 import com.sun.tools.javac.util.DefinedBy.Api;
 import com.sun.tools.javac.util.Dependencies.AttributionKind;
 import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;
+import com.sun.tools.javac.util.JCDiagnostic.Fragment;
 import com.sun.tools.javac.util.List;
 import static com.sun.tools.javac.code.Flags.*;
 import static com.sun.tools.javac.code.Flags.ANNOTATION;
@@ -219,6 +224,26 @@
                final Type found,
                final KindSelector ownkind,
                final ResultInfo resultInfo) {
+        return check(tree, found, ownkind, resultInfo, true);
+    }
+    /** Check kind and type of given tree against protokind and prototype.
+     *  If check succeeds, store type in tree and return it.
+     *  If check fails, store errType in tree and return it.
+     *  No checks are performed if the prototype is a method type.
+     *  It is not necessary in this case since we know that kind and type
+     *  are correct.
+     *
+     *  @param tree     The tree whose kind and type is checked
+     *  @param found    The computed type of the tree
+     *  @param ownkind  The computed kind of the tree
+     *  @param resultInfo  The expected result of the tree
+     *  @param recheckPostInference If true and inference is underway, arrange to recheck the tree after inference finishes.
+     */
+    Type check(final JCTree tree,
+               final Type found,
+               final KindSelector ownkind,
+               final ResultInfo resultInfo,
+               boolean recheckPostInference) {
         InferenceContext inferenceContext = resultInfo.checkContext.inferenceContext();
         Type owntype;
         boolean shouldCheck = !found.hasTag(ERROR) &&
@@ -233,12 +258,14 @@
             //delay the check if there are inference variables in the found type
             //this means we are dealing with a partially inferred poly expression
             owntype = shouldCheck ? resultInfo.pt : found;
-            inferenceContext.addFreeTypeListener(List.of(found, resultInfo.pt),
-                    instantiatedContext -> {
-                        ResultInfo pendingResult =
-                                resultInfo.dup(inferenceContext.asInstType(resultInfo.pt));
-                        check(tree, inferenceContext.asInstType(found), ownkind, pendingResult);
-                    });
+            if (recheckPostInference) {
+                inferenceContext.addFreeTypeListener(List.of(found, resultInfo.pt),
+                        instantiatedContext -> {
+                            ResultInfo pendingResult =
+                                    resultInfo.dup(inferenceContext.asInstType(resultInfo.pt));
+                            check(tree, inferenceContext.asInstType(found), ownkind, pendingResult, false);
+                        });
+            }
         } else {
             owntype = shouldCheck ?
             resultInfo.check(tree, found) :
@@ -862,7 +889,7 @@
             } else {
                 chk.checkOverrideClashes(tree.pos(), env.enclClass.type, m);
             }
-            chk.checkOverride(tree, m);
+            chk.checkOverride(env, tree, m);
 
             if (isDefaultMethod && types.overridesObjectMethod(m.enclClass(), m)) {
                 log.error(tree, "default.overrides.object.member", m.name, Kinds.kindName(m.location()), m.location());
@@ -1969,11 +1996,16 @@
                  (((JCVariableDecl) env.tree).mods.flags & Flags.ENUM) == 0 ||
                  ((JCVariableDecl) env.tree).init != tree))
                 log.error(tree.pos(), "enum.cant.be.instantiated");
+
+            boolean isSpeculativeDiamondInferenceRound = TreeInfo.isDiamond(tree) &&
+                    resultInfo.checkContext.deferredAttrContext().mode == DeferredAttr.AttrMode.SPECULATIVE;
+            boolean skipNonDiamondPath = false;
             // Check that class is not abstract
-            if (cdef == null &&
+            if (cdef == null && !isSpeculativeDiamondInferenceRound && // class body may be nulled out in speculative tree copy
                 (clazztype.tsym.flags() & (ABSTRACT | INTERFACE)) != 0) {
                 log.error(tree.pos(), "abstract.cant.be.instantiated",
                           clazztype.tsym);
+                skipNonDiamondPath = true;
             } else if (cdef != null && clazztype.tsym.isInterface()) {
                 // Check that no constructor arguments are given to
                 // anonymous classes implementing an interface
@@ -1986,7 +2018,9 @@
                 // Error recovery: pretend no arguments were supplied.
                 argtypes = List.nil();
                 typeargtypes = List.nil();
-            } else if (TreeInfo.isDiamond(tree)) {
+                skipNonDiamondPath = true;
+            }
+            if (TreeInfo.isDiamond(tree)) {
                 ClassType site = new ClassType(clazztype.getEnclosingType(),
                             clazztype.tsym.type.getTypeArguments(),
                                                clazztype.tsym,
@@ -2022,7 +2056,7 @@
 
                 tree.clazz.type = types.createErrorType(clazztype);
                 if (!constructorType.isErroneous()) {
-                    tree.clazz.type = clazztype = constructorType.getReturnType();
+                    tree.clazz.type = clazz.type = constructorType.getReturnType();
                     tree.constructorType = types.createMethodTypeWithReturn(constructorType, syms.voidType);
                 }
                 clazztype = chk.checkClassType(tree.clazz, tree.clazz.type, true);
@@ -2031,7 +2065,7 @@
             // Resolve the called constructor under the assumption
             // that we are referring to a superclass instance of the
             // current instance (JLS ???).
-            else {
+            else if (!skipNonDiamondPath) {
                 //the following code alters some of the fields in the current
                 //AttrContext - hence, the current context must be dup'ed in
                 //order to avoid downstream failures
@@ -2052,70 +2086,8 @@
             }
 
             if (cdef != null) {
-                // We are seeing an anonymous class instance creation.
-                // In this case, the class instance creation
-                // expression
-                //
-                //    E.new <typeargs1>C<typargs2>(args) { ... }
-                //
-                // is represented internally as
-                //
-                //    E . new <typeargs1>C<typargs2>(args) ( class <empty-name> { ... } )  .
-                //
-                // This expression is then *transformed* as follows:
-                //
-                // (1) add an extends or implements clause
-                // (2) add a constructor.
-                //
-                // For instance, if C is a class, and ET is the type of E,
-                // the expression
-                //
-                //    E.new <typeargs1>C<typargs2>(args) { ... }
-                //
-                // is translated to (where X is a fresh name and typarams is the
-                // parameter list of the super constructor):
-                //
-                //   new <typeargs1>X(<*nullchk*>E, args) where
-                //     X extends C<typargs2> {
-                //       <typarams> X(ET e, args) {
-                //         e.<typeargs1>super(args)
-                //       }
-                //       ...
-                //     }
-
-                if (clazztype.tsym.isInterface()) {
-                    cdef.implementing = List.of(clazz);
-                } else {
-                    cdef.extending = clazz;
-                }
-
-                if (resultInfo.checkContext.deferredAttrContext().mode == DeferredAttr.AttrMode.CHECK &&
-                    isSerializable(clazztype)) {
-                    localEnv.info.isSerializable = true;
-                }
-
-                attribStat(cdef, localEnv);
-
-                // If an outer instance is given,
-                // prefix it to the constructor arguments
-                // and delete it from the new expression
-                if (tree.encl != null && !clazztype.tsym.isInterface()) {
-                    tree.args = tree.args.prepend(makeNullCheck(tree.encl));
-                    argtypes = argtypes.prepend(tree.encl.type);
-                    tree.encl = null;
-                }
-
-                // Reassign clazztype and recompute constructor.
-                clazztype = cdef.sym.type;
-                Symbol sym = tree.constructor = rs.resolveConstructor(
-                    tree.pos(), localEnv, clazztype, argtypes, typeargtypes);
-                Assert.check(!sym.kind.isResolutionError());
-                tree.constructor = sym;
-                tree.constructorType = checkId(noCheckTree,
-                    clazztype,
-                    tree.constructor,
-                    localEnv,
-                    new ResultInfo(pkind, newMethodTemplate(syms.voidType, argtypes, typeargtypes)));
+                visitAnonymousClassDefinition(tree, clazz, clazztype, cdef, localEnv, argtypes, typeargtypes, pkind);
+                return;
             }
 
             if (tree.constructor != null && tree.constructor.kind == MTH)
@@ -2133,6 +2105,125 @@
         chk.validate(tree.typeargs, localEnv);
     }
 
+        // where
+        private void visitAnonymousClassDefinition(JCNewClass tree, JCExpression clazz, Type clazztype,
+                                                   JCClassDecl cdef, Env<AttrContext> localEnv,
+                                                   List<Type> argtypes, List<Type> typeargtypes,
+                                                   KindSelector pkind) {
+            // We are seeing an anonymous class instance creation.
+            // In this case, the class instance creation
+            // expression
+            //
+            //    E.new <typeargs1>C<typargs2>(args) { ... }
+            //
+            // is represented internally as
+            //
+            //    E . new <typeargs1>C<typargs2>(args) ( class <empty-name> { ... } )  .
+            //
+            // This expression is then *transformed* as follows:
+            //
+            // (1) add an extends or implements clause
+            // (2) add a constructor.
+            //
+            // For instance, if C is a class, and ET is the type of E,
+            // the expression
+            //
+            //    E.new <typeargs1>C<typargs2>(args) { ... }
+            //
+            // is translated to (where X is a fresh name and typarams is the
+            // parameter list of the super constructor):
+            //
+            //   new <typeargs1>X(<*nullchk*>E, args) where
+            //     X extends C<typargs2> {
+            //       <typarams> X(ET e, args) {
+            //         e.<typeargs1>super(args)
+            //       }
+            //       ...
+            //     }
+            InferenceContext inferenceContext = resultInfo.checkContext.inferenceContext();
+            final boolean isDiamond = TreeInfo.isDiamond(tree);
+            if (isDiamond
+                    && ((tree.constructorType != null && inferenceContext.free(tree.constructorType))
+                    || (tree.clazz.type != null && inferenceContext.free(tree.clazz.type)))) {
+                inferenceContext.addFreeTypeListener(List.of(tree.constructorType, tree.clazz.type),
+                        instantiatedContext -> {
+                            tree.constructorType = instantiatedContext.asInstType(tree.constructorType);
+                            clazz.type = instantiatedContext.asInstType(clazz.type);
+                            visitAnonymousClassDefinition(tree, clazz, clazz.type, cdef, localEnv, argtypes, typeargtypes, pkind);
+                        });
+            } else {
+                if (isDiamond && clazztype.hasTag(CLASS)) {
+                    List<Type> invalidDiamondArgs = chk.checkDiamondDenotable((ClassType)clazztype);
+                    if (!clazztype.isErroneous() && invalidDiamondArgs.nonEmpty()) {
+                        // One or more types inferred in the previous steps is non-denotable.
+                        Fragment fragment = Diamond(clazztype.tsym);
+                        log.error(tree.clazz.pos(),
+                                Errors.CantApplyDiamond1(
+                                        fragment,
+                                        invalidDiamondArgs.size() > 1 ?
+                                                DiamondInvalidArgs(invalidDiamondArgs, fragment) :
+                                                DiamondInvalidArg(invalidDiamondArgs, fragment)));
+                    }
+                    // For <>(){}, inferred types must also be accessible.
+                    for (Type t : clazztype.getTypeArguments()) {
+                        rs.checkAccessibleType(env, t);
+                    }
+                }
+
+                // If we already errored, be careful to avoid a further avalanche. ErrorType answers
+                // false for isInterface call even when the original type is an interface.
+                boolean implementing = clazztype.tsym.isInterface() ||
+                        clazztype.isErroneous() && clazztype.getOriginalType().tsym.isInterface();
+
+                if (implementing) {
+                    cdef.implementing = List.of(clazz);
+                } else {
+                    cdef.extending = clazz;
+                }
+
+                if (resultInfo.checkContext.deferredAttrContext().mode == DeferredAttr.AttrMode.CHECK &&
+                    isSerializable(clazztype)) {
+                    localEnv.info.isSerializable = true;
+                }
+
+                attribStat(cdef, localEnv);
+
+                List<Type> finalargtypes;
+                // If an outer instance is given,
+                // prefix it to the constructor arguments
+                // and delete it from the new expression
+                if (tree.encl != null && !clazztype.tsym.isInterface()) {
+                    tree.args = tree.args.prepend(makeNullCheck(tree.encl));
+                    finalargtypes = argtypes.prepend(tree.encl.type);
+                    tree.encl = null;
+                } else {
+                    finalargtypes = argtypes;
+                }
+
+                // Reassign clazztype and recompute constructor. As this necessarily involves
+                // another attribution pass for deferred types in the case of <>, replicate
+                // them. Original arguments have right decorations already.
+                if (isDiamond && pkind.contains(KindSelector.POLY)) {
+                    finalargtypes = finalargtypes.map(deferredAttr.deferredCopier);
+                }
+
+                clazztype = cdef.sym.type;
+                Symbol sym = tree.constructor = rs.resolveConstructor(
+                        tree.pos(), localEnv, clazztype, finalargtypes, typeargtypes);
+                Assert.check(!sym.kind.isResolutionError());
+                tree.constructor = sym;
+                tree.constructorType = checkId(noCheckTree,
+                        clazztype,
+                        tree.constructor,
+                        localEnv,
+                        new ResultInfo(pkind, newMethodTemplate(syms.voidType, finalargtypes, typeargtypes)));
+            }
+            Type owntype = (tree.constructor != null && tree.constructor.kind == MTH) ?
+                                clazztype : types.createErrorType(tree.type);
+            result = check(tree, owntype, KindSelector.VAL, resultInfo, false);
+            chk.validate(tree.typeargs, localEnv);
+        }
+
     /** Make an attributed null check tree.
      */
     public JCExpression makeNullCheck(JCExpression arg) {
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/AttrContext.java	Sat Mar 28 10:18:27 2015 -0700
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/AttrContext.java	Mon Mar 30 17:09:14 2015 +0530
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1999, 2014, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1999, 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
@@ -63,6 +63,11 @@
      */
     boolean isSpeculative = false;
 
+    /**
+     *  Is this an attribution environment for an anonymous class instantiated using <> ?
+     */
+    boolean isAnonymousDiamond = false;
+
     /** Are arguments to current function applications boxed into an array for varargs?
      */
     Resolve.MethodResolutionPhase pendingResolutionPhase = null;
@@ -100,6 +105,7 @@
         info.defaultSuperCallSite = defaultSuperCallSite;
         info.isSerializable = isSerializable;
         info.isSpeculative = isSpeculative;
+        info.isAnonymousDiamond = isAnonymousDiamond;
         return info;
     }
 
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Check.java	Sat Mar 28 10:18:27 2015 -0700
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Check.java	Mon Mar 30 17:09:14 2015 +0530
@@ -32,6 +32,8 @@
 import com.sun.tools.javac.code.*;
 import com.sun.tools.javac.code.Attribute.Compound;
 import com.sun.tools.javac.jvm.*;
+import com.sun.tools.javac.resources.CompilerProperties.Errors;
+import com.sun.tools.javac.resources.CompilerProperties.Fragments;
 import com.sun.tools.javac.tree.*;
 import com.sun.tools.javac.util.*;
 import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;
@@ -84,6 +86,7 @@
     private boolean suppressAbortOnBadClassFile;
     private boolean enableSunApiLintControl;
     private final JavaFileManager fileManager;
+    private final Source source;
     private final Profile profile;
     private final boolean warnOnAccessToSensitiveMembers;
 
@@ -122,11 +125,12 @@
         lint = Lint.instance(context);
         fileManager = context.get(JavaFileManager.class);
 
-        Source source = Source.instance(context);
+        source = Source.instance(context);
         allowSimplifiedVarargs = source.allowSimplifiedVarargs();
         allowDefaultMethods = source.allowDefaultMethods();
         allowStrictMethodClashCheck = source.allowStrictMethodClashCheck();
         allowPrivateSafeVarargs = source.allowPrivateSafeVarargs();
+        allowDiamondWithAnonymousClassCreation = source.allowDiamondWithAnonymousClassCreation();
         complexInference = options.isSet("complexinference");
         warnOnSyntheticConflicts = options.isSet("warnOnSyntheticConflicts");
         suppressAbortOnBadClassFile = options.isSet("suppressAbortOnBadClassFile");
@@ -169,6 +173,10 @@
      */
     boolean allowPrivateSafeVarargs;
 
+    /** Switch: can diamond inference be used in anonymous instance creation ?
+     */
+    boolean allowDiamondWithAnonymousClassCreation;
+
     /** Switch: -complexinference option set?
      */
     boolean complexInference;
@@ -773,10 +781,9 @@
         if (!TreeInfo.isDiamond(tree) ||
                 t.isErroneous()) {
             return checkClassType(tree.clazz.pos(), t, true);
-        } else if (tree.def != null) {
+        } else if (tree.def != null && !allowDiamondWithAnonymousClassCreation) {
             log.error(tree.clazz.pos(),
-                    "cant.apply.diamond.1",
-                    t, diags.fragment("diamond.and.anon.class", t));
+                    Errors.CantApplyDiamond1(t, Fragments.DiamondAndAnonClassNotSupportedInSource(source.name)));
             return types.createErrorType(t);
         } else if (t.tsym.type.getTypeArguments().isEmpty()) {
             log.error(tree.clazz.pos(),
@@ -794,6 +801,59 @@
         }
     }
 
+    /** Check that the type inferred using the diamond operator does not contain
+     *  non-denotable types such as captured types or intersection types.
+     *  @param t the type inferred using the diamond operator
+     *  @return  the (possibly empty) list of non-denotable types.
+     */
+    List<Type> checkDiamondDenotable(ClassType t) {
+        ListBuffer<Type> buf = new ListBuffer<>();
+        for (Type arg : t.getTypeArguments()) {
+            if (!diamondTypeChecker.visit(arg, null)) {
+                buf.append(arg);
+            }
+        }
+        return buf.toList();
+    }
+        // where
+
+        /** diamondTypeChecker: A type visitor that descends down the given type looking for non-denotable
+         *  types. The visit methods return false as soon as a non-denotable type is encountered and true
+         *  otherwise.
+         */
+        private static final Types.SimpleVisitor<Boolean, Void> diamondTypeChecker = new Types.SimpleVisitor<Boolean, Void>() {
+            @Override
+            public Boolean visitType(Type t, Void s) {
+                return true;
+            }
+            @Override
+            public Boolean visitClassType(ClassType t, Void s) {
+                if (t.isCompound()) {
+                    return false;
+                }
+                for (Type targ : t.getTypeArguments()) {
+                    if (!visit(targ, s)) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+            @Override
+            public Boolean visitCapturedType(CapturedType t, Void s) {
+                return false;
+            }
+
+            @Override
+            public Boolean visitArrayType(ArrayType t, Void s) {
+                return visit(t.elemtype, s);
+            }
+
+            @Override
+            public Boolean visitWildcardType(WildcardType t, Void s) {
+                return visit(t.type, s);
+            }
+        };
+
     void checkVarargsMethodDecl(Env<AttrContext> env, JCMethodDecl tree) {
         MethodSymbol m = tree.sym;
         if (!allowSimplifiedVarargs) return;
@@ -1917,7 +1977,7 @@
      *                      for errors.
      *  @param m            The overriding method.
      */
-    void checkOverride(JCMethodDecl tree, MethodSymbol m) {
+    void checkOverride(Env<AttrContext> env, JCMethodDecl tree, MethodSymbol m) {
         ClassSymbol origin = (ClassSymbol)m.owner;
         if ((origin.flags() & ENUM) != 0 && names.finalize.equals(m.name))
             if (m.overrides(syms.enumFinalFinalize, origin, types, false)) {
@@ -1934,7 +1994,12 @@
             }
         }
 
-        if (m.attribute(syms.overrideType.tsym) != null && !isOverrider(m)) {
+        // Check if this method must override a super method due to being annotated with @Override
+        // or by virtue of being a member of a diamond inferred anonymous class. Latter case is to
+        // be treated "as if as they were annotated" with @Override.
+        boolean mustOverride = m.attribute(syms.overrideType.tsym) != null ||
+                (env.info.isAnonymousDiamond && !m.isConstructor() && !m.isPrivate());
+        if (mustOverride && !isOverrider(m)) {
             DiagnosticPosition pos = tree.pos();
             for (JCAnnotation a : tree.getModifiers().annotations) {
                 if (a.annotationType.type.tsym == syms.overrideType.tsym) {
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/DeferredAttr.java	Sat Mar 28 10:18:27 2015 -0700
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/DeferredAttr.java	Mon Mar 30 17:09:14 2015 +0530
@@ -26,6 +26,7 @@
 package com.sun.tools.javac.comp;
 
 import com.sun.source.tree.LambdaExpressionTree.BodyKind;
+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.Resolve.ResolveError;
@@ -81,6 +82,8 @@
     final Log log;
     final Symtab syms;
     final TreeMaker make;
+    final TreeCopier<Void> treeCopier;
+    final TypeMapping<Void> deferredCopier;
     final Types types;
     final Flow flow;
     final Names names;
@@ -125,6 +128,35 @@
                     return "Empty deferred context!";
                 }
             };
+
+        // For speculative attribution, skip the class definition in <>.
+        treeCopier =
+            new TreeCopier<Void>(make) {
+                @Override @DefinedBy(Api.COMPILER_TREE)
+                public JCTree visitNewClass(NewClassTree node, Void p) {
+                    JCNewClass t = (JCNewClass) node;
+                    if (TreeInfo.isDiamond(t)) {
+                        JCExpression encl = copy(t.encl, p);
+                        List<JCExpression> typeargs = copy(t.typeargs, p);
+                        JCExpression clazz = copy(t.clazz, p);
+                        List<JCExpression> args = copy(t.args, p);
+                        JCClassDecl def = null;
+                        return make.at(t.pos).NewClass(encl, typeargs, clazz, args, def);
+                    } else {
+                        return super.visitNewClass(node, p);
+                    }
+                }
+            };
+        deferredCopier = new TypeMapping<Void> () {
+                @Override
+                public Type visitType(Type t, Void v) {
+                    if (t.hasTag(DEFERRED)) {
+                        DeferredType dt = (DeferredType) t;
+                        return new DeferredType(treeCopier.copy(dt.tree), dt.env);
+                    }
+                    return t;
+                }
+            };
     }
 
     /** shared tree for stuck expressions */
@@ -364,7 +396,7 @@
      * disabled during speculative type-checking.
      */
     JCTree attribSpeculative(JCTree tree, Env<AttrContext> env, ResultInfo resultInfo) {
-        return attribSpeculative(tree, env, resultInfo, new TreeCopier<>(make),
+        return attribSpeculative(tree, env, resultInfo, treeCopier,
                 (newTree)->new DeferredAttrDiagHandler(log, newTree));
     }
 
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Enter.java	Sat Mar 28 10:18:27 2015 -0700
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Enter.java	Mon Mar 30 17:09:14 2015 +0530
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1999, 2014, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1999, 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
@@ -192,6 +192,7 @@
         localEnv.info.isSelfCall = false;
         localEnv.info.lint = null; // leave this to be filled in by Attr,
                                    // when annotations have been processed
+        localEnv.info.isAnonymousDiamond = TreeInfo.isDiamond(env.tree);
         return localEnv;
     }
 
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Resolve.java	Sat Mar 28 10:18:27 2015 -0700
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Resolve.java	Mon Mar 30 17:09:14 2015 +0530
@@ -2555,7 +2555,8 @@
                               boolean allowBoxing,
                               boolean useVarargs) {
         Symbol bestSoFar = methodNotFound;
-        for (final Symbol sym : site.tsym.members().getSymbolsByName(names.init)) {
+        TypeSymbol tsym = site.tsym.isInterface() ? syms.objectType.tsym : site.tsym;
+        for (final Symbol sym : tsym.members().getSymbolsByName(names.init)) {
             //- System.out.println(" e " + e.sym);
             if (sym.kind == MTH &&
                 (sym.flags_field & SYNTHETIC) == 0) {
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/resources/compiler.properties	Sat Mar 28 10:18:27 2015 -0700
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/resources/compiler.properties	Mon Mar 30 17:09:14 2015 +0530
@@ -2010,6 +2010,16 @@
 compiler.misc.diamond.non.generic=\
     cannot use ''<>'' with non-generic class {0}
 
+# 0: list of type, 1: message segment
+compiler.misc.diamond.invalid.arg=\
+    type argument {0} inferred for {1} is not allowed in this context\n\
+    inferred argument is not expressible in the Signature attribute
+
+# 0: list of type, 1: message segment
+compiler.misc.diamond.invalid.args=\
+    type arguments {0} inferred for {1} are not allowed in this context\n\
+    inferred arguments are not expressible in the Signature attribute
+
 # 0: unused
 compiler.misc.diamond.and.explicit.params=\
     cannot use ''<>'' with explicit type parameters for constructor
@@ -2271,10 +2281,6 @@
 compiler.misc.varargs.clash.with=\
     {0} in {1} overrides {2} in {3}
 
-# 0: unused
-compiler.misc.diamond.and.anon.class=\
-    cannot use ''<>'' with anonymous inner classes
-
 # 0: symbol kind, 1: symbol, 2: symbol, 3: message segment
 compiler.misc.inapplicable.method=\
     {0} {1}.{2} is not applicable\n\
@@ -2284,6 +2290,11 @@
 # Diagnostics for language feature changes
 ########################################
 # 0: string
+compiler.misc.diamond.and.anon.class.not.supported.in.source=\
+    cannot use ''<>'' with anonymous inner classes in -source {0}\n\
+    (use -source 9 or higher to enable ''<>'' with anonymous inner classes)
+
+# 0: string
 compiler.err.unsupported.binary.lit=\
     binary literals are not supported in -source {0}\n\
     (use -source 7 or higher to enable binary literals)
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/tree/TreeInfo.java	Sat Mar 28 10:18:27 2015 -0700
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/tree/TreeInfo.java	Mon Mar 30 17:09:14 2015 +0530
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1999, 2014, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1999, 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
@@ -190,6 +190,18 @@
         }
     }
 
+    /** Return true if the given tree represents a type elided anonymous class instance creation. */
+    public static boolean isAnonymousDiamond(JCTree tree) {
+        switch(tree.getTag()) {
+            case NEWCLASS:  {
+                JCNewClass nc = (JCNewClass)tree;
+                return nc.def != null && isDiamond(nc.clazz);
+            }
+            case ANNOTATED_TYPE: return isAnonymousDiamond(((JCAnnotatedType)tree).underlyingType);
+            default: return false;
+        }
+    }
+
     public static boolean isEnumInit(JCTree tree) {
         switch (tree.getTag()) {
             case VARDEF:
--- a/test/tools/javac/classfiles/attributes/innerclasses/InnerClassesInAnonymousClassTest.java	Sat Mar 28 10:18:27 2015 -0700
+++ b/test/tools/javac/classfiles/attributes/innerclasses/InnerClassesInAnonymousClassTest.java	Mon Mar 30 17:09:14 2015 +0530
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2014, 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
@@ -23,7 +23,7 @@
 
 /*
  * @test
- * @bug 8042251
+ * @bug 8042251 8062373
  * @summary Testing InnerClasses_attribute of inner classes in anonymous class.
  * @library /tools/lib /tools/javac/lib ../lib
  * @build InnerClassesTestBase TestResult TestBase InMemoryFileManager ToolBox
@@ -73,6 +73,6 @@
     public void getAdditionalFlags(Map<String, Set<String>> class2Flags, ClassType type, Modifier... flags) {
         super.getAdditionalFlags(class2Flags, type, flags);
         class2Flags.put("Anonymous", getFlags(currentClassType, Arrays.asList(flags)));
-        class2Flags.put("1", new HashSet<>());
+        class2Flags.put("1", new HashSet<>() {});
     }
 }
--- a/test/tools/javac/diags/examples/DiamondAndAnonClass.java	Sat Mar 28 10:18:27 2015 -0700
+++ b/test/tools/javac/diags/examples/DiamondAndAnonClass.java	Mon Mar 30 17:09:14 2015 +0530
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2011, 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
@@ -21,8 +21,10 @@
  * questions.
  */
 
-// key: compiler.misc.diamond.and.anon.class
+// key: compiler.misc.diamond.and.anon.class.not.supported.in.source
 // key: compiler.err.cant.apply.diamond.1
+// key: compiler.warn.source.no.bootclasspath
+// options: -source 8
 
 import java.util.*;
 
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/diags/examples/DiamondAndNonDenotableTypes.java	Mon Mar 30 17:09:14 2015 +0530
@@ -0,0 +1,42 @@
+/*
+ * 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.
+ *
+ * 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.
+ */
+
+// key: compiler.misc.diamond
+// key: compiler.err.cant.apply.diamond.1
+// key: compiler.misc.diamond.invalid.arg
+// key: compiler.misc.diamond.invalid.args
+
+import java.util.*;
+
+class DiamondAndNonDenotableType<T> {
+    DiamondAndNonDenotableType(T t) {}
+}
+
+class DiamondAndNonDenotableTypes<T, S> {
+    DiamondAndNonDenotableTypes(T t, S s) {}
+    void m() {
+        List<?> wl = null;
+        new DiamondAndNonDenotableTypes<>(wl, wl) {};
+        new DiamondAndNonDenotableType<>(wl) {};
+    };
+}
--- a/test/tools/javac/failover/CheckAttributedTree.java	Sat Mar 28 10:18:27 2015 -0700
+++ b/test/tools/javac/failover/CheckAttributedTree.java	Mon Mar 30 17:09:14 2015 +0530
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2010, 2014, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2010, 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
@@ -23,7 +23,7 @@
 
 /*
  * @test
- * @bug 6970584 8006694
+ * @bug 6970584 8006694 8062373
  * @summary assorted position errors in compiler syntax trees
  *  temporarily workaround combo tests are causing time out in several platforms
  * @library ../lib
@@ -290,7 +290,7 @@
             }
             public void finished(TaskEvent e) { }
         });
-
+        int i = 0;
         try {
             Iterable<? extends CompilationUnitTree> trees = task.parse();
 //            JavaCompiler c = JavaCompiler.instance(((JavacTaskImpl) task).getContext());
@@ -308,7 +308,7 @@
                    if (def.hasTag(CLASSDEF) &&
                            analyzedElems.contains(((JCTree.JCClassDecl)def).sym)) {
                        //System.err.println("Adding pair..." + cu.sourcefile + " " + ((JCTree.JCClassDecl) def).name);
-                       res.add(new Pair<>(cu, def));
+                       res.add((i++ % 2) == 0 ? new Pair<>(cu, def) {} : new Pair<>(cu, def));
                    }
                }
             }
--- a/test/tools/javac/generics/diamond/6939780/T6939780.java	Sat Mar 28 10:18:27 2015 -0700
+++ b/test/tools/javac/generics/diamond/6939780/T6939780.java	Mon Mar 30 17:09:14 2015 +0530
@@ -1,11 +1,12 @@
 /*
  * @test /nodynamiccopyright/
- * @bug 6939780 7020044 8009459 8021338 8064365
+ * @bug 6939780 7020044 8009459 8021338 8064365 8062373
  *
- * @summary  add a warning to detect diamond sites
+ * @summary  add a warning to detect diamond sites (including anonymous class instance creation at source >= 9)
  * @author mcimadamore
  * @compile/ref=T6939780_7.out -Xlint:-options -source 7 T6939780.java -XDrawDiagnostics -XDfind=diamond
- * @compile/ref=T6939780_8.out T6939780.java -XDrawDiagnostics -XDfind=diamond
+ * @compile/ref=T6939780_8.out -Xlint:-options -source 8 T6939780.java -XDrawDiagnostics -XDfind=diamond
+ * @compile/ref=T6939780_9.out -Xlint:-options -source 9 T6939780.java -XDrawDiagnostics -XDfind=diamond
  *
  */
 
--- a/test/tools/javac/generics/diamond/6939780/T6939780_7.out	Sat Mar 28 10:18:27 2015 -0700
+++ b/test/tools/javac/generics/diamond/6939780/T6939780_7.out	Mon Mar 30 17:09:14 2015 +0530
@@ -1,5 +1,5 @@
-T6939780.java:21:28: compiler.warn.diamond.redundant.args
-T6939780.java:22:28: compiler.warn.diamond.redundant.args.1: T6939780.Foo<java.lang.Integer>, T6939780.Foo<java.lang.Number>
-T6939780.java:30:19: compiler.warn.diamond.redundant.args
-T6939780.java:31:19: compiler.warn.diamond.redundant.args.1: T6939780.Foo<java.lang.Integer>, T6939780.Foo<java.lang.Number>
+T6939780.java:22:28: compiler.warn.diamond.redundant.args
+T6939780.java:23:28: compiler.warn.diamond.redundant.args.1: T6939780.Foo<java.lang.Integer>, T6939780.Foo<java.lang.Number>
+T6939780.java:31:19: compiler.warn.diamond.redundant.args
+T6939780.java:32:19: compiler.warn.diamond.redundant.args.1: T6939780.Foo<java.lang.Integer>, T6939780.Foo<java.lang.Number>
 4 warnings
--- a/test/tools/javac/generics/diamond/6939780/T6939780_8.out	Sat Mar 28 10:18:27 2015 -0700
+++ b/test/tools/javac/generics/diamond/6939780/T6939780_8.out	Mon Mar 30 17:09:14 2015 +0530
@@ -1,7 +1,7 @@
-T6939780.java:20:33: compiler.warn.diamond.redundant.args
-T6939780.java:21:28: compiler.warn.diamond.redundant.args
-T6939780.java:22:28: compiler.warn.diamond.redundant.args.1: T6939780.Foo<java.lang.Integer>, T6939780.Foo<java.lang.Number>
-T6939780.java:29:19: compiler.warn.diamond.redundant.args
+T6939780.java:21:33: compiler.warn.diamond.redundant.args
+T6939780.java:22:28: compiler.warn.diamond.redundant.args
+T6939780.java:23:28: compiler.warn.diamond.redundant.args.1: T6939780.Foo<java.lang.Integer>, T6939780.Foo<java.lang.Number>
 T6939780.java:30:19: compiler.warn.diamond.redundant.args
-T6939780.java:31:19: compiler.warn.diamond.redundant.args.1: T6939780.Foo<java.lang.Integer>, T6939780.Foo<java.lang.Number>
+T6939780.java:31:19: compiler.warn.diamond.redundant.args
+T6939780.java:32:19: compiler.warn.diamond.redundant.args.1: T6939780.Foo<java.lang.Integer>, T6939780.Foo<java.lang.Number>
 6 warnings
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/generics/diamond/6939780/T6939780_9.out	Mon Mar 30 17:09:14 2015 +0530
@@ -0,0 +1,13 @@
+T6939780.java:21:33: compiler.warn.diamond.redundant.args
+T6939780.java:22:28: compiler.warn.diamond.redundant.args
+T6939780.java:23:28: compiler.warn.diamond.redundant.args.1: T6939780.Foo<java.lang.Integer>, T6939780.Foo<java.lang.Number>
+T6939780.java:24:33: compiler.warn.diamond.redundant.args
+T6939780.java:25:28: compiler.warn.diamond.redundant.args
+T6939780.java:26:28: compiler.warn.diamond.redundant.args
+T6939780.java:30:19: compiler.warn.diamond.redundant.args
+T6939780.java:31:19: compiler.warn.diamond.redundant.args
+T6939780.java:32:19: compiler.warn.diamond.redundant.args.1: T6939780.Foo<java.lang.Integer>, T6939780.Foo<java.lang.Number>
+T6939780.java:33:19: compiler.warn.diamond.redundant.args
+T6939780.java:34:19: compiler.warn.diamond.redundant.args
+T6939780.java:35:19: compiler.warn.diamond.redundant.args
+12 warnings
--- a/test/tools/javac/generics/diamond/6996914/T6996914a.java	Sat Mar 28 10:18:27 2015 -0700
+++ b/test/tools/javac/generics/diamond/6996914/T6996914a.java	Mon Mar 30 17:09:14 2015 +0530
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2010, 2011, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2010, 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
@@ -23,7 +23,7 @@
 
 /*
  * @test
- * @bug 6996914 7020044
+ * @bug 6996914 7020044 8062373
  * @summary  Diamond inference: problem when accessing protected constructor
  * @run main T6996914a
  */
@@ -53,6 +53,17 @@
         }
     }
 
+    enum DiamondKind {
+        STANDARD("new Foo<>();"),
+        ANON("new Foo<>() {};");
+
+        String expr;
+
+        DiamondKind(String expr) {
+            this.expr = expr;
+        }
+    }
+
     enum ConstructorKind {
         PACKAGE(""),
         PROTECTED("protected"),
@@ -93,14 +104,14 @@
         final static String sourceStub =
                         "#I\n" +
                         "class Test {\n" +
-                        "  Foo<String> fs = new Foo<>();\n" +
+                        "  Foo<String> fs = #D\n" +
                         "}\n";
 
         String source;
 
-        public ClientClass(PackageKind pk) {
+        public ClientClass(PackageKind pk, DiamondKind dk) {
             super(URI.create("myfo:/Test.java"), JavaFileObject.Kind.SOURCE);
-            source = sourceStub.replace("#I", pk.importDecl);
+            source = sourceStub.replace("#I", pk.importDecl).replace("#D", dk.expr);
         }
 
         @Override
@@ -112,20 +123,22 @@
     public static void main(String... args) throws Exception {
         for (PackageKind pk : PackageKind.values()) {
             for (ConstructorKind ck : ConstructorKind.values()) {
-                    compileAndCheck(pk, ck);
+                for (DiamondKind dk : DiamondKind.values()) {
+                    compileAndCheck(pk, ck, dk);
+                }
             }
         }
     }
 
-    static void compileAndCheck(PackageKind pk, ConstructorKind ck) throws Exception {
+    static void compileAndCheck(PackageKind pk, ConstructorKind ck, DiamondKind dk) throws Exception {
         FooClass foo = new FooClass(pk, ck);
-        ClientClass client = new ClientClass(pk);
+        ClientClass client = new ClientClass(pk, dk);
         final JavaCompiler tool = ToolProvider.getSystemJavaCompiler();
         ErrorListener el = new ErrorListener();
         JavacTask ct = (JavacTask)tool.getTask(null, null, el,
                 null, null, Arrays.asList(foo, client));
         ct.analyze();
-        if (el.errors > 0 == check(pk, ck)) {
+        if (el.errors > 0 == check(pk, ck, dk)) {
             String msg = el.errors > 0 ?
                 "Error compiling files" :
                 "No error when compiling files";
@@ -133,9 +146,10 @@
         }
     }
 
-    static boolean check(PackageKind pk, ConstructorKind ck) {
+    static boolean check(PackageKind pk, ConstructorKind ck, DiamondKind dk) {
         switch (pk) {
-            case A: return ck == ConstructorKind.PUBLIC;
+            case A: return ck == ConstructorKind.PUBLIC ||
+                    (ck  == ConstructorKind.PROTECTED && dk == DiamondKind.ANON);
             case DEFAULT: return ck != ConstructorKind.PRIVATE;
             default: throw new AssertionError("Unknown package kind");
         }
--- a/test/tools/javac/generics/diamond/6996914/T6996914b.java	Sat Mar 28 10:18:27 2015 -0700
+++ b/test/tools/javac/generics/diamond/6996914/T6996914b.java	Mon Mar 30 17:09:14 2015 +0530
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2010, 2011, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2010, 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
@@ -23,7 +23,7 @@
 
 /*
  * @test
- * @bug 6996914 7020044
+ * @bug 6996914 7020044 8062373
  * @summary  Diamond inference: problem when accessing protected constructor
  * @compile T6996914b.java
  */
@@ -35,4 +35,5 @@
 
 class Test {
     Super<String,Integer> ssi1 = new Super<>(1, "", 2);
+    Super<String,Integer> ssi2 = new Super<>(1, "", 2) {};
 }
--- a/test/tools/javac/generics/diamond/8065986/T8065986b.java	Sat Mar 28 10:18:27 2015 -0700
+++ b/test/tools/javac/generics/diamond/8065986/T8065986b.java	Mon Mar 30 17:09:14 2015 +0530
@@ -1,6 +1,6 @@
 /*
  * @test /nodynamiccopyright/
- * @bug 8065986
+ * @bug 8065986 8062373
  *
  * @summary Compiler fails to NullPointerException when calling super with Object<>()
  * @compile/fail/ref=T8065986b.out T8065986b.java -XDrawDiagnostics
@@ -29,5 +29,12 @@
         this(cond ? o1 : o2);
     }
 
+    T8065986b(int x) {
+        this(new Object<>() {});
+    }
+
+    T8065986b(int x, int y) {
+        this(new ArrayList<>() {});
+    }
     static void m() { }
 }
--- a/test/tools/javac/generics/diamond/8065986/T8065986b.out	Sat Mar 28 10:18:27 2015 -0700
+++ b/test/tools/javac/generics/diamond/8065986/T8065986b.out	Mon Mar 30 17:09:14 2015 +0530
@@ -1,6 +1,8 @@
 T8065986b.java:13:24: compiler.err.cant.apply.diamond.1: java.lang.Object, (compiler.misc.diamond.non.generic: java.lang.Object)
-T8065986b.java:17:9: compiler.err.cant.apply.symbols: kindname.constructor, T8065986b, java.util.ArrayList<java.lang.Object>,{(compiler.misc.inapplicable.method: kindname.constructor, T8065986b, T8065986b(), (compiler.misc.arg.length.mismatch)),(compiler.misc.inapplicable.method: kindname.constructor, T8065986b, T8065986b(boolean), (compiler.misc.no.conforming.assignment.exists: (compiler.misc.cant.apply.diamond.1: (compiler.misc.diamond: java.util.ArrayList), (compiler.misc.infer.no.conforming.instance.exists: E, java.util.ArrayList<E>, boolean)))),(compiler.misc.inapplicable.method: kindname.constructor, T8065986b, T8065986b(boolean,boolean), (compiler.misc.arg.length.mismatch)),(compiler.misc.inapplicable.method: kindname.constructor, T8065986b, T8065986b(boolean,boolean,boolean), (compiler.misc.arg.length.mismatch)),(compiler.misc.inapplicable.method: kindname.constructor, T8065986b, T8065986b(boolean,java.lang.Object,java.lang.Object), (compiler.misc.arg.length.mismatch))}
-T8065986b.java:21:9: compiler.err.cant.apply.symbols: kindname.constructor, T8065986b, @435,{(compiler.misc.inapplicable.method: kindname.constructor, T8065986b, T8065986b(), (compiler.misc.arg.length.mismatch)),(compiler.misc.inapplicable.method: kindname.constructor, T8065986b, T8065986b(boolean), (compiler.misc.no.conforming.assignment.exists: (compiler.misc.not.a.functional.intf: boolean))),(compiler.misc.inapplicable.method: kindname.constructor, T8065986b, T8065986b(boolean,boolean), (compiler.misc.arg.length.mismatch)),(compiler.misc.inapplicable.method: kindname.constructor, T8065986b, T8065986b(boolean,boolean,boolean), (compiler.misc.arg.length.mismatch)),(compiler.misc.inapplicable.method: kindname.constructor, T8065986b, T8065986b(boolean,java.lang.Object,java.lang.Object), (compiler.misc.arg.length.mismatch))}
-T8065986b.java:25:9: compiler.err.cant.apply.symbols: kindname.constructor, T8065986b, @516,{(compiler.misc.inapplicable.method: kindname.constructor, T8065986b, T8065986b(), (compiler.misc.arg.length.mismatch)),(compiler.misc.inapplicable.method: kindname.constructor, T8065986b, T8065986b(boolean), (compiler.misc.no.conforming.assignment.exists: (compiler.misc.not.a.functional.intf: boolean))),(compiler.misc.inapplicable.method: kindname.constructor, T8065986b, T8065986b(boolean,boolean), (compiler.misc.arg.length.mismatch)),(compiler.misc.inapplicable.method: kindname.constructor, T8065986b, T8065986b(boolean,boolean,boolean), (compiler.misc.arg.length.mismatch)),(compiler.misc.inapplicable.method: kindname.constructor, T8065986b, T8065986b(boolean,java.lang.Object,java.lang.Object), (compiler.misc.arg.length.mismatch))}
-T8065986b.java:29:9: compiler.err.cant.apply.symbols: kindname.constructor, T8065986b, @603,{(compiler.misc.inapplicable.method: kindname.constructor, T8065986b, T8065986b(), (compiler.misc.arg.length.mismatch)),(compiler.misc.inapplicable.method: kindname.constructor, T8065986b, T8065986b(boolean), (compiler.misc.no.conforming.assignment.exists: (compiler.misc.incompatible.type.in.conditional: (compiler.misc.inconvertible.types: java.lang.Object, boolean)))),(compiler.misc.inapplicable.method: kindname.constructor, T8065986b, T8065986b(boolean,boolean), (compiler.misc.arg.length.mismatch)),(compiler.misc.inapplicable.method: kindname.constructor, T8065986b, T8065986b(boolean,boolean,boolean), (compiler.misc.arg.length.mismatch)),(compiler.misc.inapplicable.method: kindname.constructor, T8065986b, T8065986b(boolean,java.lang.Object,java.lang.Object), (compiler.misc.arg.length.mismatch))}
-5 errors
+T8065986b.java:17:9: compiler.err.cant.apply.symbols: kindname.constructor, T8065986b, java.util.ArrayList<java.lang.Object>,{(compiler.misc.inapplicable.method: kindname.constructor, T8065986b, T8065986b(), (compiler.misc.arg.length.mismatch)),(compiler.misc.inapplicable.method: kindname.constructor, T8065986b, T8065986b(boolean), (compiler.misc.no.conforming.assignment.exists: (compiler.misc.cant.apply.diamond.1: (compiler.misc.diamond: java.util.ArrayList), (compiler.misc.infer.no.conforming.instance.exists: E, java.util.ArrayList<E>, boolean)))),(compiler.misc.inapplicable.method: kindname.constructor, T8065986b, T8065986b(boolean,boolean), (compiler.misc.arg.length.mismatch)),(compiler.misc.inapplicable.method: kindname.constructor, T8065986b, T8065986b(boolean,boolean,boolean), (compiler.misc.arg.length.mismatch)),(compiler.misc.inapplicable.method: kindname.constructor, T8065986b, T8065986b(boolean,java.lang.Object,java.lang.Object), (compiler.misc.arg.length.mismatch)),(compiler.misc.inapplicable.method: kindname.constructor, T8065986b, T8065986b(int), (compiler.misc.no.conforming.assignment.exists: (compiler.misc.cant.apply.diamond.1: (compiler.misc.diamond: java.util.ArrayList), (compiler.misc.infer.no.conforming.instance.exists: E, java.util.ArrayList<E>, int)))),(compiler.misc.inapplicable.method: kindname.constructor, T8065986b, T8065986b(int,int), (compiler.misc.arg.length.mismatch))}
+T8065986b.java:21:9: compiler.err.cant.apply.symbols: kindname.constructor, T8065986b, @443,{(compiler.misc.inapplicable.method: kindname.constructor, T8065986b, T8065986b(), (compiler.misc.arg.length.mismatch)),(compiler.misc.inapplicable.method: kindname.constructor, T8065986b, T8065986b(boolean), (compiler.misc.no.conforming.assignment.exists: (compiler.misc.not.a.functional.intf: boolean))),(compiler.misc.inapplicable.method: kindname.constructor, T8065986b, T8065986b(boolean,boolean), (compiler.misc.arg.length.mismatch)),(compiler.misc.inapplicable.method: kindname.constructor, T8065986b, T8065986b(boolean,boolean,boolean), (compiler.misc.arg.length.mismatch)),(compiler.misc.inapplicable.method: kindname.constructor, T8065986b, T8065986b(boolean,java.lang.Object,java.lang.Object), (compiler.misc.arg.length.mismatch)),(compiler.misc.inapplicable.method: kindname.constructor, T8065986b, T8065986b(int), (compiler.misc.no.conforming.assignment.exists: (compiler.misc.not.a.functional.intf: int))),(compiler.misc.inapplicable.method: kindname.constructor, T8065986b, T8065986b(int,int), (compiler.misc.arg.length.mismatch))}
+T8065986b.java:25:9: compiler.err.cant.apply.symbols: kindname.constructor, T8065986b, @524,{(compiler.misc.inapplicable.method: kindname.constructor, T8065986b, T8065986b(), (compiler.misc.arg.length.mismatch)),(compiler.misc.inapplicable.method: kindname.constructor, T8065986b, T8065986b(boolean), (compiler.misc.no.conforming.assignment.exists: (compiler.misc.not.a.functional.intf: boolean))),(compiler.misc.inapplicable.method: kindname.constructor, T8065986b, T8065986b(boolean,boolean), (compiler.misc.arg.length.mismatch)),(compiler.misc.inapplicable.method: kindname.constructor, T8065986b, T8065986b(boolean,boolean,boolean), (compiler.misc.arg.length.mismatch)),(compiler.misc.inapplicable.method: kindname.constructor, T8065986b, T8065986b(boolean,java.lang.Object,java.lang.Object), (compiler.misc.arg.length.mismatch)),(compiler.misc.inapplicable.method: kindname.constructor, T8065986b, T8065986b(int), (compiler.misc.no.conforming.assignment.exists: (compiler.misc.not.a.functional.intf: int))),(compiler.misc.inapplicable.method: kindname.constructor, T8065986b, T8065986b(int,int), (compiler.misc.arg.length.mismatch))}
+T8065986b.java:29:9: compiler.err.cant.apply.symbols: kindname.constructor, T8065986b, @611,{(compiler.misc.inapplicable.method: kindname.constructor, T8065986b, T8065986b(), (compiler.misc.arg.length.mismatch)),(compiler.misc.inapplicable.method: kindname.constructor, T8065986b, T8065986b(boolean), (compiler.misc.no.conforming.assignment.exists: (compiler.misc.incompatible.type.in.conditional: (compiler.misc.inconvertible.types: java.lang.Object, boolean)))),(compiler.misc.inapplicable.method: kindname.constructor, T8065986b, T8065986b(boolean,boolean), (compiler.misc.arg.length.mismatch)),(compiler.misc.inapplicable.method: kindname.constructor, T8065986b, T8065986b(boolean,boolean,boolean), (compiler.misc.arg.length.mismatch)),(compiler.misc.inapplicable.method: kindname.constructor, T8065986b, T8065986b(boolean,java.lang.Object,java.lang.Object), (compiler.misc.arg.length.mismatch)),(compiler.misc.inapplicable.method: kindname.constructor, T8065986b, T8065986b(int), (compiler.misc.no.conforming.assignment.exists: (compiler.misc.incompatible.type.in.conditional: (compiler.misc.inconvertible.types: java.lang.Object, int)))),(compiler.misc.inapplicable.method: kindname.constructor, T8065986b, T8065986b(int,int), (compiler.misc.arg.length.mismatch))}
+T8065986b.java:33:24: compiler.err.cant.apply.diamond.1: java.lang.Object, (compiler.misc.diamond.non.generic: java.lang.Object)
+T8065986b.java:37:9: compiler.err.cant.apply.symbols: kindname.constructor, T8065986b, java.util.ArrayList<java.lang.Object>,{(compiler.misc.inapplicable.method: kindname.constructor, T8065986b, T8065986b(), (compiler.misc.arg.length.mismatch)),(compiler.misc.inapplicable.method: kindname.constructor, T8065986b, T8065986b(boolean), (compiler.misc.no.conforming.assignment.exists: (compiler.misc.cant.apply.diamond.1: (compiler.misc.diamond: java.util.ArrayList), (compiler.misc.infer.no.conforming.instance.exists: E, java.util.ArrayList<E>, boolean)))),(compiler.misc.inapplicable.method: kindname.constructor, T8065986b, T8065986b(boolean,boolean), (compiler.misc.arg.length.mismatch)),(compiler.misc.inapplicable.method: kindname.constructor, T8065986b, T8065986b(boolean,boolean,boolean), (compiler.misc.arg.length.mismatch)),(compiler.misc.inapplicable.method: kindname.constructor, T8065986b, T8065986b(boolean,java.lang.Object,java.lang.Object), (compiler.misc.arg.length.mismatch)),(compiler.misc.inapplicable.method: kindname.constructor, T8065986b, T8065986b(int), (compiler.misc.no.conforming.assignment.exists: (compiler.misc.cant.apply.diamond.1: (compiler.misc.diamond: java.util.ArrayList), (compiler.misc.infer.no.conforming.instance.exists: E, java.util.ArrayList<E>, int)))),(compiler.misc.inapplicable.method: kindname.constructor, T8065986b, T8065986b(int,int), (compiler.misc.arg.length.mismatch))}
+7 errors
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/generics/diamond/MultipleInferenceHooksTest.java	Mon Mar 30 17:09:14 2015 +0530
@@ -0,0 +1,38 @@
+/*
+ * 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.
+ *
+ * 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 8062373
+ * @summary Test that <>(){} works fine without verify error when there are multiple post inference hooks.
+ */
+
+import java.util.Collections;
+import java.util.IdentityHashMap;
+import java.util.Set;
+
+public class MultipleInferenceHooksTest {
+    public static void main(String[] args) {
+        Set<String> result = Collections.newSetFromMap(new IdentityHashMap<>() {});
+    }
+}
--- a/test/tools/javac/generics/diamond/neg/Neg01.java	Sat Mar 28 10:18:27 2015 -0700
+++ b/test/tools/javac/generics/diamond/neg/Neg01.java	Mon Mar 30 17:09:14 2015 +0530
@@ -1,6 +1,6 @@
 /*
  * @test /nodynamiccopyright/
- * @bug 6939620 7020044
+ * @bug 6939620 7020044 8062373
  *
  * @summary  Check that diamond fails when inference violates declared bounds
  *           (basic test with nested class, generic/non-generic constructors)
@@ -25,5 +25,16 @@
         Neg01<? extends String> n6 = new Neg01<>("", "");
         Neg01<?> n7 = new Neg01<>("", "");
         Foo<? super String> n8 = new Neg01<>("", "");
+
+        Neg01<String> n9 = new Neg01<>("", ""){};
+        Neg01<? extends String> n10 = new Neg01<>("", ""){};
+        Neg01<?> n11 = new Neg01<>("", ""){};
+        Neg01<? super String> n12 = new Neg01<>("", ""){};
+
+        Neg01<String> n13 = new Neg01<>(""){};
+        Neg01<? extends String> n14 = new Neg01<>(""){};
+        Neg01<?> n15 = new Neg01<>(""){};
+        Neg01<? super String> n16 = new Neg01<>(""){};
+
     }
 }
--- a/test/tools/javac/generics/diamond/neg/Neg01.out	Sat Mar 28 10:18:27 2015 -0700
+++ b/test/tools/javac/generics/diamond/neg/Neg01.out	Mon Mar 30 17:09:14 2015 +0530
@@ -12,4 +12,18 @@
 Neg01.java:26:23: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg01), null
 Neg01.java:27:9: compiler.err.cant.resolve.location: kindname.class, Foo, , , (compiler.misc.location: kindname.class, Neg01<X>, null)
 Neg01.java:27:34: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg01), null
-14 errors
+Neg01.java:29:15: compiler.err.not.within.bounds: java.lang.String, X
+Neg01.java:29:28: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg01), null
+Neg01.java:30:15: compiler.err.not.within.bounds: ? extends java.lang.String, X
+Neg01.java:30:39: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg01), null
+Neg01.java:31:24: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg01), null
+Neg01.java:32:15: compiler.err.not.within.bounds: ? super java.lang.String, X
+Neg01.java:32:37: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg01), null
+Neg01.java:34:15: compiler.err.not.within.bounds: java.lang.String, X
+Neg01.java:34:29: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg01), null
+Neg01.java:35:15: compiler.err.not.within.bounds: ? extends java.lang.String, X
+Neg01.java:35:39: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg01), null
+Neg01.java:36:24: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg01), null
+Neg01.java:37:15: compiler.err.not.within.bounds: ? super java.lang.String, X
+Neg01.java:37:37: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg01), null
+28 errors
--- a/test/tools/javac/generics/diamond/neg/Neg02.java	Sat Mar 28 10:18:27 2015 -0700
+++ b/test/tools/javac/generics/diamond/neg/Neg02.java	Mon Mar 30 17:09:14 2015 +0530
@@ -1,6 +1,6 @@
 /*
  * @test /nodynamiccopyright/
- * @bug 6939620 7020044
+ * @bug 6939620 7020044 8062373
  *
  * @summary  Check that diamond fails when inference violates declared bounds
  *           (test with nested class, qualified/simple type expressions)
@@ -26,6 +26,16 @@
         Foo<? extends String> f6 = new Foo<>("", "");
         Foo<?> f7 = new Foo<>("", "");
         Foo<? super String> f8 = new Foo<>("", "");
+
+        Foo<String> f9 = new Foo<>(""){};
+        Foo<? extends String> f10 = new Foo<>(""){};
+        Foo<?> f11 = new Foo<>(""){};
+        Foo<? super String> f12 = new Foo<>(""){};
+
+        Foo<String> f13 = new Foo<>("", ""){};
+        Foo<? extends String> f14 = new Foo<>("", ""){};
+        Foo<?> f15 = new Foo<>("", ""){};
+        Foo<? super String> f16 = new Foo<>("", ""){};
     }
 
     void testQualified() {
@@ -38,5 +48,15 @@
         Foo<? extends String> f6 = new Neg02.Foo<>("", "");
         Foo<?> f7 = new Neg02.Foo<>("", "");
         Foo<? super String> f8 = new Neg02.Foo<>("", "");
+
+        Foo<String> f9 = new Neg02.Foo<>(""){};
+        Foo<? extends String> f10 = new Neg02.Foo<>(""){};
+        Foo<?> f11 = new Neg02.Foo<>(""){};
+        Foo<? super String> f12 = new Neg02.Foo<>(""){};
+
+        Foo<String> f13 = new Neg02.Foo<>("", ""){};
+        Foo<? extends String> f14 = new Neg02.Foo<>("", ""){};
+        Foo<?> f15 = new Neg02.Foo<>("", ""){};
+        Foo<? super String> f16 = new Neg02.Foo<>("", ""){};
     }
 }
--- a/test/tools/javac/generics/diamond/neg/Neg02.out	Sat Mar 28 10:18:27 2015 -0700
+++ b/test/tools/javac/generics/diamond/neg/Neg02.out	Mon Mar 30 17:09:14 2015 +0530
@@ -12,18 +12,46 @@
 Neg02.java:27:21: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg02.Foo), null
 Neg02.java:28:13: compiler.err.not.within.bounds: ? super java.lang.String, X
 Neg02.java:28:34: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg02.Foo), null
-Neg02.java:32:13: compiler.err.not.within.bounds: java.lang.String, X
-Neg02.java:32:26: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg02.Foo), null
-Neg02.java:33:13: compiler.err.not.within.bounds: ? extends java.lang.String, X
-Neg02.java:33:36: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg02.Foo), null
-Neg02.java:34:21: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg02.Foo), null
-Neg02.java:35:13: compiler.err.not.within.bounds: ? super java.lang.String, X
-Neg02.java:35:34: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg02.Foo), null
-Neg02.java:37:13: compiler.err.not.within.bounds: java.lang.String, X
-Neg02.java:37:26: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg02.Foo), null
-Neg02.java:38:13: compiler.err.not.within.bounds: ? extends java.lang.String, X
-Neg02.java:38:36: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg02.Foo), null
-Neg02.java:39:21: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg02.Foo), null
-Neg02.java:40:13: compiler.err.not.within.bounds: ? super java.lang.String, X
-Neg02.java:40:34: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg02.Foo), null
-28 errors
+Neg02.java:30:13: compiler.err.not.within.bounds: java.lang.String, X
+Neg02.java:30:26: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg02.Foo), null
+Neg02.java:31:13: compiler.err.not.within.bounds: ? extends java.lang.String, X
+Neg02.java:31:37: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg02.Foo), null
+Neg02.java:32:22: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg02.Foo), null
+Neg02.java:33:13: compiler.err.not.within.bounds: ? super java.lang.String, X
+Neg02.java:33:35: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg02.Foo), null
+Neg02.java:35:13: compiler.err.not.within.bounds: java.lang.String, X
+Neg02.java:35:27: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg02.Foo), null
+Neg02.java:36:13: compiler.err.not.within.bounds: ? extends java.lang.String, X
+Neg02.java:36:37: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg02.Foo), null
+Neg02.java:37:22: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg02.Foo), null
+Neg02.java:38:13: compiler.err.not.within.bounds: ? super java.lang.String, X
+Neg02.java:38:35: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg02.Foo), null
+Neg02.java:42:13: compiler.err.not.within.bounds: java.lang.String, X
+Neg02.java:42:26: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg02.Foo), null
+Neg02.java:43:13: compiler.err.not.within.bounds: ? extends java.lang.String, X
+Neg02.java:43:36: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg02.Foo), null
+Neg02.java:44:21: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg02.Foo), null
+Neg02.java:45:13: compiler.err.not.within.bounds: ? super java.lang.String, X
+Neg02.java:45:34: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg02.Foo), null
+Neg02.java:47:13: compiler.err.not.within.bounds: java.lang.String, X
+Neg02.java:47:26: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg02.Foo), null
+Neg02.java:48:13: compiler.err.not.within.bounds: ? extends java.lang.String, X
+Neg02.java:48:36: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg02.Foo), null
+Neg02.java:49:21: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg02.Foo), null
+Neg02.java:50:13: compiler.err.not.within.bounds: ? super java.lang.String, X
+Neg02.java:50:34: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg02.Foo), null
+Neg02.java:52:13: compiler.err.not.within.bounds: java.lang.String, X
+Neg02.java:52:26: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg02.Foo), null
+Neg02.java:53:13: compiler.err.not.within.bounds: ? extends java.lang.String, X
+Neg02.java:53:37: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg02.Foo), null
+Neg02.java:54:22: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg02.Foo), null
+Neg02.java:55:13: compiler.err.not.within.bounds: ? super java.lang.String, X
+Neg02.java:55:35: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg02.Foo), null
+Neg02.java:57:13: compiler.err.not.within.bounds: java.lang.String, X
+Neg02.java:57:27: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg02.Foo), null
+Neg02.java:58:13: compiler.err.not.within.bounds: ? extends java.lang.String, X
+Neg02.java:58:37: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg02.Foo), null
+Neg02.java:59:22: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg02.Foo), null
+Neg02.java:60:13: compiler.err.not.within.bounds: ? super java.lang.String, X
+Neg02.java:60:35: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg02.Foo), null
+56 errors
--- a/test/tools/javac/generics/diamond/neg/Neg03.java	Sat Mar 28 10:18:27 2015 -0700
+++ b/test/tools/javac/generics/diamond/neg/Neg03.java	Mon Mar 30 17:09:14 2015 +0530
@@ -1,6 +1,6 @@
 /*
  * @test /nodynamiccopyright/
- * @bug 6939620 7020044
+ * @bug 6939620 7020044 8062373
  *
  * @summary  Check that diamond fails when inference violates declared bounds
  *           (test with inner class, qualified/simple type expressions)
@@ -26,6 +26,16 @@
         Foo<? extends String> f6 = new Foo<>("", "");
         Foo<?> f7 = new Foo<>("", "");
         Foo<? super String> f8 = new Foo<>("", "");
+
+        Foo<String> f9 = new Foo<>(""){};
+        Foo<? extends String> f10 = new Foo<>(""){};
+        Foo<?> f11 = new Foo<>(""){};
+        Foo<? super String> f12 = new Foo<>(""){};
+
+        Foo<String> f13 = new Foo<>("", ""){};
+        Foo<? extends String> f14 = new Foo<>("", ""){};
+        Foo<?> f15 = new Foo<>("", ""){};
+        Foo<? super String> f16 = new Foo<>("", ""){};
     }
 
     void testQualified_1() {
@@ -38,6 +48,16 @@
         Foo<? extends String> f6 = new Neg03<U>.Foo<>("", "");
         Foo<?> f7 = new Neg03<U>.Foo<>("", "");
         Foo<? super String> f8 = new Neg03<U>.Foo<>("", "");
+
+        Foo<String> f9 = new Neg03<U>.Foo<>(""){};
+        Foo<? extends String> f10 = new Neg03<U>.Foo<>(""){};
+        Foo<?> f11 = new Neg03<U>.Foo<>(""){};
+        Foo<? super String> f12 = new Neg03<U>.Foo<>(""){};
+
+        Foo<String> f13 = new Neg03<U>.Foo<>("", ""){};
+        Foo<? extends String> f14 = new Neg03<U>.Foo<>("", ""){};
+        Foo<?> f15 = new Neg03<U>.Foo<>("", ""){};
+        Foo<? super String> f16 = new Neg03<U>.Foo<>("", ""){};
     }
 
     void testQualified_2(Neg03<U> n) {
@@ -50,5 +70,15 @@
         Foo<? extends String> f6 = n.new Foo<>("", "");
         Foo<?> f7 = n.new Foo<>("", "");
         Foo<? super String> f8 = n.new Foo<>("", "");
+
+        Foo<String> f9 = n.new Foo<>(""){};
+        Foo<? extends String> f10 = n.new Foo<>(""){};
+        Foo<?> f11 = n.new Foo<>(""){};
+        Foo<? super String> f12 = n.new Foo<>(""){};
+
+        Foo<String> f13 = n.new Foo<>("", ""){};
+        Foo<? extends String> f14 = n.new Foo<>("", ""){};
+        Foo<?> f15 = n.new Foo<>("", ""){};
+        Foo<? super String> f16 = n.new Foo<>("", ""){};
     }
 }
--- a/test/tools/javac/generics/diamond/neg/Neg03.out	Sat Mar 28 10:18:27 2015 -0700
+++ b/test/tools/javac/generics/diamond/neg/Neg03.out	Mon Mar 30 17:09:14 2015 +0530
@@ -12,32 +12,74 @@
 Neg03.java:27:21: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
 Neg03.java:28:13: compiler.err.not.within.bounds: ? super java.lang.String, V
 Neg03.java:28:34: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
-Neg03.java:32:13: compiler.err.not.within.bounds: java.lang.String, V
-Neg03.java:32:26: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
-Neg03.java:33:13: compiler.err.not.within.bounds: ? extends java.lang.String, V
-Neg03.java:33:36: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
-Neg03.java:34:21: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
-Neg03.java:35:13: compiler.err.not.within.bounds: ? super java.lang.String, V
-Neg03.java:35:34: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
-Neg03.java:37:13: compiler.err.not.within.bounds: java.lang.String, V
-Neg03.java:37:26: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
-Neg03.java:38:13: compiler.err.not.within.bounds: ? extends java.lang.String, V
-Neg03.java:38:36: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
-Neg03.java:39:21: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
-Neg03.java:40:13: compiler.err.not.within.bounds: ? super java.lang.String, V
-Neg03.java:40:34: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
-Neg03.java:44:13: compiler.err.not.within.bounds: java.lang.String, V
-Neg03.java:44:28: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
-Neg03.java:45:13: compiler.err.not.within.bounds: ? extends java.lang.String, V
-Neg03.java:45:38: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
-Neg03.java:46:23: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
-Neg03.java:47:13: compiler.err.not.within.bounds: ? super java.lang.String, V
-Neg03.java:47:36: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
-Neg03.java:49:13: compiler.err.not.within.bounds: java.lang.String, V
-Neg03.java:49:28: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
-Neg03.java:50:13: compiler.err.not.within.bounds: ? extends java.lang.String, V
-Neg03.java:50:38: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
-Neg03.java:51:23: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
-Neg03.java:52:13: compiler.err.not.within.bounds: ? super java.lang.String, V
-Neg03.java:52:36: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
-42 errors
+Neg03.java:30:13: compiler.err.not.within.bounds: java.lang.String, V
+Neg03.java:30:26: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
+Neg03.java:31:13: compiler.err.not.within.bounds: ? extends java.lang.String, V
+Neg03.java:31:37: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
+Neg03.java:32:22: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
+Neg03.java:33:13: compiler.err.not.within.bounds: ? super java.lang.String, V
+Neg03.java:33:35: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
+Neg03.java:35:13: compiler.err.not.within.bounds: java.lang.String, V
+Neg03.java:35:27: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
+Neg03.java:36:13: compiler.err.not.within.bounds: ? extends java.lang.String, V
+Neg03.java:36:37: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
+Neg03.java:37:22: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
+Neg03.java:38:13: compiler.err.not.within.bounds: ? super java.lang.String, V
+Neg03.java:38:35: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
+Neg03.java:42:13: compiler.err.not.within.bounds: java.lang.String, V
+Neg03.java:42:26: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
+Neg03.java:43:13: compiler.err.not.within.bounds: ? extends java.lang.String, V
+Neg03.java:43:36: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
+Neg03.java:44:21: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
+Neg03.java:45:13: compiler.err.not.within.bounds: ? super java.lang.String, V
+Neg03.java:45:34: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
+Neg03.java:47:13: compiler.err.not.within.bounds: java.lang.String, V
+Neg03.java:47:26: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
+Neg03.java:48:13: compiler.err.not.within.bounds: ? extends java.lang.String, V
+Neg03.java:48:36: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
+Neg03.java:49:21: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
+Neg03.java:50:13: compiler.err.not.within.bounds: ? super java.lang.String, V
+Neg03.java:50:34: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
+Neg03.java:52:13: compiler.err.not.within.bounds: java.lang.String, V
+Neg03.java:52:26: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
+Neg03.java:53:13: compiler.err.not.within.bounds: ? extends java.lang.String, V
+Neg03.java:53:37: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
+Neg03.java:54:22: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
+Neg03.java:55:13: compiler.err.not.within.bounds: ? super java.lang.String, V
+Neg03.java:55:35: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
+Neg03.java:57:13: compiler.err.not.within.bounds: java.lang.String, V
+Neg03.java:57:27: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
+Neg03.java:58:13: compiler.err.not.within.bounds: ? extends java.lang.String, V
+Neg03.java:58:37: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
+Neg03.java:59:22: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
+Neg03.java:60:13: compiler.err.not.within.bounds: ? super java.lang.String, V
+Neg03.java:60:35: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
+Neg03.java:64:13: compiler.err.not.within.bounds: java.lang.String, V
+Neg03.java:64:28: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
+Neg03.java:65:13: compiler.err.not.within.bounds: ? extends java.lang.String, V
+Neg03.java:65:38: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
+Neg03.java:66:23: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
+Neg03.java:67:13: compiler.err.not.within.bounds: ? super java.lang.String, V
+Neg03.java:67:36: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
+Neg03.java:69:13: compiler.err.not.within.bounds: java.lang.String, V
+Neg03.java:69:28: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
+Neg03.java:70:13: compiler.err.not.within.bounds: ? extends java.lang.String, V
+Neg03.java:70:38: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
+Neg03.java:71:23: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
+Neg03.java:72:13: compiler.err.not.within.bounds: ? super java.lang.String, V
+Neg03.java:72:36: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
+Neg03.java:74:13: compiler.err.not.within.bounds: java.lang.String, V
+Neg03.java:74:28: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
+Neg03.java:75:13: compiler.err.not.within.bounds: ? extends java.lang.String, V
+Neg03.java:75:39: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
+Neg03.java:76:24: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
+Neg03.java:77:13: compiler.err.not.within.bounds: ? super java.lang.String, V
+Neg03.java:77:37: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
+Neg03.java:79:13: compiler.err.not.within.bounds: java.lang.String, V
+Neg03.java:79:29: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
+Neg03.java:80:13: compiler.err.not.within.bounds: ? extends java.lang.String, V
+Neg03.java:80:39: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
+Neg03.java:81:24: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
+Neg03.java:82:13: compiler.err.not.within.bounds: ? super java.lang.String, V
+Neg03.java:82:37: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
+84 errors
--- a/test/tools/javac/generics/diamond/neg/Neg04.java	Sat Mar 28 10:18:27 2015 -0700
+++ b/test/tools/javac/generics/diamond/neg/Neg04.java	Mon Mar 30 17:09:14 2015 +0530
@@ -1,6 +1,6 @@
 /*
  * @test /nodynamiccopyright/
- * @bug 6939620 7020044
+ * @bug 6939620 7020044 8062373
  *
  * @summary  Check that diamond fails when inference violates declared bounds
  *           (test with local class, qualified/simple type expressions)
@@ -25,5 +25,15 @@
         Foo<? extends String> n6 = new Foo<>("", "");
         Foo<?> n7 = new Foo<>("", "");
         Foo<? super String> n8 = new Foo<>("", "");
+
+        Foo<String> n9 = new Foo<>(""){};
+        Foo<? extends String> n10 = new Foo<>(""){};
+        Foo<?> n11 = new Foo<>(""){};
+        Foo<? super String> n12 = new Foo<>(""){};
+
+        Foo<String> n13 = new Foo<>("", ""){};
+        Foo<? extends String> n14 = new Foo<>("", ""){};
+        Foo<?> n15 = new Foo<>("", ""){};
+        Foo<? super String> n16 = new Foo<>("", ""){};
     }
 }
--- a/test/tools/javac/generics/diamond/neg/Neg04.out	Sat Mar 28 10:18:27 2015 -0700
+++ b/test/tools/javac/generics/diamond/neg/Neg04.out	Mon Mar 30 17:09:14 2015 +0530
@@ -12,4 +12,18 @@
 Neg04.java:26:21: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Foo), null
 Neg04.java:27:13: compiler.err.not.within.bounds: ? super java.lang.String, V
 Neg04.java:27:34: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Foo), null
-14 errors
+Neg04.java:29:13: compiler.err.not.within.bounds: java.lang.String, V
+Neg04.java:29:26: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Foo), null
+Neg04.java:30:13: compiler.err.not.within.bounds: ? extends java.lang.String, V
+Neg04.java:30:37: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Foo), null
+Neg04.java:31:22: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Foo), null
+Neg04.java:32:13: compiler.err.not.within.bounds: ? super java.lang.String, V
+Neg04.java:32:35: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Foo), null
+Neg04.java:34:13: compiler.err.not.within.bounds: java.lang.String, V
+Neg04.java:34:27: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Foo), null
+Neg04.java:35:13: compiler.err.not.within.bounds: ? extends java.lang.String, V
+Neg04.java:35:37: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Foo), null
+Neg04.java:36:22: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Foo), null
+Neg04.java:37:13: compiler.err.not.within.bounds: ? super java.lang.String, V
+Neg04.java:37:35: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Foo), null
+28 errors
--- a/test/tools/javac/generics/diamond/neg/Neg05.java	Sat Mar 28 10:18:27 2015 -0700
+++ b/test/tools/javac/generics/diamond/neg/Neg05.java	Mon Mar 30 17:09:14 2015 +0530
@@ -1,6 +1,6 @@
 /*
  * @test /nodynamiccopyright/
- * @bug 6939620 7020044
+ * @bug 6939620 7020044 8062373
  *
  * @summary  Check that usage of rare types doesn't cause spurious diamond diagnostics
  * @author mcimadamore
@@ -25,6 +25,16 @@
         Neg05<?>.Foo<? extends String> f6 = new Neg05.Foo<>("", "");
         Neg05<?>.Foo<?> f7 = new Neg05.Foo<>("", "");
         Neg05<?>.Foo<? super String> f8 = new Neg05.Foo<>("", "");
+
+        Neg05<?>.Foo<String> f9 = new Neg05.Foo<>(""){};
+        Neg05<?>.Foo<? extends String> f10 = new Neg05.Foo<>(""){};
+        Neg05<?>.Foo<?> f11 = new Neg05.Foo<>(""){};
+        Neg05<?>.Foo<? super String> f12 = new Neg05.Foo<>(""){};
+
+        Neg05<?>.Foo<String> f13 = new Neg05.Foo<>("", ""){};
+        Neg05<?>.Foo<? extends String> f14 = new Neg05.Foo<>("", ""){};
+        Neg05<?>.Foo<?> f15 = new Neg05.Foo<>("", ""){};
+        Neg05<?>.Foo<? super String> f16 = new Neg05.Foo<>("", ""){};
     }
 
     void testRare_2(Neg05 n) {
@@ -37,5 +47,15 @@
         Neg05<?>.Foo<? extends String> f6 = n.new Foo<>("", "");
         Neg05<?>.Foo<?> f7 = n.new Foo<>("", "");
         Neg05<?>.Foo<? super String> f8 = n.new Foo<>("", "");
+
+        Neg05<?>.Foo<String> f9 = n.new Foo<>(""){};
+        Neg05<?>.Foo<? extends String> f10 = n.new Foo<>(""){};
+        Neg05<?>.Foo<?> f11 = n.new Foo<>(""){};
+        Neg05<?>.Foo<? super String> f12 = n.new Foo<>(""){};
+
+        Neg05<?>.Foo<String> f13 = n.new Foo<>("", ""){};
+        Neg05<?>.Foo<? extends String> f14 = n.new Foo<>("", ""){};
+        Neg05<?>.Foo<?> f15 = n.new Foo<>("", ""){};
+        Neg05<?>.Foo<? super String> f16 = n.new Foo<>("", ""){};
     }
 }
--- a/test/tools/javac/generics/diamond/neg/Neg05.out	Sat Mar 28 10:18:27 2015 -0700
+++ b/test/tools/javac/generics/diamond/neg/Neg05.out	Mon Mar 30 17:09:14 2015 +0530
@@ -6,20 +6,52 @@
 Neg05.java:25:58: compiler.err.improperly.formed.type.inner.raw.param
 Neg05.java:26:43: compiler.err.improperly.formed.type.inner.raw.param
 Neg05.java:27:56: compiler.err.improperly.formed.type.inner.raw.param
-Neg05.java:31:37: compiler.err.improperly.formed.type.inner.raw.param
-Neg05.java:31:44: compiler.err.prob.found.req: (compiler.misc.cant.apply.diamond.1: (compiler.misc.diamond: Neg05.Foo), (compiler.misc.infer.no.conforming.instance.exists: V, Neg05.Foo<V>, Neg05<?>.Foo<java.lang.String>))
-Neg05.java:32:47: compiler.err.improperly.formed.type.inner.raw.param
-Neg05.java:32:54: compiler.err.prob.found.req: (compiler.misc.cant.apply.diamond.1: (compiler.misc.diamond: Neg05.Foo), (compiler.misc.infer.no.conforming.instance.exists: V, Neg05.Foo<V>, Neg05<?>.Foo<? extends java.lang.String>))
-Neg05.java:33:32: compiler.err.improperly.formed.type.inner.raw.param
-Neg05.java:33:39: compiler.err.prob.found.req: (compiler.misc.cant.apply.diamond.1: (compiler.misc.diamond: Neg05.Foo), (compiler.misc.infer.no.conforming.instance.exists: V, Neg05.Foo<V>, Neg05<?>.Foo<?>))
-Neg05.java:34:45: compiler.err.improperly.formed.type.inner.raw.param
-Neg05.java:34:52: compiler.err.prob.found.req: (compiler.misc.cant.apply.diamond.1: (compiler.misc.diamond: Neg05.Foo), (compiler.misc.infer.no.conforming.instance.exists: V, Neg05.Foo<V>, Neg05<?>.Foo<? super java.lang.String>))
-Neg05.java:36:37: compiler.err.improperly.formed.type.inner.raw.param
-Neg05.java:36:44: compiler.err.prob.found.req: (compiler.misc.cant.apply.diamond.1: (compiler.misc.diamond: Neg05.Foo), (compiler.misc.infer.no.conforming.instance.exists: V,Z, Neg05.Foo<V>, Neg05<?>.Foo<java.lang.String>))
-Neg05.java:37:47: compiler.err.improperly.formed.type.inner.raw.param
-Neg05.java:37:54: compiler.err.prob.found.req: (compiler.misc.cant.apply.diamond.1: (compiler.misc.diamond: Neg05.Foo), (compiler.misc.infer.no.conforming.instance.exists: V,Z, Neg05.Foo<V>, Neg05<?>.Foo<? extends java.lang.String>))
-Neg05.java:38:32: compiler.err.improperly.formed.type.inner.raw.param
-Neg05.java:38:39: compiler.err.prob.found.req: (compiler.misc.cant.apply.diamond.1: (compiler.misc.diamond: Neg05.Foo), (compiler.misc.infer.no.conforming.instance.exists: V,Z, Neg05.Foo<V>, Neg05<?>.Foo<?>))
-Neg05.java:39:45: compiler.err.improperly.formed.type.inner.raw.param
-Neg05.java:39:52: compiler.err.prob.found.req: (compiler.misc.cant.apply.diamond.1: (compiler.misc.diamond: Neg05.Foo), (compiler.misc.infer.no.conforming.instance.exists: V,Z, Neg05.Foo<V>, Neg05<?>.Foo<? super java.lang.String>))
-24 errors
+Neg05.java:29:48: compiler.err.improperly.formed.type.inner.raw.param
+Neg05.java:29:35: compiler.err.cant.apply.symbol: kindname.constructor, , V, java.lang.String, kindname.class, compiler.misc.anonymous.class: <any>, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: java.lang.String, V))
+Neg05.java:30:59: compiler.err.improperly.formed.type.inner.raw.param
+Neg05.java:30:46: compiler.err.cant.apply.symbol: kindname.constructor, , V, java.lang.String, kindname.class, compiler.misc.anonymous.class: <any>, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: java.lang.String, V))
+Neg05.java:31:44: compiler.err.improperly.formed.type.inner.raw.param
+Neg05.java:31:31: compiler.err.cant.apply.symbol: kindname.constructor, , V, java.lang.String, kindname.class, compiler.misc.anonymous.class: <any>, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: java.lang.String, V))
+Neg05.java:32:57: compiler.err.improperly.formed.type.inner.raw.param
+Neg05.java:32:44: compiler.err.cant.apply.symbol: kindname.constructor, , V, java.lang.String, kindname.class, compiler.misc.anonymous.class: <any>, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: java.lang.String, V))
+Neg05.java:34:49: compiler.err.improperly.formed.type.inner.raw.param
+Neg05.java:34:36: compiler.err.cant.apply.symbol: kindname.constructor, , V,Z, java.lang.String,java.lang.String, kindname.class, compiler.misc.anonymous.class: <any>, (compiler.misc.infer.no.conforming.assignment.exists: Z, (compiler.misc.inconvertible.types: java.lang.String, V))
+Neg05.java:35:59: compiler.err.improperly.formed.type.inner.raw.param
+Neg05.java:35:46: compiler.err.cant.apply.symbol: kindname.constructor, , V,Z, java.lang.String,java.lang.String, kindname.class, compiler.misc.anonymous.class: <any>, (compiler.misc.infer.no.conforming.assignment.exists: Z, (compiler.misc.inconvertible.types: java.lang.String, V))
+Neg05.java:36:44: compiler.err.improperly.formed.type.inner.raw.param
+Neg05.java:36:31: compiler.err.cant.apply.symbol: kindname.constructor, , V,Z, java.lang.String,java.lang.String, kindname.class, compiler.misc.anonymous.class: <any>, (compiler.misc.infer.no.conforming.assignment.exists: Z, (compiler.misc.inconvertible.types: java.lang.String, V))
+Neg05.java:37:57: compiler.err.improperly.formed.type.inner.raw.param
+Neg05.java:37:44: compiler.err.cant.apply.symbol: kindname.constructor, , V,Z, java.lang.String,java.lang.String, kindname.class, compiler.misc.anonymous.class: <any>, (compiler.misc.infer.no.conforming.assignment.exists: Z, (compiler.misc.inconvertible.types: java.lang.String, V))
+Neg05.java:41:37: compiler.err.improperly.formed.type.inner.raw.param
+Neg05.java:41:44: compiler.err.prob.found.req: (compiler.misc.cant.apply.diamond.1: (compiler.misc.diamond: Neg05.Foo), (compiler.misc.infer.no.conforming.instance.exists: V, Neg05.Foo<V>, Neg05<?>.Foo<java.lang.String>))
+Neg05.java:42:47: compiler.err.improperly.formed.type.inner.raw.param
+Neg05.java:42:54: compiler.err.prob.found.req: (compiler.misc.cant.apply.diamond.1: (compiler.misc.diamond: Neg05.Foo), (compiler.misc.infer.no.conforming.instance.exists: V, Neg05.Foo<V>, Neg05<?>.Foo<? extends java.lang.String>))
+Neg05.java:43:32: compiler.err.improperly.formed.type.inner.raw.param
+Neg05.java:43:39: compiler.err.prob.found.req: (compiler.misc.cant.apply.diamond.1: (compiler.misc.diamond: Neg05.Foo), (compiler.misc.infer.no.conforming.instance.exists: V, Neg05.Foo<V>, Neg05<?>.Foo<?>))
+Neg05.java:44:45: compiler.err.improperly.formed.type.inner.raw.param
+Neg05.java:44:52: compiler.err.prob.found.req: (compiler.misc.cant.apply.diamond.1: (compiler.misc.diamond: Neg05.Foo), (compiler.misc.infer.no.conforming.instance.exists: V, Neg05.Foo<V>, Neg05<?>.Foo<? super java.lang.String>))
+Neg05.java:46:37: compiler.err.improperly.formed.type.inner.raw.param
+Neg05.java:46:44: compiler.err.prob.found.req: (compiler.misc.cant.apply.diamond.1: (compiler.misc.diamond: Neg05.Foo), (compiler.misc.infer.no.conforming.instance.exists: V,Z, Neg05.Foo<V>, Neg05<?>.Foo<java.lang.String>))
+Neg05.java:47:47: compiler.err.improperly.formed.type.inner.raw.param
+Neg05.java:47:54: compiler.err.prob.found.req: (compiler.misc.cant.apply.diamond.1: (compiler.misc.diamond: Neg05.Foo), (compiler.misc.infer.no.conforming.instance.exists: V,Z, Neg05.Foo<V>, Neg05<?>.Foo<? extends java.lang.String>))
+Neg05.java:48:32: compiler.err.improperly.formed.type.inner.raw.param
+Neg05.java:48:39: compiler.err.prob.found.req: (compiler.misc.cant.apply.diamond.1: (compiler.misc.diamond: Neg05.Foo), (compiler.misc.infer.no.conforming.instance.exists: V,Z, Neg05.Foo<V>, Neg05<?>.Foo<?>))
+Neg05.java:49:45: compiler.err.improperly.formed.type.inner.raw.param
+Neg05.java:49:52: compiler.err.prob.found.req: (compiler.misc.cant.apply.diamond.1: (compiler.misc.diamond: Neg05.Foo), (compiler.misc.infer.no.conforming.instance.exists: V,Z, Neg05.Foo<V>, Neg05<?>.Foo<? super java.lang.String>))
+Neg05.java:51:37: compiler.err.improperly.formed.type.inner.raw.param
+Neg05.java:51:44: compiler.err.prob.found.req: (compiler.misc.cant.apply.diamond.1: (compiler.misc.diamond: Neg05.Foo), (compiler.misc.infer.no.conforming.instance.exists: V, Neg05.Foo<V>, Neg05<?>.Foo<java.lang.String>))
+Neg05.java:52:48: compiler.err.improperly.formed.type.inner.raw.param
+Neg05.java:52:55: compiler.err.prob.found.req: (compiler.misc.cant.apply.diamond.1: (compiler.misc.diamond: Neg05.Foo), (compiler.misc.infer.no.conforming.instance.exists: V, Neg05.Foo<V>, Neg05<?>.Foo<? extends java.lang.String>))
+Neg05.java:53:33: compiler.err.improperly.formed.type.inner.raw.param
+Neg05.java:53:40: compiler.err.prob.found.req: (compiler.misc.cant.apply.diamond.1: (compiler.misc.diamond: Neg05.Foo), (compiler.misc.infer.no.conforming.instance.exists: V, Neg05.Foo<V>, Neg05<?>.Foo<?>))
+Neg05.java:54:46: compiler.err.improperly.formed.type.inner.raw.param
+Neg05.java:54:53: compiler.err.prob.found.req: (compiler.misc.cant.apply.diamond.1: (compiler.misc.diamond: Neg05.Foo), (compiler.misc.infer.no.conforming.instance.exists: V, Neg05.Foo<V>, Neg05<?>.Foo<? super java.lang.String>))
+Neg05.java:56:38: compiler.err.improperly.formed.type.inner.raw.param
+Neg05.java:56:45: compiler.err.prob.found.req: (compiler.misc.cant.apply.diamond.1: (compiler.misc.diamond: Neg05.Foo), (compiler.misc.infer.no.conforming.instance.exists: V,Z, Neg05.Foo<V>, Neg05<?>.Foo<java.lang.String>))
+Neg05.java:57:48: compiler.err.improperly.formed.type.inner.raw.param
+Neg05.java:57:55: compiler.err.prob.found.req: (compiler.misc.cant.apply.diamond.1: (compiler.misc.diamond: Neg05.Foo), (compiler.misc.infer.no.conforming.instance.exists: V,Z, Neg05.Foo<V>, Neg05<?>.Foo<? extends java.lang.String>))
+Neg05.java:58:33: compiler.err.improperly.formed.type.inner.raw.param
+Neg05.java:58:40: compiler.err.prob.found.req: (compiler.misc.cant.apply.diamond.1: (compiler.misc.diamond: Neg05.Foo), (compiler.misc.infer.no.conforming.instance.exists: V,Z, Neg05.Foo<V>, Neg05<?>.Foo<?>))
+Neg05.java:59:46: compiler.err.improperly.formed.type.inner.raw.param
+Neg05.java:59:53: compiler.err.prob.found.req: (compiler.misc.cant.apply.diamond.1: (compiler.misc.diamond: Neg05.Foo), (compiler.misc.infer.no.conforming.instance.exists: V,Z, Neg05.Foo<V>, Neg05<?>.Foo<? super java.lang.String>))
+56 errors
--- a/test/tools/javac/generics/diamond/neg/Neg06.java	Sat Mar 28 10:18:27 2015 -0700
+++ b/test/tools/javac/generics/diamond/neg/Neg06.java	Mon Mar 30 17:09:14 2015 +0530
@@ -1,6 +1,6 @@
 /*
  * @test /nodynamiccopyright/
- * @bug 6939620 7020044
+ * @bug 6939620 7020044 8062373
  *
  * @summary  Check that diamond works where LHS is supertype of RHS (nilary constructor)
  * @author mcimadamore
@@ -9,9 +9,13 @@
  */
 
 class Neg06 {
+   interface ISuperFoo<X> {}
+   interface IFoo<X extends Number> extends ISuperFoo<X> {}
 
    static class CSuperFoo<X> {}
    static class CFoo<X extends Number> extends CSuperFoo<X> {}
 
+   ISuperFoo<String> isf = new IFoo<>() {};
    CSuperFoo<String> csf1 = new CFoo<>();
+   CSuperFoo<String> csf2 = new CFoo<>() {};
 }
--- a/test/tools/javac/generics/diamond/neg/Neg06.out	Sat Mar 28 10:18:27 2015 -0700
+++ b/test/tools/javac/generics/diamond/neg/Neg06.out	Mon Mar 30 17:09:14 2015 +0530
@@ -1,2 +1,6 @@
-Neg06.java:16:37: compiler.err.prob.found.req: (compiler.misc.cant.apply.diamond.1: (compiler.misc.diamond: Neg06.CFoo), (compiler.misc.incompatible.eq.upper.bounds: X, java.lang.String, java.lang.Number))
-1 error
+Neg06.java:18:36: compiler.err.prob.found.req: (compiler.misc.cant.apply.diamond.1: (compiler.misc.diamond: Neg06.IFoo), (compiler.misc.incompatible.eq.upper.bounds: X, java.lang.String, java.lang.Number))
+Neg06.java:18:28: compiler.err.prob.found.req: (compiler.misc.inconvertible.types: compiler.misc.anonymous.class: java.lang.Object, Neg06.ISuperFoo<java.lang.String>)
+Neg06.java:19:37: compiler.err.prob.found.req: (compiler.misc.cant.apply.diamond.1: (compiler.misc.diamond: Neg06.CFoo), (compiler.misc.incompatible.eq.upper.bounds: X, java.lang.String, java.lang.Number))
+Neg06.java:20:37: compiler.err.prob.found.req: (compiler.misc.cant.apply.diamond.1: (compiler.misc.diamond: Neg06.CFoo), (compiler.misc.incompatible.eq.upper.bounds: X, java.lang.String, java.lang.Number))
+Neg06.java:20:29: compiler.err.prob.found.req: (compiler.misc.inconvertible.types: compiler.misc.anonymous.class: <any>, Neg06.CSuperFoo<java.lang.String>)
+5 errors
--- a/test/tools/javac/generics/diamond/neg/Neg07.java	Sat Mar 28 10:18:27 2015 -0700
+++ b/test/tools/javac/generics/diamond/neg/Neg07.java	Mon Mar 30 17:09:14 2015 +0530
@@ -1,6 +1,6 @@
 /*
  * @test /nodynamiccopyright/
- * @bug 6939620 7020044
+ * @bug 6939620 7020044 8062373
  *
  * @summary  Check that diamond works where LHS is supertype of RHS (1-ary constructor)
  * @author mcimadamore
@@ -15,4 +15,5 @@
    }
 
    SuperFoo<String> sf1 = new Foo<>("");
+   SuperFoo<String> sf2 = new Foo<>("") {};
 }
--- a/test/tools/javac/generics/diamond/neg/Neg07.out	Sat Mar 28 10:18:27 2015 -0700
+++ b/test/tools/javac/generics/diamond/neg/Neg07.out	Mon Mar 30 17:09:14 2015 +0530
@@ -1,2 +1,3 @@
 Neg07.java:17:27: compiler.err.cant.apply.diamond.1: (compiler.misc.diamond: Neg07.Foo), (compiler.misc.inferred.do.not.conform.to.upper.bounds: java.lang.String, java.lang.Number)
-1 error
+Neg07.java:18:27: compiler.err.cant.apply.diamond.1: (compiler.misc.diamond: Neg07.Foo), (compiler.misc.inferred.do.not.conform.to.upper.bounds: java.lang.String, java.lang.Number)
+2 errors
--- a/test/tools/javac/generics/diamond/neg/Neg09.java	Sat Mar 28 10:18:27 2015 -0700
+++ b/test/tools/javac/generics/diamond/neg/Neg09.java	Mon Mar 30 17:09:14 2015 +0530
@@ -1,10 +1,10 @@
 /*
  * @test /nodynamiccopyright/
- * @bug 7020044
+ * @bug 7020044 8062373
  *
- * @summary  Check that diamond is not allowed with anonymous inner class expressions
+ * @summary  Check that diamond is not allowed with anonymous inner class expressions at source < 9
  * @author Maurizio Cimadamore
- * @compile/fail/ref=Neg09.out Neg09.java -XDrawDiagnostics
+ * @compile/fail/ref=Neg09.out Neg09.java -source 8 -XDrawDiagnostics
  *
  */
 
--- a/test/tools/javac/generics/diamond/neg/Neg09.out	Sat Mar 28 10:18:27 2015 -0700
+++ b/test/tools/javac/generics/diamond/neg/Neg09.out	Mon Mar 30 17:09:14 2015 +0530
@@ -1,5 +1,7 @@
-Neg09.java:17:34: compiler.err.cant.apply.diamond.1: Neg09.Member<X>, (compiler.misc.diamond.and.anon.class: Neg09.Member<X>)
-Neg09.java:18:34: compiler.err.cant.apply.diamond.1: Neg09.Nested<X>, (compiler.misc.diamond.and.anon.class: Neg09.Nested<X>)
-Neg09.java:22:39: compiler.err.cant.apply.diamond.1: Neg09.Member<X>, (compiler.misc.diamond.and.anon.class: Neg09.Member<X>)
-Neg09.java:23:40: compiler.err.cant.apply.diamond.1: Neg09.Nested<X>, (compiler.misc.diamond.and.anon.class: Neg09.Nested<X>)
+- compiler.warn.source.no.bootclasspath: 1.8
+Neg09.java:17:34: compiler.err.cant.apply.diamond.1: Neg09.Member<X>, (compiler.misc.diamond.and.anon.class.not.supported.in.source: 1.8)
+Neg09.java:18:34: compiler.err.cant.apply.diamond.1: Neg09.Nested<X>, (compiler.misc.diamond.and.anon.class.not.supported.in.source: 1.8)
+Neg09.java:22:39: compiler.err.cant.apply.diamond.1: Neg09.Member<X>, (compiler.misc.diamond.and.anon.class.not.supported.in.source: 1.8)
+Neg09.java:23:40: compiler.err.cant.apply.diamond.1: Neg09.Nested<X>, (compiler.misc.diamond.and.anon.class.not.supported.in.source: 1.8)
 4 errors
+1 warning
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/generics/diamond/neg/Neg12.java	Mon Mar 30 17:09:14 2015 +0530
@@ -0,0 +1,33 @@
+/*
+ * @test /nodynamiccopyright/
+ * @bug 8062373
+ *
+ * @summary  Test diamond + anonymous classes with non-denotable types
+ * @author mcimadamore
+ * @compile/fail/ref=Neg12.out Neg12.java -XDrawDiagnostics
+ *
+ */
+
+ class Neg12 {
+    static class Foo<X> {
+        Foo(X x) {  }
+    }
+
+    static class DoubleFoo<X,Y> {
+        DoubleFoo(X x,Y y) {  }
+    }
+
+    static class TripleFoo<X,Y,Z> {
+        TripleFoo(X x,Y y,Z z) {  }
+    }
+
+    Foo<? extends Integer> fi = new Foo<>(1);
+    Foo<?> fw = new Foo<>(fi) {}; // Error.
+    Foo<?> fw1 = new Foo<>(fi); // OK.
+    Foo<? extends Double> fd = new Foo<>(3.0);
+    DoubleFoo<?,?> dw = new DoubleFoo<>(fi,fd) {}; // Error.
+    DoubleFoo<?,?> dw1 = new DoubleFoo<>(fi,fd); // OK.
+    Foo<String> fs = new Foo<>("one");
+    TripleFoo<?,?,?> tw = new TripleFoo<>(fi,fd,fs) {}; // Error.
+    TripleFoo<?,?,?> tw1 = new TripleFoo<>(fi,fd,fs); // OK.
+ }
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/generics/diamond/neg/Neg12.out	Mon Mar 30 17:09:14 2015 +0530
@@ -0,0 +1,4 @@
+Neg12.java:25:24: compiler.err.cant.apply.diamond.1: (compiler.misc.diamond: Neg12.Foo), (compiler.misc.diamond.invalid.arg: Neg12.Foo<compiler.misc.type.captureof: 1, ? extends java.lang.Integer>, (compiler.misc.diamond: Neg12.Foo))
+Neg12.java:28:38: compiler.err.cant.apply.diamond.1: (compiler.misc.diamond: Neg12.DoubleFoo), (compiler.misc.diamond.invalid.args: Neg12.Foo<compiler.misc.type.captureof: 1, ? extends java.lang.Integer>,Neg12.Foo<compiler.misc.type.captureof: 2, ? extends java.lang.Double>, (compiler.misc.diamond: Neg12.DoubleFoo))
+Neg12.java:31:40: compiler.err.cant.apply.diamond.1: (compiler.misc.diamond: Neg12.TripleFoo), (compiler.misc.diamond.invalid.args: Neg12.Foo<compiler.misc.type.captureof: 1, ? extends java.lang.Integer>,Neg12.Foo<compiler.misc.type.captureof: 2, ? extends java.lang.Double>, (compiler.misc.diamond: Neg12.TripleFoo))
+3 errors
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/generics/diamond/neg/Neg13.java	Mon Mar 30 17:09:14 2015 +0530
@@ -0,0 +1,49 @@
+/*
+ * @test /nodynamiccopyright/
+ * @bug 8062373
+ *
+ * @summary  Test diamond + anonymous classes with abstract super type
+ * @author sadayapalam
+ * @compile/fail/ref=Neg13.out Neg13.java -XDrawDiagnostics
+ *
+ */
+class Neg13 {
+
+    static abstract class A<T> {
+        abstract void foo();
+    }
+
+    static void foo(A<String> as) {}
+
+    public static void main(String[] args) {
+
+        // Method invocation context - good <>(){}
+        foo(new A<>() {
+            public void foo() {}
+        });
+
+        // Assignment context - good <>(){}
+        A<?> aq = new A<>() {
+            public void foo() {}
+        };
+
+        // When the anonymous type subtypes an abstract class but is missing definitions for
+        // abstract methods, expect no overload resolution error, but an attribution error
+        // while attributing anonymous class body.
+
+
+        // Method invocation context - bad <>(){}
+        foo(new A<>() {
+        });
+
+        // Assignment invocation context - bad <>(){}
+        aq = new A<>() {
+        };
+
+        // Method invocation context - bad <>()
+        foo(new A<>());
+
+        // Assignment invocation context - bad <>()
+        aq = new A<>();
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/generics/diamond/neg/Neg13.out	Mon Mar 30 17:09:14 2015 +0530
@@ -0,0 +1,5 @@
+Neg13.java:36:23: compiler.err.does.not.override.abstract: compiler.misc.anonymous.class: Neg13$3, foo(), Neg13.A
+Neg13.java:40:24: compiler.err.does.not.override.abstract: compiler.misc.anonymous.class: Neg13$4, foo(), Neg13.A
+Neg13.java:44:13: compiler.err.abstract.cant.be.instantiated: Neg13.A
+Neg13.java:47:14: compiler.err.abstract.cant.be.instantiated: Neg13.A
+4 errors
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/generics/diamond/neg/Neg14.java	Mon Mar 30 17:09:14 2015 +0530
@@ -0,0 +1,49 @@
+/*
+ * @test /nodynamiccopyright/
+ * @bug 8062373
+ *
+ * @summary  Test diamond + anonymous classes with super type being an interface.
+ * @author sadayapalam
+ * @compile/fail/ref=Neg14.out Neg14.java -XDrawDiagnostics
+ *
+ */
+class Neg14 {
+
+    static interface A<T> {
+        void foo();
+    }
+
+    static void foo(A<String> as) {}
+
+    public static void main(String[] args) {
+
+        // Method invocation context - good <>(){}
+        foo(new A<>() {
+            public void foo() {}
+        });
+
+        // Assignment context - good <>(){}
+        A<?> aq = new A<>() {
+            public void foo() {}
+        };
+
+        // When the anonymous type subtypes an interface but is missing definitions for
+        // abstract methods, expect no overload resolution error, but an attribution error
+        // while attributing anonymous class body.
+
+
+        // Method invocation context - bad <>(){}
+        foo(new A<>() {
+        });
+
+        // Assignment invocation context - bad <>(){}
+        aq = new A<>() {
+        };
+
+        // Method invocation context - bad <>()
+        foo(new A<>());
+
+        // Assignment invocation context - bad <>()
+        aq = new A<>();
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/generics/diamond/neg/Neg14.out	Mon Mar 30 17:09:14 2015 +0530
@@ -0,0 +1,5 @@
+Neg14.java:36:23: compiler.err.does.not.override.abstract: compiler.misc.anonymous.class: Neg14$3, foo(), Neg14.A
+Neg14.java:40:24: compiler.err.does.not.override.abstract: compiler.misc.anonymous.class: Neg14$4, foo(), Neg14.A
+Neg14.java:44:13: compiler.err.abstract.cant.be.instantiated: Neg14.A
+Neg14.java:47:14: compiler.err.abstract.cant.be.instantiated: Neg14.A
+4 errors
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/generics/diamond/neg/Neg15.java	Mon Mar 30 17:09:14 2015 +0530
@@ -0,0 +1,66 @@
+/*
+ * @test /nodynamiccopyright/
+ * @bug 8062373
+ *
+ * @summary  Test that javac complains when a <> inferred class contains a public method that does override a supertype method.
+ * @author sadayapalam
+ * @compile/fail/ref=Neg15.out Neg15.java -XDrawDiagnostics
+ *
+ */
+
+class Neg15 {
+
+    interface Predicate<T> {
+        default boolean test(T t) {
+            System.out.println("Default method");
+            return false;
+        }
+    }
+
+
+    static void someMethod(Predicate<? extends Number> p) {
+        if (!p.test(null))
+            throw new Error("Blew it");
+    }
+
+    public static void main(String[] args) {
+
+        someMethod(new Predicate<Integer>() {
+            public boolean test(Integer n) {
+                System.out.println("Override");
+                return true;
+            }
+            boolean test(Integer n, int i) {
+                System.out.println("Override");
+                return true;
+            }
+            protected boolean test(Integer n, int i, int j) {
+                System.out.println("Override");
+                return true;
+            }
+            private boolean test(Integer n, int i, long j) {
+                System.out.println("Override");
+                return true;
+            }
+        });
+
+        someMethod(new Predicate<>() {
+            public boolean test(Integer n) { // bad.
+                System.out.println("Override");
+                return true;
+            }
+            boolean test(Integer n, int i) { // bad, package access.
+                System.out.println("Override");
+                return true;
+            }
+            protected boolean test(Integer n, int i, int j) { // bad, protected access.
+                System.out.println("Override");
+                return true;
+            }
+            private boolean test(Integer n, int i, long j) { // OK, private method.
+                System.out.println("Override");
+                return true;
+            }
+        });
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/generics/diamond/neg/Neg15.out	Mon Mar 30 17:09:14 2015 +0530
@@ -0,0 +1,4 @@
+Neg15.java:48:28: compiler.err.method.does.not.override.superclass
+Neg15.java:52:21: compiler.err.method.does.not.override.superclass
+Neg15.java:56:31: compiler.err.method.does.not.override.superclass
+3 errors
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/generics/diamond/neg/Neg16.java	Mon Mar 30 17:09:14 2015 +0530
@@ -0,0 +1,36 @@
+/*
+ * @test /nodynamiccopyright/
+ * @bug 8062373
+ * @summary Test that javac does not recommend a diamond site that would result in error.
+ * @compile/ref=Neg16.out -Xlint:-options Neg16.java -XDrawDiagnostics -XDfind=diamond
+ */
+
+class Neg16 {
+
+   interface Predicate<T> {
+        default boolean test(T t) {
+            System.out.println("Default method");
+            return false;
+        }
+    }
+
+    static void someMethod(Predicate<? extends Number> p) {
+        if (!p.test(null))
+            throw new Error("Blew it");
+    }
+
+    public static void main(String[] args) {
+        someMethod(new Predicate<Integer>() { // cannot convert to diamond
+            public boolean test(Integer n) {
+                System.out.println("Override");
+                return true;
+            }
+        });
+        someMethod(new Predicate<Number>() { // can convert to diamond.
+            public boolean test(Number n) {
+                System.out.println("Override");
+                return true;
+            }
+        });
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/generics/diamond/neg/Neg16.out	Mon Mar 30 17:09:14 2015 +0530
@@ -0,0 +1,2 @@
+Neg16.java:29:33: compiler.warn.diamond.redundant.args
+1 warning
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/generics/diamond/neg/Neg17.java	Mon Mar 30 17:09:14 2015 +0530
@@ -0,0 +1,21 @@
+/*
+ * @test /nodynamiccopyright/
+ * @bug 8062373
+ * @summary Test that the anonymous class constructor appears to returns a Foo<T>, when it actually returns a Anon$1. (status as of now - may change in future)
+ * @compile/fail/ref=Neg17.out Neg17.java -XDrawDiagnostics
+ */
+
+import java.util.Collections;
+
+abstract class Neg17<T> {
+
+   abstract void m();
+
+   public static void main(String[] args) {
+       Collections.singletonList(new Neg17<>() { void m() {} }).get(0).m(); // good.
+       Collections.singletonList(new Neg17<>() {
+                 void m() {}
+                 private void n() {}
+           }).get(0).n(); // bad unknown method n()
+   }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/generics/diamond/neg/Neg17.out	Mon Mar 30 17:09:14 2015 +0530
@@ -0,0 +1,2 @@
+Neg17.java:19:21: compiler.err.cant.resolve.location.args: kindname.method, n, , , (compiler.misc.location: kindname.class, Neg17<java.lang.Object>, null)
+1 error
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/generics/diamond/neg/Neg18.java	Mon Mar 30 17:09:14 2015 +0530
@@ -0,0 +1,16 @@
+/*
+ * @test /nodynamiccopyright/
+ * @bug 8062373
+ * @summary Test that inaccessible vararg element type triggers an error during diamond inferred anonymous class instance creation.
+ * @compile/fail/ref=Neg18.out Neg18.java -XDrawDiagnostics
+ */
+
+import java.util.Collections;
+import pkg.Neg18_01;
+
+class Neg18 {
+
+   public static void main(String[] args) {
+        new Neg18_01<>() {};
+   }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/generics/diamond/neg/Neg18.out	Mon Mar 30 17:09:14 2015 +0530
@@ -0,0 +1,3 @@
+Neg18.java:14:21: compiler.err.prob.found.req: (compiler.misc.cant.apply.diamond.1: (compiler.misc.diamond: pkg.Neg18_01), (compiler.misc.inaccessible.varargs.type: pkg.Neg18_01.PkgPrivate, kindname.class, Neg18))
+Neg18.java:14:26: compiler.err.not.def.public.cant.access: pkg.Neg18_01.PkgPrivate, pkg.Neg18_01
+2 errors
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/generics/diamond/neg/Neg19.java	Mon Mar 30 17:09:14 2015 +0530
@@ -0,0 +1,21 @@
+/*
+ * @test /nodynamiccopyright/
+ * @bug 8062373
+ * @summary Test that when inaccessible types constitute the inferred types of <> the compiler complains.
+ * @compile/fail/ref=Neg19.out Neg19.java -XDrawDiagnostics
+ */
+
+
+
+class Neg19 {
+    public static void main(String[] args) {
+        new Neg19_01<Neg19>().foo(new Neg19_01<>()); // OK.
+        new Neg19_01<Neg19>().foo(new Neg19_01<>() {}); // ERROR.
+    }
+}
+
+class Neg19_01<T> {
+    private class Private {}
+    Neg19_01() {}
+    void foo(Neg19_01<Private> p) {}
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/generics/diamond/neg/Neg19.out	Mon Mar 30 17:09:14 2015 +0530
@@ -0,0 +1,2 @@
+Neg19.java:13:34: compiler.err.report.access: Neg19_01.Private, private, Neg19_01
+1 error
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/generics/diamond/neg/pkg/Neg18_01.java	Mon Mar 30 17:09:14 2015 +0530
@@ -0,0 +1,29 @@
+/*
+ * 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.
+ *
+ * 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 pkg;
+
+public class Neg18_01<T> {
+    static class PkgPrivate {}
+    public Neg18_01 (PkgPrivate ... pp) {}
+}
--- a/test/tools/javac/generics/diamond/pos/Pos01.java	Sat Mar 28 10:18:27 2015 -0700
+++ b/test/tools/javac/generics/diamond/pos/Pos01.java	Mon Mar 30 17:09:14 2015 +0530
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2010, 2011, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2010, 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
@@ -23,7 +23,7 @@
 
 /*
  * @test
- * @bug 6939620 7020044
+ * @bug 6939620 7020044 8062373
  *
  * @summary  basic test for diamond (generic/non-generic constructors)
  * @author mcimadamore
@@ -48,7 +48,17 @@
         Pos01<? extends Integer> p6 = new Pos01<>(1, "");
         Pos01<?> p7 = new Pos01<>(1, "");
         Pos01<? super Integer> p8 = new Pos01<>(1, "");
-    }
+
+        Pos01<Integer> p9 = new Pos01<>(1){};
+        Pos01<? extends Integer> p10 = new Pos01<>(1){};
+        Pos01<?> p11 = new Pos01<>(1){};
+        Pos01<? super Integer> p12 = new Pos01<>(1){};
+
+        Pos01<Integer> p13 = new Pos01<>(1, ""){};
+        Pos01<? extends Integer> p14= new Pos01<>(1, ""){};
+        Pos01<?> p15 = new Pos01<>(1, ""){};
+        Pos01<? super Integer> p16 = new Pos01<>(1, ""){};
+   }
 
     public static void main(String[] args) {
         Pos01<String> p1 = new Pos01<>("");
--- a/test/tools/javac/generics/diamond/pos/Pos02.java	Sat Mar 28 10:18:27 2015 -0700
+++ b/test/tools/javac/generics/diamond/pos/Pos02.java	Mon Mar 30 17:09:14 2015 +0530
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2010, 2011, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2010, 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
@@ -23,7 +23,7 @@
 
 /*
  * @test
- * @bug 6939620 7020044
+ * @bug 6939620 7020044 8062373
  *
  * @summary  basic test for diamond (simple/qualified type-expressions)
  * @author mcimadamore
@@ -48,6 +48,16 @@
         Foo<? extends Integer> f6 = new Foo<>(1, "");
         Foo<?> f7 = new Foo<>(1, "");
         Foo<? super Integer> f8 = new Foo<>(1, "");
+
+        Foo<Integer> f9 = new Foo<>(1){};
+        Foo<? extends Integer> f10 = new Foo<>(1){};
+        Foo<?> f11 = new Foo<>(1){};
+        Foo<? super Integer> f12 = new Foo<>(1){};
+
+        Foo<Integer> f13 = new Foo<>(1, ""){};
+        Foo<? extends Integer> f14 = new Foo<>(1, ""){};
+        Foo<?> f15 = new Foo<>(1, ""){};
+        Foo<? super Integer> f16 = new Foo<>(1, ""){};
     }
 
     void testQualified() {
@@ -60,6 +70,16 @@
         Foo<? extends Integer> f6 = new Pos02.Foo<>(1, "");
         Foo<?> f7 = new Pos02.Foo<>(1, "");
         Foo<? super Integer> f8 = new Pos02.Foo<>(1, "");
+
+        Foo<Integer> f9 = new Pos02.Foo<>(1){};
+        Foo<? extends Integer> f10 = new Pos02.Foo<>(1){};
+        Foo<?> f11 = new Pos02.Foo<>(1){};
+        Foo<? super Integer> f12 = new Pos02.Foo<>(1){};
+
+        Foo<Integer> f13 = new Pos02.Foo<>(1, ""){};
+        Foo<? extends Integer> f14 = new Pos02.Foo<>(1, ""){};
+        Foo<?> f15 = new Pos02.Foo<>(1, ""){};
+        Foo<? super Integer> f16 = new Pos02.Foo<>(1, ""){};
     }
 
     public static void main(String[] args) {
--- a/test/tools/javac/generics/diamond/pos/Pos03.java	Sat Mar 28 10:18:27 2015 -0700
+++ b/test/tools/javac/generics/diamond/pos/Pos03.java	Mon Mar 30 17:09:14 2015 +0530
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2010, 2011, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2010, 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
@@ -23,7 +23,7 @@
 
 /*
  * @test
- * @bug 6939620 7020044
+ * @bug 6939620 7020044 8062373
  *
  * @summary  basic test for diamond (simple/qualified type-expressions, member inner)
  * @author mcimadamore
@@ -49,6 +49,16 @@
         Foo<? extends Integer> f6 = new Foo<>(1, "");
         Foo<?> f7 = new Foo<>(1, "");
         Foo<? super Integer> f8 = new Foo<>(1, "");
+
+        Foo<Integer> f9 = new Foo<>(1){};
+        Foo<? extends Integer> f10 = new Foo<>(1){};
+        Foo<?> f11 = new Foo<>(1){};
+        Foo<? super Integer> f12 = new Foo<>(1){};
+
+        Foo<Integer> f13 = new Foo<>(1, ""){};
+        Foo<? extends Integer> f14 = new Foo<>(1, ""){};
+        Foo<?> f15 = new Foo<>(1, ""){};
+        Foo<? super Integer> f16 = new Foo<>(1, ""){};
     }
 
     void testQualified_1() {
@@ -61,6 +71,16 @@
         Foo<? extends Integer> f6 = new Pos03<U>.Foo<>(1, "");
         Foo<?> f7 = new Pos03<U>.Foo<>(1, "");
         Foo<? super Integer> f8 = new Pos03<U>.Foo<>(1, "");
+
+        Foo<Integer> f9 = new Pos03<U>.Foo<>(1){};
+        Foo<? extends Integer> f10 = new Pos03<U>.Foo<>(1){};
+        Foo<?> f11 = new Pos03<U>.Foo<>(1){};
+        Foo<? super Integer> f12 = new Pos03<U>.Foo<>(1){};
+
+        Foo<Integer> f13 = new Pos03<U>.Foo<>(1, ""){};
+        Foo<? extends Integer> f14 = new Pos03<U>.Foo<>(1, ""){};
+        Foo<?> f15 = new Pos03<U>.Foo<>(1, ""){};
+        Foo<? super Integer> f16 = new Pos03<U>.Foo<>(1, ""){};
     }
 
     void testQualified_2(Pos03<U> p) {
@@ -73,6 +93,16 @@
         Foo<? extends Integer> f6 = p.new Foo<>(1, "");
         Foo<?> f7 = p.new Foo<>(1, "");
         Foo<? super Integer> f8 = p.new Foo<>(1, "");
+
+        Foo<Integer> f9 = p.new Foo<>(1){};
+        Foo<? extends Integer> f10 = p.new Foo<>(1){};
+        Foo<?> f11 = p.new Foo<>(1){};
+        Foo<? super Integer> f12 = p.new Foo<>(1){};
+
+        Foo<Integer> f13 = p.new Foo<>(1, ""){};
+        Foo<? extends Integer> f14 = p.new Foo<>(1, ""){};
+        Foo<?> f15 = p.new Foo<>(1, ""){};
+        Foo<? super Integer> f16 = p.new Foo<>(1, ""){};
     }
 
     public static void main(String[] args) {
--- a/test/tools/javac/generics/diamond/pos/Pos04.java	Sat Mar 28 10:18:27 2015 -0700
+++ b/test/tools/javac/generics/diamond/pos/Pos04.java	Mon Mar 30 17:09:14 2015 +0530
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2010, 2011, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2010, 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
@@ -23,7 +23,7 @@
 
 /*
  * @test
- * @bug 6939620 7020044
+ * @bug 6939620 7020044 8062373
  *
  * @summary  basic test for diamond (simple/qualified type-expressions, local class)
  * @author mcimadamore
@@ -48,6 +48,16 @@
         Foo<? extends Integer> p6 = new Foo<>(1, "");
         Foo<?> p7 = new Foo<>(1, "");
         Foo<? super Integer> p8 = new Foo<>(1, "");
+
+        Foo<Integer> p9 = new Foo<>(1){};
+        Foo<? extends Integer> p10 = new Foo<>(1){};
+        Foo<?> p11 = new Foo<>(1){};
+        Foo<? super Integer> p12 = new Foo<>(1){};
+
+        Foo<Integer> p13 = new Foo<>(1, ""){};
+        Foo<? extends Integer> p14 = new Foo<>(1, ""){};
+        Foo<?> p15 = new Foo<>(1, ""){};
+        Foo<? super Integer> p16 = new Foo<>(1, ""){};
     }
 
     public static void main(String[] args) {
--- a/test/tools/javac/generics/diamond/pos/Pos05.java	Sat Mar 28 10:18:27 2015 -0700
+++ b/test/tools/javac/generics/diamond/pos/Pos05.java	Mon Mar 30 17:09:14 2015 +0530
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2010, 2011, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2010, 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
@@ -23,11 +23,10 @@
 
 /*
  * @test
- * @bug 6939620 7020044
+ * @bug 6939620 7020044 8062373
  *
  * @summary  Check that 'complex' inference sometimes works in method context
  * @author mcimadamore
- * @compile Pos05.java
  *
  */
 
@@ -41,5 +40,11 @@
 
     void test() {
         m(new Foo<>(1));
+        m(new Foo<>(1) {});
     }
+
+    public static void main(String [] args) {
+        new Pos05().test();
+    }
+
 }
--- a/test/tools/javac/generics/inference/8055963/T8055963.java	Sat Mar 28 10:18:27 2015 -0700
+++ b/test/tools/javac/generics/inference/8055963/T8055963.java	Mon Mar 30 17:09:14 2015 +0530
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2014, 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
@@ -25,11 +25,10 @@
 
 /**
  * @test
- * @bug 8055963
+ * @bug 8055963 8062373
  * @summary Inference failure with nested invocation
- * @compile T8055963.java
  */
-class T8055963 {
+public class T8055963 {
 
     static class C<T> {}
 
@@ -38,4 +37,8 @@
     void test() {
         C<String> cs = choose(new C<String>(), new C<>());
     }
+
+    public static void main(String [] args) {
+      new T8055963().test();
+    }
 }
--- a/test/tools/javac/lambda/8066974/T8066974.java	Sat Mar 28 10:18:27 2015 -0700
+++ b/test/tools/javac/lambda/8066974/T8066974.java	Mon Mar 30 17:09:14 2015 +0530
@@ -1,6 +1,6 @@
 /*
  * @test /nodynamiccopyright/
- * @bug 8066974
+ * @bug 8066974 8062373
  * @summary Compiler doesn't infer method's generic type information in lambda body
  * @compile/fail/ref=T8066974.out -XDrawDiagnostics T8066974.java
  */
@@ -34,11 +34,13 @@
         map(p->p.m(rt));
         map(mapper(rt));
         map(new ThrowingMapper<>(rt));
+        map(new ThrowingMapper<>(rt) {});
     }
 
     void testChecked(CheckedThrowing ct) {
         map(p->p.m(ct));
         map(mapper(ct));
         map(new ThrowingMapper<>(ct));
+        map(new ThrowingMapper<>(ct) {});
     }
 }
--- a/test/tools/javac/lambda/8066974/T8066974.out	Sat Mar 28 10:18:27 2015 -0700
+++ b/test/tools/javac/lambda/8066974/T8066974.out	Mon Mar 30 17:09:14 2015 +0530
@@ -1,4 +1,5 @@
-T8066974.java:40:19: compiler.err.unreported.exception.need.to.catch.or.throw: java.lang.Exception
 T8066974.java:41:19: compiler.err.unreported.exception.need.to.catch.or.throw: java.lang.Exception
-T8066974.java:42:13: compiler.err.unreported.exception.need.to.catch.or.throw: java.lang.Exception
-3 errors
+T8066974.java:42:19: compiler.err.unreported.exception.need.to.catch.or.throw: java.lang.Exception
+T8066974.java:43:13: compiler.err.unreported.exception.need.to.catch.or.throw: java.lang.Exception
+T8066974.java:44:13: compiler.err.unreported.exception.need.to.catch.or.throw: java.lang.Exception
+4 errors
--- a/test/tools/javac/lambda/TargetType46.java	Sat Mar 28 10:18:27 2015 -0700
+++ b/test/tools/javac/lambda/TargetType46.java	Mon Mar 30 17:09:14 2015 +0530
@@ -1,6 +1,6 @@
 /*
  * @test /nodynamiccopyright/
- * @bug 8003280
+ * @bug 8003280 8062373
  * @summary Add lambda tests
  *  compiler doesn't report accessibility problem due to inaccessible target
  * @compile/fail/ref=TargetType46.out -XDrawDiagnostics TargetType46.java
@@ -22,6 +22,7 @@
         outer.m(()->{}); //access error
         outer.m(this::g); //access error
         outer.m(new ArrayList<>()); //ok
+        outer.m(new ArrayList<>() {}); // access error
         outer.m(Collections.emptyList()); //ok
     }
 
--- a/test/tools/javac/lambda/TargetType46.out	Sat Mar 28 10:18:27 2015 -0700
+++ b/test/tools/javac/lambda/TargetType46.out	Mon Mar 30 17:09:14 2015 +0530
@@ -1,3 +1,4 @@
 TargetType46.java:22:17: compiler.err.report.access: TargetType46Outer.PI, private, TargetType46Outer
 TargetType46.java:23:17: compiler.err.report.access: TargetType46Outer.PI, private, TargetType46Outer
-2 errors
+TargetType46.java:25:16: compiler.err.report.access: TargetType46Outer.PI, private, TargetType46Outer
+3 errors
--- a/test/tools/javac/lambda/TargetType68.java	Sat Mar 28 10:18:27 2015 -0700
+++ b/test/tools/javac/lambda/TargetType68.java	Mon Mar 30 17:09:14 2015 +0530
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2013, 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
@@ -23,9 +23,9 @@
 
 /*
  * @test
- * @bug 8010303
+ * @bug 8010303 8062373
  * @summary Graph inference: missing incorporation step causes spurious inference error
- * @compile TargetType68.java
+ * @compile/fail/ref=TargetType68.out -XDrawDiagnostics TargetType68.java
  */
 import java.util.*;
 
@@ -58,6 +58,6 @@
             List<XYChart.Data<Number, Number>> data_2 = new ArrayList<>();
             numberChart.getData().setAll(
                     Arrays.asList(new XYChart.Series<>("Data", FXCollections.observableList(data_1)),
-                    new XYChart.Series<>("Data", FXCollections.observableList(data_2))));
+                    new XYChart.Series<>("Data", FXCollections.observableList(data_2)) {}));
     }
 }
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/lambda/TargetType68.out	Mon Mar 30 17:09:14 2015 +0530
@@ -0,0 +1,3 @@
+TargetType68.java:61:32: compiler.err.cant.inherit.from.final: TargetType68.XYChart.Series
+TargetType68.java:61:39: compiler.err.cant.inherit.from.final: TargetType68.XYChart.Series
+2 errors
--- a/test/tools/javac/lambda/TargetType69.java	Sat Mar 28 10:18:27 2015 -0700
+++ b/test/tools/javac/lambda/TargetType69.java	Mon Mar 30 17:09:14 2015 +0530
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2013, 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
@@ -23,7 +23,7 @@
 
 /*
  * @test
- * @bug 8010303
+ * @bug 8010303 8062373
  * @summary Graph inference: missing incorporation step causes spurious inference error
  * @compile TargetType69.java
  */
@@ -47,5 +47,6 @@
 
     void test(Function<Integer, Integer> classifier, Function<Integer, Map<Integer, List<Integer>>> coll) {
         exerciseMapTabulation(coll, new GroupedMapAssertion<>(classifier));
+        exerciseMapTabulation(coll, new GroupedMapAssertion<>(classifier) {});
     }
 }
--- a/test/tools/javac/lambdaShapes/org/openjdk/tests/javac/FDTest.java	Sat Mar 28 10:18:27 2015 -0700
+++ b/test/tools/javac/lambdaShapes/org/openjdk/tests/javac/FDTest.java	Mon Mar 30 17:09:14 2015 +0530
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, 2014, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 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
@@ -108,9 +108,10 @@
     public static List<Pair<TestKind, Hierarchy>> generateCases() {
         ArrayList<Pair<TestKind,Hierarchy>> list = new ArrayList<>();
         HierarchyGenerator hg = new HierarchyGenerator();
+        int i = 0;
         for (TestKind tk : TestKind.values()) {
             for (Hierarchy hs : tk.getHierarchy(hg)) {
-                list.add(new Pair<>(tk, hs));
+                list.add((i++ % 2) == 0 ? new Pair<>(tk, hs) {} : new Pair<>(tk, hs));
             }
         }
         return list;
--- a/test/tools/javac/scope/DupUnsharedTest.java	Sat Mar 28 10:18:27 2015 -0700
+++ b/test/tools/javac/scope/DupUnsharedTest.java	Mon Mar 30 17:09:14 2015 +0530
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2014, 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
@@ -68,7 +68,7 @@
     }
 
     void runScopeContentTest() throws Exception {
-        Set<Symbol> expected = Collections.newSetFromMap(new IdentityHashMap<>());
+        Set<Symbol> expected = Collections.newSetFromMap(new IdentityHashMap<>() {});
         Set<Symbol> notExpected = Collections.newSetFromMap(new IdentityHashMap<>());
         WriteableScope s1 = WriteableScope.create(symtab.rootPackage);
         ClassSymbol acceptSym = symtab.arrayClass;
@@ -105,7 +105,7 @@
     }
 
     Set<Symbol> toSet(Iterable<Symbol> it) {
-        Set<Symbol> result = Collections.newSetFromMap(new IdentityHashMap<>());
+        Set<Symbol> result = Collections.newSetFromMap(new IdentityHashMap<>() {});
 
         for (Symbol sym : it) {
             result.add(sym);