changeset 3011:329f5ec6e169

Enhancement: add support for anyfied wildcards in javac * parser changes to support new Foo<any> syntax for anyfied wildcards * type system changes to match semantics of new wildcard types * code generation changes, erasure also applies a 'virtualization' pass * virtualized accessors fo through indy to hide boxing adapations * added several tests Todo: * separate compilation doesn't work properly w.r.t. anyfied wildcards (as there's no way to represent them inside Signature attributes, yet) * semantics of unchecked calls might need further refinements
author mcimadamore
date Thu, 09 Jul 2015 16:14:35 +0100
parents ffc0d863bbf9
children 79986bf4ea64
files src/jdk.compiler/share/classes/com/sun/tools/javac/code/Flags.java src/jdk.compiler/share/classes/com/sun/tools/javac/code/Symbol.java src/jdk.compiler/share/classes/com/sun/tools/javac/code/Symtab.java src/jdk.compiler/share/classes/com/sun/tools/javac/code/Types.java src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Attr.java src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Check.java src/jdk.compiler/share/classes/com/sun/tools/javac/comp/SpecializeTypes.java src/jdk.compiler/share/classes/com/sun/tools/javac/comp/TypeEnter.java src/jdk.compiler/share/classes/com/sun/tools/javac/jvm/Gen.java src/jdk.compiler/share/classes/com/sun/tools/javac/parser/JavacParser.java src/jdk.compiler/share/classes/com/sun/tools/javac/resources/compiler.properties src/jdk.compiler/share/classes/com/sun/tools/javac/tree/JCTree.java src/jdk.compiler/share/classes/com/sun/tools/javac/tree/Pretty.java src/jdk.compiler/share/classes/com/sun/tools/javac/tree/TreeMaker.java test/tools/javac/diags/examples/CantSelectNonVirtual.java test/tools/javac/generics/bridges/BridgeHarness.java test/tools/javac/treeannotests/TestProcessor.java test/tools/javac/valhalla/typespec/Cast01.java test/tools/javac/valhalla/typespec/Cast01.out test/tools/javac/valhalla/typespec/Wildcards05.java test/tools/javac/valhalla/typespec/Wildcards06.java test/tools/javac/valhalla/typespec/Wildcards07.java test/tools/javac/valhalla/typespec/Wildcards07.out test/tools/javac/valhalla/typespec/Wildcards08.java test/tools/javac/valhalla/typespec/Wildcards08.out test/tools/javac/valhalla/typespec/Wildcards09.java test/tools/javac/valhalla/typespec/Wildcards09.out test/tools/javac/valhalla/typespec/items/BytecodeMappingHarness.java
diffstat 28 files changed, 1317 insertions(+), 120 deletions(-) [+]
line wrap: on
line diff
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/code/Flags.java	Wed Jul 08 15:14:54 2015 +0100
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/code/Flags.java	Thu Jul 09 16:14:35 2015 +0100
@@ -303,6 +303,11 @@
      */
     public static final long SPECIALIZABLE = 1L<<54;
 
+    /**
+     * Flag to mark virtualized members and types in SpecializeTypes
+     */
+    public static final long VIRTUAL = 1L << 55;
+
 
 
     /* Type-variable declaration flags - since standard Java flags are not supported on type
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/code/Symbol.java	Wed Jul 08 15:14:54 2015 +0100
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/code/Symbol.java	Thu Jul 09 16:14:35 2015 +0100
@@ -36,18 +36,13 @@
 import javax.lang.model.element.*;
 import javax.tools.JavaFileObject;
 
-import com.sun.tools.javac.code.Attribute.Compound;
-import com.sun.tools.javac.code.TypeAnnotations.AnnotationType;
-import com.sun.tools.javac.code.TypeMetadata.Entry;
 import com.sun.tools.javac.code.Types.AsSuperKind;
-import com.sun.tools.javac.comp.Annotate.AnnotationTypeCompleter;
 import com.sun.tools.javac.comp.Annotate.AnnotationTypeMetadata;
 import com.sun.tools.javac.code.Scope.WriteableScope;
 import com.sun.tools.javac.code.Type.*;
 import com.sun.tools.javac.comp.Attr;
 import com.sun.tools.javac.comp.AttrContext;
 import com.sun.tools.javac.comp.Env;
-import com.sun.tools.javac.comp.SpecializeTypes;
 import com.sun.tools.javac.jvm.*;
 import com.sun.tools.javac.jvm.Pool.MethodHandle;
 import com.sun.tools.javac.tree.JCTree.JCVariableDecl;
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/code/Symtab.java	Wed Jul 08 15:14:54 2015 +0100
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/code/Symtab.java	Thu Jul 09 16:14:35 2015 +0100
@@ -208,6 +208,7 @@
     public final Type elementTypeType;
     public final Type functionalInterfaceType;
     public final Type genericMethodSpecialzer;
+    public final Type virtualAccess;
 
     /** The symbol representing the length field of an array.
      */
@@ -284,7 +285,7 @@
         }
     }
 
-    public void synthesizeEmptyGenericMethodSpecializerIfMissing(final Type type) {
+    public void synthesizeEmptyBSMIfMissing(final Type type) {
         final Completer completer = type.tsym.completer;
         if (completer != null) {
             type.tsym.completer = new Completer() {
@@ -505,6 +506,7 @@
         lambdaMetafactory = enterClass("java.lang.invoke.LambdaMetafactory");
         functionalInterfaceType = enterClass("java.lang.FunctionalInterface");
         genericMethodSpecialzer = enterClass("java.lang.invoke.GenericMethodSpecializer");
+        virtualAccess = enterClass("java.lang.invoke.VirtualAccess");
 
         //transitional
         synthesizeEmptyInterfaceIfMissing(varHandleType);
@@ -515,7 +517,8 @@
         synthesizeEmptyInterfaceIfMissing(cloneableType);
         synthesizeEmptyInterfaceIfMissing(serializableType);
         synthesizeEmptyInterfaceIfMissing(lambdaMetafactory);
-        synthesizeEmptyGenericMethodSpecializerIfMissing(genericMethodSpecialzer);
+        synthesizeEmptyBSMIfMissing(genericMethodSpecialzer);
+        synthesizeEmptyBSMIfMissing(virtualAccess);
         synthesizeEmptyInterfaceIfMissing(serializedLambdaType);
         synthesizeBoxTypeIfMissing(doubleType);
         synthesizeBoxTypeIfMissing(floatType);
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/code/Types.java	Wed Jul 08 15:14:54 2015 +0100
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/code/Types.java	Thu Jul 09 16:14:35 2015 +0100
@@ -237,8 +237,7 @@
         if (t.hasTag(WILDCARD)) {
             WildcardType w = (WildcardType) t;
             if (w.isSuperBound()) {
-                boolean shouldDrop = w.isUnbound() || !isAnyTypeVar(w.type);
-                return w.bound == null ? syms.objectType : (shouldDrop ? dropAny(w.bound.bound) : w.bound.bound);
+                return w.bound == null ? syms.objectType : w.bound.bound;
             } else {
                 return wildUpperBound(w.type);
             }
@@ -367,6 +366,7 @@
 
             @Override
             public Boolean visitClassType(ClassType t, Predicate<Type> typeArgsFilter) {
+                if (isVirtualizable(t)) return false;
                 return t.allparams().stream()
                         .filter(typeArgsFilter)
                         .anyMatch(targ -> visit(targ, typeArgsFilter)) ||
@@ -415,7 +415,7 @@
 
         @Override
         public Boolean visitWildcardType(WildcardType t, Void aVoid) {
-            return visit(t.type, null);
+            return isAnyUnboundTypeArgument(t) || visit(t.type, null);
         }
 
         @Override
@@ -969,7 +969,7 @@
        @Override
        public boolean accepts(Symbol sym) {
            return sym.kind == MTH &&
-                   (sym.flags() & (ABSTRACT | DEFAULT)) == ABSTRACT &&
+                   (sym.flags() & (ABSTRACT | DEFAULT | SYNTHETIC)) == ABSTRACT &&
                    !overridesObjectMethod(origin, sym) &&
                    (interfaceCandidates(origin.type, (MethodSymbol)sym).head.flags() & DEFAULT) == 0;
        }
@@ -1004,7 +1004,8 @@
                 return true;
             } else if (t.hasTag(TYPEVAR)) {
                 return isSubtypeUnchecked(t.getUpperBound(), s, warn);
-            } else if (!s.isRaw() && !isSpecializable(s)) {
+            } else if (!s.isRaw() && //specializable types are not compatible with raw
+                    s.allparams().stream().noneMatch(this::isTypeArgumentSpecializable)) {
                 Type t2 = asSuper(t, s.tsym);
                 if (t2 != null && t2.isRaw()) {
                     if (isReifiable(s)) {
@@ -1166,6 +1167,10 @@
             public Boolean visitClassType(ClassType t, Type s) {
                 Type sup = asSuper(t, s.tsym);
                 if (sup == null) return false;
+                if (s.isRaw() && t.allparams().stream().anyMatch(Types.this::isTypeArgumentSpecializable)) {
+                    //specializable types are not compatible with raw
+                    return false;
+                }
                 // If t is an intersection, sup might not be a class type
                 if (!sup.hasTag(CLASS)) return isSubtypeNoCapture(sup, s);
                 return sup.tsym == s.tsym
@@ -1657,7 +1662,8 @@
                     return isSameWildcard(t, s)
                         || isCaptureOf(s, t)
                         || ((t.isExtendsBound() || isSubtypeNoCapture(wildLowerBound(t), wildLowerBound(s))) &&
-                            (t.isSuperBound() || isSubtypeNoCapture(wildUpperBound(s), wildUpperBound(t))));
+                            (t.isSuperBound() || isSubtypeNoCapture(wildUpperBound(s), wildUpperBound(t)))) &&
+                            (!isTypeArgumentSpecializable(s) || isTypeArgumentSpecializable(t));
                 }
             }
 
@@ -1795,8 +1801,8 @@
 
                 if (s.hasTag(CLASS) || s.hasTag(ARRAY)) {
                     boolean upcast;
-                    if ((upcast = isSubtype(erasure(t), erasure(s)))
-                        || isSubtype(erasure(s), erasure(t))) {
+                    if ((upcast = isSubtype(erasureSource(t), erasureSource(s)))
+                        || isSubtype(erasureSource(s), erasureSource(t))) {
                         if (!upcast && s.hasTag(ARRAY)) {
                             if (!isReifiable(s))
                                 warnStack.head.warn(LintCategory.UNCHECKED);
@@ -2419,7 +2425,7 @@
                         if (ownerParams.nonEmpty()) {
                             if (baseParams.isEmpty()) {
                                 // then base is a raw type
-                                return erasure(sym.type, ErasureKind.SOURCE);
+                                return erasureSource(sym.type);
                             } else {
                                 return subst(sym.type, ownerParams, baseParams);
                             }
@@ -2565,6 +2571,10 @@
             }
         };
 
+    public Type erasureSource(Type t) {
+        return erasure(t, ErasureKind.SOURCE);
+    }
+
     public List<Type> erasure(List<Type> ts) {
         return erasure.visit(ts, ErasureKind.NORMAL);
     }
@@ -2581,6 +2591,10 @@
         return erasure(t, ErasureKind.REFERENCE_ONLY);
     }
 
+    public List<Type> erasureSource(List<Type> ts) {
+        return erasure.visit(ts, ErasureKind.SOURCE);
+    }
+
     public List<Type> erasureReference(List<Type> ts) {
         return erasure.visit(ts, ErasureKind.REFERENCE_ONLY);
     }
@@ -2591,7 +2605,8 @@
     enum ErasureKind {
         /**
          * Standard erasure behavior. Class types are not recursively erased,
-         * synthetic 'any' type is erased to Object.
+         * synthetic 'any' type is erased to Object. Class types are specialized and virtualized
+         * (if needed) before erasure is applied.
          */
         NORMAL,
         /**
@@ -2605,7 +2620,7 @@
          */
         REFERENCE_ONLY,
         /**
-         * Specialized erasure behavior. Class types are specialized before erasure is applied.
+         * Source erasure behavior. Specialization/virtualization is not applied.
          * Otherwise, behavior is same as with {@link com.sun.tools.javac.code.Types.ErasureKind##NORMAL}.
          */
         SOURCE;
@@ -2631,12 +2646,16 @@
 
     /**
      * Thsi visitor computes a specialized type from given type, if needed. For classes, this involves
-     * creating a supporting specialized symbol {@link Types##specializeSymbol(com.sun.tools.javac.code.Types.UniqueType, Type)},
+     * creating a supporting specialized symbol {@link Types#specializeSymbol(com.sun.tools.javac.code.Types.UniqueType, Type)},
      * where value-based type-parameters are encoded as part of the symbol name.
      */
     MapVisitor<Void> specialize = new MapVisitor<Void>() {
         @Override
         public Type visitClassType(ClassType ct, Void aVoid) {
+            if (isVirtualizable(ct)) {
+                ClassSymbol virtualClass = virtualizeClass(ct.tsym);
+                return visitClassType((ClassType)subst(virtualClass.type, virtualClass.type.allparams(), ct.allparams()), null);
+            }
             //compute specialization of enclosing type
             Type specializedEncl = specialize(ct.getEnclosingType());
 
@@ -2668,7 +2687,7 @@
                                 specializedClassSymbol) {
                                 @Override
                                 public Type baseType() {
-                                    return ct;
+                                    return ct.baseType();
                                 }
                             };
                 }
@@ -2976,6 +2995,189 @@
     }
     // </editor-fold>
 
+    // <editor-fold defaultstate="collapsed" desc="virtualization">
+    /** cache of virtualized class symbols. */
+    HashMap<ClassSymbol, ClassSymbol> virtualizedSymbols = new HashMap<>();
+
+    /**
+     * Generate a virtualized interface corresponding to a given anyfied class/interface. The virtual
+     * interface is used as common supertype between all parameterization (both value and reference)
+     * of a given anyfied class/interface.
+     */
+    public ClassSymbol virtualizeClass(TypeSymbol origin) {
+        ClassSymbol csym = (ClassSymbol)origin;
+        ClassSymbol result = virtualizedSymbols.get(csym);
+        if (result == null) {
+            //compute specialized class symbol
+            ClassSymbol virtualIntfSym = result =
+                    new ClassSymbol((csym.flags() & Flags.AccessFlags) |
+                            Flags.ACYCLIC | Flags.INTERFACE | Flags.STATIC | Flags.VIRTUAL | Flags.ABSTRACT,
+                            names.fromString("$any"), null, csym) {
+                        @Override
+                        public Symbol baseSymbol() {
+                            return origin.baseSymbol();
+                        }
+                    };
+
+            virtualizedSymbols.put(csym, virtualIntfSym);
+
+            ClassType virtualIntfType = new ClassType(Type.noType, List.nil(), virtualIntfSym);
+            virtualIntfType.supertype_field = syms.objectType;
+            virtualIntfSym.type = virtualIntfType;
+            virtualIntfSym.members_field = WriteableScope.create(virtualIntfSym);
+            virtualIntfSym.sourcefile = csym.sourcefile;
+
+            //lazy completion support
+            virtualIntfSym.completer = (_unused) -> {
+                    for (Symbol m : csym.members().getSymbols()) {
+                        if (m.kind == TYP ||
+                                m.isStatic() ||
+                                m.isConstructor() ||
+                                containsAnyfiedArrays(m.type) ||
+                                (m.flags() & Flags.PUBLIC) == 0)
+                            continue; //only public instance methods/fields!
+                        if (m.kind == MTH) {
+                            //simply clone the method
+                            MethodSymbol m2 = (MethodSymbol)m.clone(virtualIntfSym);
+                            m2.flags_field = Flags.SYNTHETIC | Flags.SPECIALIZABLE | Flags.PUBLIC | Flags.ABSTRACT;
+                            m2.type = asVirtualType(m2.type);
+                            virtualIntfSym.members().enter(m2);
+                        } else {
+                            virtualIntfSym.members().enter(makeGetter((VarSymbol)m, virtualIntfSym));
+                            virtualIntfSym.members().enter(makeSetter((VarSymbol)m, virtualIntfSym));
+                        }
+                    }
+                };
+        }
+
+        return result;
+    }
+
+    /**
+     * Does a given type contain anyfied arrays?
+     */
+    public boolean containsAnyfiedArrays(Type t) {
+        return t.accept(hasAnyfiedArrays, false);
+    }
+
+    SimpleVisitor<Boolean, Boolean> hasAnyfiedArrays = new SimpleVisitor<Boolean, Boolean>() {
+        @Override
+        public Boolean visitType(Type t, Boolean insideArray) {
+            return false;
+        }
+
+        @Override
+        public Boolean visitArrayType(ArrayType t, Boolean insideArray) {
+            return visit(t.elemtype, true);
+        }
+
+        @Override
+        public Boolean visitTypeVar(TypeVar t, Boolean insideArray) {
+            return insideArray && isAnyTypeVar(t);
+        }
+
+        @Override
+        public Boolean visitClassType(ClassType t, Boolean aBoolean) {
+            return false;
+        }
+
+        @Override
+        public Boolean visitMethodType(MethodType t, Boolean insideArray) {
+            return t.getParameterTypes().prepend(t.getReturnType()).stream()
+                    .anyMatch(p -> visit(p, false));
+        }
+    };
+
+    /**
+     * Compute the virtual type associated with a given type. In most cases, the virtual type of X
+     * will be just |X|. There are cases however, where things are different - such as when the input
+     * type contains anyfied unbounded wildcards (in which case virtualization is necessary).
+     */
+    public Type asVirtualType(Type t) {
+        return asVirtualType(t, this::erasure);
+    }
+
+    public Type asVirtualType(Type t, Function<Type, Type> typeFunc) {
+        return t.map(virtualTypeMap, typeFunc);
+    }
+
+    public TypeMapping<Function<Type, Type>> virtualTypeMap = new TypeMapping<Function<Type, Type>>() {
+        @Override
+        public Type visitClassType(ClassType t, Function<Type, Type> typeFunc) {
+            return t.allparams().stream().anyMatch(ta -> isAnyTypeVar(ta) || isAnyUnboundTypeArgument(ta)) ?
+                    virtualizeClass(t.tsym).type : typeFunc.apply(t);
+        }
+
+        @Override
+        public Type visitTypeVar(TypeVar t, Function<Type, Type> typeFunc) {
+            return typeFunc.apply(t);
+        }
+    };
+
+    /**
+     * Generate getter method symbol for virtual interface.
+     */
+    Symbol makeGetter(VarSymbol field, TypeSymbol origin) {
+        Type accessorType = new MethodType(
+                List.nil(),
+                asVirtualType(field.type),
+                List.nil(),
+                syms.methodClass);
+        return new MethodSymbol(Flags.ABSTRACT | Flags.SYNTHETIC | Flags.SPECIALIZABLE | Flags.PUBLIC,
+                field.name.append(names.fromString("$get")), accessorType, origin) {
+            @Override
+            public Symbol baseSymbol() {
+                return field.baseSymbol();
+            }
+        };
+    }
+
+    /**
+     * Generate setter method symbol for virtual interface.
+     */
+    Symbol makeSetter(VarSymbol field, TypeSymbol origin) {
+        Type accessorType = new MethodType(
+                List.of(asVirtualType(field.type)),
+                asVirtualType(field.type),
+                List.nil(),
+                syms.methodClass);
+        return new MethodSymbol(Flags.ABSTRACT | Flags.SYNTHETIC | Flags.SPECIALIZABLE | Flags.PUBLIC,
+                field.name.append(names.fromString("$set")), accessorType, origin) {
+            @Override
+            public Symbol baseSymbol() {
+                return field.baseSymbol();
+            }
+        };
+    }
+
+    /**
+     * Should a given type be virtualized?
+     */
+    public boolean isVirtualizable(ClassType ctype) {
+        return ctype.allparams().stream().anyMatch(this::isAnyUnboundTypeArgument);
+    }
+    //where
+        private boolean isAnyUnboundTypeArgument(Type t) {
+            switch (t.getTag()) {
+                case WILDCARD:
+                    WildcardType wt = (WildcardType)t;
+                    return wt.isUnbound() && wt.type.hasTag(ANY_BOUND);
+                case TYPEVAR:
+                    return ((TypeVar)t).isCaptured() &&
+                            isAnyUnboundTypeArgument(((CapturedType)t).wildcard);
+                default:
+                    return false;
+            }
+        }
+
+    /**
+     * Does a given symbol correspond to an anyfied class?
+     */
+    public boolean isAnyfied(TypeSymbol tsym) {
+        return typeVarsByOwner(tsym).stream().flatMap(t -> t.elem1.stream()).anyMatch(this::isAnyTypeVar);
+    }
+    // </editor-fold>
+
     // <editor-fold defaultstate="collapsed" desc="supertype">
     public Type supertype(Type t) {
         return supertype.visit(t);
@@ -3138,26 +3340,29 @@
 
     // <editor-fold defaultstate="collapsed" desc="typeVarsByOwner">
     public List<Tuple2<Symbol, List<Type>>> typeVarsByOwner(Symbol sym) {
-        Symbol currentSym = sym;
-        List<Tuple2<Symbol, List<Type>>> varsByOwner = List.nil();
-        while (true) {
-            if (currentSym.type != null) {
-                //some synthetic symbols do not have a corresponding type - skip them
-                List<Type> targs = currentSym.type.getTypeArguments();
-                if (targs.nonEmpty()) {
-                    varsByOwner = varsByOwner.append(new Tuple2<>(currentSym, targs));
-                }
-            }
-            if (currentSym == sym.outermostClass() ||
-                    (currentSym.flags() & (STATIC | SPECIALIZABLE)) == STATIC) {
-                break;
-            }
-            do {
-                currentSym = currentSym.owner;
-            } while (currentSym.kind != TYP && currentSym.kind != MTH);
-        }
-        return varsByOwner;
-    }
+        return ownersClosure(sym).stream()
+                .filter(s -> (s.kind == MTH || s.kind == TYP) && s.type != null)
+                .map(s -> new Tuple2<>(s, s.type.getTypeArguments()))
+                .collect(List.collector());
+    }
+    //where
+        List<Symbol> ownersClosure(Symbol sym) {
+            return ownersClosure(sym, List.nil()).reverse();
+        }
+
+        List<Symbol> ownersClosure(Symbol sym, List<Symbol> closure) {
+            closure = closure.prepend(sym);
+            switch (sym.kind) {
+                case VAR:
+                case MTH:
+                case TYP:
+                    return ((sym.flags() & (STATIC | SPECIALIZABLE)) == STATIC) ?
+                            closure :
+                            ownersClosure(sym.owner, closure);
+                default:
+                    return closure;
+            }
+        }
     // </editor-fold>
 
     // <editor-fold defaultstate="collapsed" desc="isDerivedRaw">
@@ -3503,7 +3708,7 @@
                 Scope s = c.members();
                 for (Symbol sym : s.getSymbols(NON_RECURSIVE)) {
                     if (sym.kind == MTH &&
-                            (sym.flags() & (ABSTRACT | IPROXY | DEFAULT)) == ABSTRACT) {
+                            (sym.flags() & (SYNTHETIC | ABSTRACT | IPROXY | DEFAULT)) == ABSTRACT) {
                         //skip ref-only method as needed
                         if (c != impl &&
                                 ((MethodSymbol)sym).isApplicabilityRestrictedIn(impl.type, this)) {
@@ -5194,11 +5399,7 @@
      * such variables might cause a type such as {@code Foo} to be turned into {@code Foo<int>}.
      */
     public Type decorateDescriptor(Type source, Type target) {
-        try {
-            return source.map(new DescriptorAugmentor(), target);
-        } catch (NullPointerException ex) {
-            throw new AssertionError("bad adapt " + source + " " + erasure(target, ErasureKind.SOURCE), ex);
-        }
+        return source.map(new DescriptorAugmentor(), target);
     }
 
     public class DescriptorAugmentor extends TypeMapping<Type> {
@@ -5209,7 +5410,7 @@
 
         @Override
         public Type visitClassType(ClassType t, Type target) {
-            Type erased = erasure(target, ErasureKind.SOURCE);
+            Type erased = erasureSource(target);
             return asSuper(t, erased.tsym);
         }
 
@@ -5235,7 +5436,7 @@
                         new ArrayType(newElem, syms.arrayClass) :
                         t;
             } else {
-                Type erased = erasure(target, ErasureKind.SOURCE);
+                Type erased = erasureSource(target);
                 return asSuper(t, erased.tsym);
             }
         }
@@ -5254,7 +5455,7 @@
 
         @Override
         public Type visitTypeVar(TypeVar t, Type target) {
-            Type erased = erasure(target, ErasureKind.SOURCE);
+            Type erased = erasureSource(target);
             return isAnyTypeVar(t) ? t : asSuper(t, erased.tsym);
         }
     }
@@ -5737,7 +5938,11 @@
 
         public void assembleClassSig(Type type, SigMode mode) {
             ClassType ct = (ClassType) type;
-            ClassSymbol c = (ClassSymbol) ct.tsym;
+            //Todo: this means that we cannot recover back info associated with Box<any>
+            //from ClassReader, as exact info gets erased here (bytecode enhancemet needed)
+            ClassSymbol c = types.isVirtualizable(ct) ?
+                    types.virtualizeClass(ct.tsym) :
+                    (ClassSymbol) ct.tsym;
             classReference(c);
             Type outer = ct.getEnclosingType();
             if (outer.allparams().nonEmpty()) {
@@ -5755,7 +5960,7 @@
             } else {
                 append(externalize(c.flatname));
             }
-            if (ct.getTypeArguments().nonEmpty()) {
+            if (!types.isVirtualizable(ct) && ct.getTypeArguments().nonEmpty()) {
                 append('<');
                 boolean prevToplevel = toplevel;
                 try {
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Attr.java	Wed Jul 08 15:14:54 2015 +0100
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Attr.java	Thu Jul 09 16:14:35 2015 +0100
@@ -1995,7 +1995,6 @@
         // Attribute clazz expression and store
         // symbol + type back into the attributed tree.
         Type clazztype;
-
         try {
             env.info.isNewClass = true;
             clazztype = TreeInfo.isEnumInit(env.tree) ?
@@ -3373,6 +3372,19 @@
                               new ResultInfo(KindSelector.TYP_PCK, pt()));
         }
 
+        // Disallow selecting a non-virtual field from an expression whose type is anyfied raw/wildcard
+        if ((sym.kind == VAR || sym.kind == MTH) &&
+                (sitesym == null || !sitesym.kind.matches(KindSelector.TYP_PCK)) &&
+                tree.selected.type != null && tree.selected.type.hasTag(CLASS) &&
+                types.isVirtualizable((ClassType)tree.selected.type) &&
+                (types.containsAnyfiedArrays(sym.type) ||
+                (sym.flags() & PUBLIC) == 0)) {
+            Fragment reason = types.containsAnyfiedArrays(sym.type) ?
+                    Fragments.VirtualAnyfiedArrays(sym) :
+                    Fragments.VirtualNonPublic(sym);
+            log.error(tree, Errors.CantSelectNonVirtual(reason));
+        }
+
         if (isType(sitesym)) {
             if (sym.name == names._this) {
                 // If `C' is the currently compiled class, check that
@@ -3945,9 +3957,10 @@
                         rs.methodArguments(argtypes.map(checkDeferredMap)),
                         kindName(sym.location()),
                         sym.location());
+               //Todo: this probably needs to be revised to take into account partially erased types
                owntype = new MethodType(owntype.getParameterTypes(),
-                       types.erasure(owntype.getReturnType()),
-                       types.erasure(owntype.getThrownTypes()),
+                       types.erasureSource(owntype.getReturnType()),
+                       types.erasureSource(owntype.getThrownTypes()),
                        syms.methodClass);
             }
 
@@ -4133,7 +4146,7 @@
         if (bounds.nonEmpty()) {
             // accept class or interface or typevar as first bound.
             bounds.head.type = checkBase(bounds.head.type, bounds.head, env, false, false, false);
-            boundSet.add(types.erasure(bounds.head.type));
+            boundSet.add(bounds.head.type.tsym.erasure(types));
             if (bounds.head.type.isErroneous()) {
                 return bounds.head.type;
             } else if (tree.type != null && types.isAnyTypeVar(tree.type)) {
@@ -4162,7 +4175,7 @@
                         bounds = List.of(bound);
                     }
                     else if (bound.type.hasTag(CLASS)) {
-                        chk.checkNotRepeated(bound.pos(), types.erasure(bound.type), boundSet);
+                        chk.checkNotRepeated(bound.pos(), bound.type.tsym.erasure(types), boundSet);
                     }
                 }
             }
@@ -4207,13 +4220,19 @@
     }
 
     public void visitWildcard(JCWildcard tree) {
-        //- System.err.println("visitWildcard("+tree+");");//DEBUG
-        Type type = (tree.kind.kind == BoundKind.UNBOUND)
-            ? syms.objectType
-            : attribType(tree.inner, env);
-        result = check(tree, new WildcardType(chk.checkRefType(tree.pos(), type, true),
-                                              tree.kind.kind,
-                                              syms.boundClass),
+        Type bound;
+        switch (tree.kind.kind) {
+            case UNBOUND_ANY:
+                bound = syms.anyType;
+                break;
+            case UNBOUND_REF:
+                bound = syms.objectType;
+                break;
+            default:
+                bound = chk.checkRefType(tree.pos(), attribType(tree.inner, env), true);
+        }
+        result = check(tree,
+                new WildcardType(bound, tree.kind.asBoundKind(), syms.boundClass),
                 KindSelector.TYP, resultInfo);
     }
 
@@ -4293,7 +4312,7 @@
         chk.checkNonCyclic(null, c.type);
 
         Type st = types.supertype(c.type);
-        if ((c.flags_field & Flags.COMPOUND) == 0) {
+        if ((c.flags_field & (Flags.VIRTUAL | Flags.COMPOUND)) == 0) {
             // First, attribute superclass.
             if (st.hasTag(CLASS))
                 attribClass((ClassSymbol)st.tsym);
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Check.java	Wed Jul 08 15:14:54 2015 +0100
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Check.java	Thu Jul 09 16:14:35 2015 +0100
@@ -1100,8 +1100,11 @@
          *  Check that a type is well-formed w.r.t. its bound.
          */
         boolean checkBound(Type a, Type bound) {
-            if (a.isUnbound() || bound.hasTag(TypeTag.ANY_BOUND)) {
+            if (bound.hasTag(TypeTag.ANY_BOUND)) {
                 return true;
+            } else if (a.hasTag(WILDCARD) &&
+                    ((WildcardType)a).type.hasTag(ANY_BOUND)) {
+                return false;
             } else if (a.isPrimitiveOrValue()) {
                 return bound.hasTag(TypeTag.VAL_BOUND);
             } else if (!a.hasTag(WILDCARD)) {
@@ -2462,6 +2465,7 @@
     }
 
     void checkConflicts(DiagnosticPosition pos, Symbol sym, TypeSymbol c) {
+        if ((sym.enclClass().flags() & VIRTUAL) != 0) return; //skip conflicts checks on virtual (synthetic) interfaces
         for (Type ct = c.type; ct != Type.noType ; ct = types.supertype(ct)) {
             for (Symbol sym2 : ct.tsym.members().getSymbolsByName(sym.name, NON_RECURSIVE)) {
                 // VM allows methods and variables with differing types
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/SpecializeTypes.java	Wed Jul 08 15:14:54 2015 +0100
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/SpecializeTypes.java	Thu Jul 09 16:14:35 2015 +0100
@@ -26,14 +26,16 @@
 package com.sun.tools.javac.comp;
 
 import com.sun.tools.javac.code.Flags;
-import com.sun.tools.javac.code.Kinds;
 import com.sun.tools.javac.code.Symbol;
 import com.sun.tools.javac.code.Symbol.ClassSymbol;
+import com.sun.tools.javac.code.Symbol.DynamicMethodSymbol;
 import com.sun.tools.javac.code.Symbol.DynamicMethodSymbol.BootstrapArgument;
 import com.sun.tools.javac.code.Symbol.DynamicMethodSymbol.BootstrapArgument.Kind;
 import com.sun.tools.javac.code.Symbol.MethodSymbol;
 import com.sun.tools.javac.code.Symbol.VarSymbol;
+import com.sun.tools.javac.code.Symtab;
 import com.sun.tools.javac.code.Type;
+import com.sun.tools.javac.code.Type.ClassType;
 import com.sun.tools.javac.code.Type.ForAll;
 import com.sun.tools.javac.code.Type.MethodType;
 import com.sun.tools.javac.code.TypeTag;
@@ -46,6 +48,7 @@
 import com.sun.tools.javac.tree.JCTree;
 import com.sun.tools.javac.tree.JCTree.JCArrayAccess;
 import com.sun.tools.javac.tree.JCTree.JCArrayTypeTree;
+import com.sun.tools.javac.tree.JCTree.JCAssign;
 import com.sun.tools.javac.tree.JCTree.JCBlock;
 import com.sun.tools.javac.tree.JCTree.JCClassDecl;
 import com.sun.tools.javac.tree.JCTree.JCExpression;
@@ -67,7 +70,9 @@
 import com.sun.tools.javac.tree.TreeScanner;
 import com.sun.tools.javac.util.Assert;
 import com.sun.tools.javac.util.Context;
+import com.sun.tools.javac.util.Filter;
 import com.sun.tools.javac.util.List;
+import com.sun.tools.javac.util.ListBuffer;
 import com.sun.tools.javac.util.Log;
 import com.sun.tools.javac.util.Name;
 import com.sun.tools.javac.util.Tuple.Tuple2;
@@ -75,9 +80,19 @@
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Optional;
+import java.util.function.BiFunction;
+import java.util.function.Function;
 import java.util.function.Supplier;
 import java.util.stream.Collectors;
 
+import static com.sun.tools.javac.code.Kinds.Kind.*;
+import static com.sun.tools.javac.code.TypeTag.CLASS;
+import static com.sun.tools.javac.code.TypeTag.FORALL;
+import static com.sun.tools.javac.code.TypeTag.VOID;
+import static com.sun.tools.javac.tree.JCTree.Tag.APPLY;
+import static com.sun.tools.javac.tree.JCTree.Tag.ASSIGN;
+import static com.sun.tools.javac.tree.JCTree.Tag.SELECT;
+
 /**
  * This pass specializes primitive/value generic types.
  *
@@ -100,12 +115,14 @@
     }
 
     private Types types;
+    private Enter enter;
     private Log log;
 
     private SpecializeTypes(Context context) {
         super(context);
         context.put(specializeTypesKey, this);
         types = Types.instance(context);
+        enter = Enter.instance(context);
         log = Log.instance(context);
     }
 
@@ -124,12 +141,15 @@
     /** current inference context. */
     InferenceContext inferenceContext;
 
+    /** enclosing operation. */
+    JCExpression enclOp;
+
     /**
      * Return the specialized supertypes matching given symbol 'sym'.
      */
     Symbol asSpecializedSymbol(Type t, Symbol sym) {
         Type specializedSuper = types.specialize(types.asOuterSuper(t, sym.owner));
-        return (specializedSuper != null && (specializedSuper.tsym.flags() & Flags.SPECIALIZED_CLASS) != 0) ?
+        return (specializedSuper != null && (specializedSuper.tsym.flags() & (Flags.SPECIALIZED_CLASS | Flags.VIRTUAL)) != 0) ?
                 specializedSuper.tsym.members().findFirst(sym.name, s -> s.baseSymbol() == sym) :
                 null;
     }
@@ -152,14 +172,14 @@
     /**
      * Specialize a generic method call (if needed).
      */
-    JCExpression specializeGenericMethodCallIfNeeded(JCMethodInvocation tree) {
+    JCMethodInvocation specializeGenericMethodCallIfNeeded(JCMethodInvocation tree) {
         Symbol msym = TreeInfo.symbol(tree.meth);
         return specializeGenericMethodCallIfNeeded(msym, tree, tree.typeargs.nonEmpty() ?
-                        TreeInfo.types(tree.typeargs) :
-                        inferredTypeargs(tree.meth.type, msym));
+                TreeInfo.types(tree.typeargs) :
+                inferredTypeargs(tree.meth.type, msym));
     }
 
-    JCExpression specializeGenericMethodCallIfNeeded(Symbol msym, JCMethodInvocation tree, List<Type> inferredTypeargs) {
+    JCMethodInvocation specializeGenericMethodCallIfNeeded(Symbol msym, JCMethodInvocation tree, List<Type> inferredTypeargs) {
         JCExpression receiverExpr = null;
         if (!msym.isStatic()) {
             receiverExpr = tree.meth.hasTag(Tag.SELECT) ?
@@ -205,7 +225,8 @@
     /**
      * Replace a generic method/constructor call with a specialized/indified method call.
      */
-    JCExpression specializeGenericCallIfNeeded(JCExpression tree, Symbol msym,
+    @SuppressWarnings("unchecked")
+    <E extends JCExpression> E specializeGenericCallIfNeeded(E tree, Symbol msym,
                                                List<JCExpression> args, JCExpression receiverExpr,
                                                List<Type> typeargs, Type receiverType, Type varargsElement) {
         if (typeargs.nonEmpty()) {
@@ -275,7 +296,8 @@
                                 types.asSuper(p.elem1, types.erasure(p.elem0).tsym))
                         .collect(List.collector());
 
-                Type indyType = types.subst(uninstantiatedMethodType.asMethodType(), formals, instTypes);
+                Type mt = uninstantiatedMethodType;
+                Type indyType = types.subst(mt.asMethodType(), formals, instTypes);
                 if (receiverExpr != null) {
                     indyType = types.createMethodTypeWithParameters(indyType,
                             indyType.getParameterTypes().prepend(receiverType));
@@ -292,7 +314,7 @@
 
                 //set type to be inferred type (instead of indy return type). This will cause
                 //usual checkcast to be generated during TransTypes (where required).
-                return methInv.setType(tree.type);
+                return (E)methInv.setType(tree.type);
             }
         }
         return tree;
@@ -306,6 +328,14 @@
         return super.translate(tree);
     }
 
+    public <T extends JCTree> T translate(T tree, JCExpression enclOp) {
+        JCExpression prevEnclOp = this.enclOp;
+        this.enclOp = enclOp;
+        T res = translate(tree);
+        this.enclOp = prevEnclOp;
+        return res;
+    }
+
     /**
      * ****************************************************************
      * Visitor methods
@@ -334,12 +364,35 @@
         result = tree;
     }
 
+    public void visitAssign(JCAssign tree) {
+        tree.lhs = translate(tree.lhs, tree);
+        tree.rhs = translate(tree.rhs);
+
+        // If translated left hand side is an Apply, we are
+        // seeing an access method invocation. In this case, append
+        // right hand side as last argument of the access method.
+        if (tree.lhs.hasTag(APPLY)) {
+            JCMethodInvocation app = (JCMethodInvocation)tree.lhs;
+            app.args = List.of(tree.rhs).prependList(app.args);
+            result = app;
+        } else {
+            result = tree;
+        }
+    }
+
     @Override
     public void visitSelect(JCFieldAccess tree) {
-        if (tree.name == names._class) {
+        if (tree.sym.kind == VAR &&
+                tree.selected.type.hasTag(CLASS) &&
+                types.isVirtualizable((ClassType)tree.selected.type)) {
+            //indy accessor
+            result = makeVirtualAccessorCall(tree, List.nil(),
+                    (enclOp != null && enclOp.hasTag(ASSIGN)) ? VirtualKind.SETTER : VirtualKind.GETTER);
+            return;
+        } else if (tree.name == names._class) {
             tree.selected.unerasedType = tree.selected.type;
         }
-        tree.selected = translate(tree.selected);
+        tree.selected = translate(tree.selected, null);
         if (tree.sym != null && !tree.sym.isStatic()) {
             Symbol specializedSymbol = asSpecializedSymbol(tree.selected.type, tree.sym);
             if (specializedSymbol != null) {
@@ -416,7 +469,7 @@
         do {
             templateMethodName = names.fromString("template" + sep + name);
             s = owner.members().findFirst(templateMethodName,
-                    s2 -> s2.kind == Kinds.Kind.MTH && sameErasure(msym, (MethodSymbol)s2));
+                    s2 -> s2.kind == MTH && sameErasure(msym, (MethodSymbol)s2));
             sep += "$";
 
         } while (s != null);
@@ -513,7 +566,14 @@
         }
         tree.meth = translate(tree.meth);
         tree.args = withInferenceContext(tree.meth.type, () -> translate(tree.args));
-        result = withInferenceContext(tree.meth.type, () -> specializeGenericMethodCallIfNeeded(rewriteSuperCallIfNeeded(tree)));
+        JCMethodInvocation call = withInferenceContext(tree.meth.type, () -> specializeGenericMethodCallIfNeeded(rewriteSuperCallIfNeeded(tree)));
+        if (!(TreeInfo.symbol(call.meth) instanceof DynamicMethodSymbol) &&
+                call.meth.hasTag(SELECT) &&
+                ((JCFieldAccess)call.meth).selected.type.hasTag(CLASS) &&
+                types.isVirtualizable((ClassType)((JCFieldAccess)call.meth).selected.type)) {
+            call = makeVirtualAccessorCall((JCFieldAccess)call.meth, tree.args, VirtualKind.METHOD);
+        }
+        result = call;
     }
 
     /**
@@ -596,6 +656,22 @@
                     .anyMatch(p -> p.elem0 != tree.sym && p.elem1.stream().anyMatch(types::isAnyTypeVar))) {
                 log.warning(tree, "valhalla.not.supported", "class with implicit any type-vars");
             }
+            if (types.isAnyfied(tree.sym)) {
+                //generate companion virtual interface
+                JCClassDecl virtualIntf = makeVirtualInterface(tree.sym);
+                for (Symbol s : virtualIntf.sym.members().getSymbols()) {
+                    if (s.baseSymbol().kind == VAR) {
+                        if (s.name.toString().endsWith("$get")) {
+                            makeGetterImpl((MethodSymbol)s, tree.type);
+                        } else {
+                            makeSetterImpl((MethodSymbol)s, tree.type);
+                        }
+                    } else {
+                        Assert.check(s.kind == MTH);
+                        makeVirtualBridgeIfNeeded((MethodSymbol)s, tree.type);
+                    }
+                }
+            }
             super.visitClassDef(tree);
             tree.defs = tree.defs.appendList(pendingDefs);
             result = tree;
@@ -647,6 +723,166 @@
     }
 
     /**
+     * Generate a tree corresponding to a virtual (synthetic) interface. Such an interface contains
+     * two things: (i) boxing getters/setters for the anyfied class fields; (ii) boxing bridges for
+     * the anyfied class methods.
+     */
+    JCClassDecl makeVirtualInterface(ClassSymbol csym) {
+        ClassSymbol virtualIntfSym = types.virtualizeClass(csym);
+
+        ListBuffer<JCTree> defs = new ListBuffer<>();
+        for (Symbol m : virtualIntfSym.members().getSymbols()) {
+            defs.add(make.MethodDef((MethodSymbol)m, null));
+        }
+
+        JCClassDecl intfDecl = make.ClassDef(
+                make.Modifiers(virtualIntfSym.flags()),
+                virtualIntfSym.name,
+                List.nil(),
+                null,
+                List.nil(),
+                defs.toList());
+        intfDecl.sym = virtualIntfSym;
+        intfDecl.type = virtualIntfSym.type;
+        enter.typeEnvs.put(virtualIntfSym, enter.typeEnvs.get(csym).dup(intfDecl));
+        pendingDefs = pendingDefs.prepend(intfDecl);
+        csym.members().enter(virtualIntfSym);
+        return intfDecl;
+    }
+
+    /**
+     * Generate an implementation for the virtual interface getter in the anyfied class.
+     */
+    void makeGetterImpl(MethodSymbol getter, Type site) {
+        MethodSymbol getterImpl = getter.clone(site.tsym);
+        Type fieldType = getter.baseSymbol().type;
+        if (types.isSpecializableTypeVar(fieldType)) {
+            getterImpl.type = types.createMethodTypeWithReturn(getterImpl.type, fieldType);
+        }
+        getterImpl.flags_field &= ~Flags.ABSTRACT; //synthetic/specialziable flags flag inherited from virtual symbol
+        JCStatement returnStat = make.Return(make.Ident(getter.baseSymbol()));
+        site.tsym.members().enter(getterImpl);
+        pendingDefs = pendingDefs.prepend(make.MethodDef(getterImpl, make.Block(0, List.of(returnStat))));
+    }
+
+    /**
+     * Generate an implementation for the virtual interface setter in the anyfied class.
+     */
+    void makeSetterImpl(MethodSymbol setter, Type site) {
+        MethodSymbol setterImpl = setter.clone(site.tsym);
+        Type fieldType = setter.baseSymbol().type;
+        if (types.isSpecializableTypeVar(fieldType)) {
+            setterImpl.type = types.createMethodTypeWithParameters(setterImpl.type, List.of(fieldType));
+            setterImpl.type = types.createMethodTypeWithReturn(setterImpl.type, fieldType);
+        }
+        setterImpl.flags_field &= ~Flags.ABSTRACT; //synthetic/specialziable flags flag inherited from virtual symbol
+        JCMethodDecl setterDef = make.MethodDef(setterImpl, null);
+        setterDef.params.head.sym.flags_field |= Flags.SYNTHETIC;
+        JCStatement assignStat = make.Return(make.Assign(make.Ident(setter.baseSymbol()), make.Ident(setterDef.params.head)));
+        setterDef.body = make.Block(0, List.of(assignStat));
+        site.tsym.members().enter(setterImpl);
+        pendingDefs = pendingDefs.prepend(setterDef);
+    }
+
+    /**
+     * Generate a bridge from the virtual definition to the erased definition. This is required as,
+     * because of virtualization, signatures of the erased class could not match 1-00% signatures
+     * in the virtual interface.
+     */
+    void makeVirtualBridgeIfNeeded(MethodSymbol virtualMethod, Type site) {
+        Symbol originalSymbol = virtualMethod.baseSymbol();
+        if (!types.isSameType(originalSymbol.erasure(types), virtualMethod.erasure(types))) {
+            MethodSymbol bridgeImpl = virtualMethod.clone(site.tsym);
+            bridgeImpl.type = types.asVirtualType(originalSymbol.type, t -> t);
+            bridgeImpl.flags_field &= ~Flags.ABSTRACT;
+            bridgeImpl.flags_field |= Flags.BRIDGE; //synthetic/specialziable flags inherited from virtual symbol
+            JCMethodDecl bridgeDef = make.MethodDef(bridgeImpl, null);
+            List<JCExpression> typeargs = null;
+            if (bridgeImpl.type.hasTag(FORALL)) {
+                ForAll fa = (ForAll)bridgeImpl.type;
+                typeargs = fa.tvars.stream().map(t -> make.Ident(t.tsym)).collect(List.collector());
+            }
+            // Construct a call of  this.impl(params), or super.impl(params),
+            // casting params and possibly results as needed.
+            JCExpression call =
+                make.Apply(
+                           typeargs,
+                           make.Ident(originalSymbol),
+                           Tuple2.zip(make.Idents(bridgeDef.params), originalSymbol.type.getParameterTypes()).stream()
+                                .map(t -> coerceVirtual(t.elem0, t.elem1)).collect(List.collector()))
+                .setType(originalSymbol.type.getReturnType());
+            JCStatement stat = (originalSymbol.type.getReturnType().hasTag(VOID))
+                ? make.Exec(call)
+                : make.Return(call);
+            bridgeDef.body = make.Block(0, List.of(stat));
+            site.tsym.members().enter(bridgeImpl);
+            pendingDefs = pendingDefs.prepend(translate(bridgeDef));
+        }
+    }
+
+    /**
+     * Helper method to cast an expression to given target type.
+     */
+    JCExpression coerceVirtual(JCExpression arg, Type target) {
+        boolean fromVirtual = (arg.type.tsym.flags() & Flags.VIRTUAL) != 0;
+        boolean toVirtual = (arg.type.tsym.flags() & Flags.VIRTUAL) != 0;
+        return (fromVirtual && !toVirtual) ?
+                make.TypeCast(arg, make.Type(target)) :
+                arg;
+    }
+
+    /**
+     * The enum represents the kind of a member of a virtual interface.
+     */
+    enum VirtualKind {
+        /** a getter member */
+        GETTER(s -> s.name.toString().contains("$get"),
+                (t, syms) -> new MethodType(List.nil(), t, List.nil(), syms.methodClass),
+                t -> t),
+        /** a setter member */
+        SETTER(s -> s.name.toString().contains("$set"),
+                (t,syms) -> new MethodType(List.of(t), t, List.nil(), syms.methodClass),
+                t -> t),
+        /** a boxing bridge */
+        METHOD(s -> true, (t, syms) -> t, t -> t.getReturnType());
+
+        final Filter<Symbol> asFilter;
+        final BiFunction<Type, Symtab, Type> asType;
+        final Function<Type, Type> asInvType;
+
+        VirtualKind(Filter<Symbol> asFilter, BiFunction<Type, Symtab, Type> asType, Function<Type, Type> asInvType) {
+            this.asFilter = asFilter;
+            this.asType = asType;
+            this.asInvType = asInvType;
+        }
+    }
+
+    /**
+     * Translate a regular field/method access (with virtualized receiver) into the corresponding
+     * virtualized accessor call. Translation uses invokedynamic to handle the mismatch between
+     * static typing (which supports partial wildcards, such as {@code Foo<any, int>} and runtime
+     * typing (which erases partial wildcards to the unique type {@code Foo$any}).
+     */
+    JCMethodInvocation makeVirtualAccessorCall(JCFieldAccess sel, List<JCExpression> args, VirtualKind vk) {
+        Symbol accessor = null;
+        for (Symbol s : types.virtualizeClass(sel.selected.type.tsym).members().getSymbols(vk.asFilter)) {
+            if (s.baseSymbol() == sel.sym.baseSymbol()) {
+                accessor = s;
+                break;
+            }
+        }
+        Assert.checkNonNull(accessor, "Cannot get here!");
+        Type indyType = vk.asType.apply(sel.type, syms);
+        //prepend receiver
+        indyType = types.createMethodTypeWithParameters(indyType, indyType.getParameterTypes().prepend(sel.selected.type));
+        List<BootstrapArgument<?>> static_args =
+                List.of(BootstrapArgument.MethodHandle(new MethodHandle(referenceKind(accessor), accessor, types)));
+        JCMethodInvocation methInv = makeIndyCall(sel, accessor.owner, syms.virtualAccess,
+                names.metafactory, static_args, (MethodType)indyType, args.prepend(sel.selected), accessor.name, accessor);
+        return methInv.setType(vk.asInvType.apply(sel.type));
+    }
+
+    /**
      * This is an helper class that defines some of the common capabilities of specialized symbols.
      * This class exists solely as a means to avoid code duplication.
      */
@@ -750,7 +986,7 @@
      * Invariant: the inoput symbol must be a member of a specialized class.
      */
     Symbol makeSpecializedSymbol(Symbol s) {
-        Assert.check((s.owner.flags() & Flags.SPECIALIZED_CLASS) != 0);
+        Assert.check((s.owner.flags() & (Flags.SPECIALIZED_CLASS | Flags.VIRTUAL)) != 0);
         return makeSpecializedSymbolInternal(s);
     }
     //where
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/TypeEnter.java	Wed Jul 08 15:14:54 2015 +0100
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/TypeEnter.java	Thu Jul 09 16:14:35 2015 +0100
@@ -794,7 +794,7 @@
             for (JCExpression iface : tree.implementing) {
                 Type it = iface.type;
                 if (it.hasTag(CLASS))
-                    chk.checkNotRepeated(iface.pos(), types.erasure(it), interfaceSet);
+                    chk.checkNotRepeated(iface.pos(), it.tsym.erasure(types), interfaceSet);
             }
 
             annotate.annotateLater(tree.mods.annotations, baseEnv,
@@ -887,6 +887,11 @@
 
             finishClass(tree, env);
 
+            // Now it is safe to add the virtual interface, as this class has already been fully completed
+            if (types.isAnyfied(sym)) {
+                ct.interfaces_field = ct.interfaces_field.append(types.virtualizeClass(sym).type);
+            }
+
             if (allowTypeAnnos) {
                 typeAnnotations.organizeTypeAnnotationsSignatures(env, (JCClassDecl)env.tree);
                 typeAnnotations.validateTypeAnnotationsSignatures(env, (JCClassDecl)env.tree);
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/jvm/Gen.java	Wed Jul 08 15:14:54 2015 +0100
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/jvm/Gen.java	Thu Jul 09 16:14:35 2015 +0100
@@ -2260,6 +2260,7 @@
         // For basic types, the coerce(...) in genExpr(...) will do
         // the conversion.
         if ((tree.unerasedType != null && types.needsMangling(tree.unerasedType)) || //do not skip cast to types containing avars
+                (tree.clazz.type.hasTag(CLASS) && types.isAnyfied(tree.clazz.type.tsym)) || //do not skip cast to raw anyfied
                 (!tree.clazz.type.isPrimitive() &&
                 !types.isSameType(tree.expr.type, tree.clazz.type) &&
                 types.asSuper(tree.expr.type, tree.clazz.type.tsym) == null)) {
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/parser/JavacParser.java	Wed Jul 08 15:14:54 2015 +0100
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/parser/JavacParser.java	Thu Jul 09 16:14:35 2015 +0100
@@ -35,6 +35,7 @@
 import com.sun.tools.javac.resources.CompilerProperties;
 import com.sun.tools.javac.tree.*;
 import com.sun.tools.javac.tree.JCTree.*;
+import com.sun.tools.javac.tree.JCTree.TypeBoundKind.Kind;
 import com.sun.tools.javac.util.*;
 import com.sun.tools.javac.util.JCDiagnostic.DiagnosticFlag;
 import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;
@@ -1878,36 +1879,43 @@
      */
     JCExpression typeArgument() {
         List<JCAnnotation> annotations = typeAnnotationsOpt();
-        if (token.kind != QUES) return parseType(annotations);
-        int pos = token.pos;
-        nextToken();
-        JCExpression result;
-        if (token.kind == EXTENDS) {
-            TypeBoundKind t = to(F.at(pos).TypeBoundKind(BoundKind.EXTENDS));
+        if (token.kind == QUES || token.kind == ANY) {
+            boolean isAny = token.kind == ANY;
+            int pos = token.pos;
             nextToken();
-            JCExpression bound = parseType();
-            result = F.at(pos).Wildcard(t, bound);
-        } else if (token.kind == SUPER) {
-            TypeBoundKind t = to(F.at(pos).TypeBoundKind(BoundKind.SUPER));
-            nextToken();
-            JCExpression bound = parseType();
-            result = F.at(pos).Wildcard(t, bound);
-        } else if (LAX_IDENTIFIER.accepts(token.kind)) {
-            //error recovery
-            TypeBoundKind t = F.at(Position.NOPOS).TypeBoundKind(BoundKind.UNBOUND);
-            JCExpression wc = toP(F.at(pos).Wildcard(t, null));
-            JCIdent id = toP(F.at(token.pos).Ident(ident()));
-            JCErroneous err = F.at(pos).Erroneous(List.<JCTree>of(wc, id));
-            reportSyntaxError(err, "expected3", GT, EXTENDS, SUPER);
-            result = err;
+            JCExpression result;
+            if (!isAny && token.kind == EXTENDS) {
+                TypeBoundKind t = to(F.at(pos).TypeBoundKind(Kind.EXTENDS));
+                nextToken();
+                JCExpression bound = parseType();
+                result = F.at(pos).Wildcard(t, bound);
+            } else if (!isAny && token.kind == SUPER) {
+                TypeBoundKind t = to(F.at(pos).TypeBoundKind(Kind.SUPER));
+                nextToken();
+                JCExpression bound = parseType();
+                result = F.at(pos).Wildcard(t, bound);
+            } else if (LAX_IDENTIFIER.accepts(token.kind)) {
+                //error recovery
+                TypeBoundKind t = F.at(Position.NOPOS).TypeBoundKind(Kind.UNBOUND_REF);
+                JCExpression wc = toP(F.at(pos).Wildcard(t, null));
+                JCIdent id = toP(F.at(token.pos).Ident(ident()));
+                JCErroneous err = F.at(pos).Erroneous(List.<JCTree>of(wc, id));
+                Object[] expected = isAny ?
+                        new Object[] { GT } :
+                        new Object[] { GT, EXTENDS, SUPER };
+                reportSyntaxError(err, "expected3", expected);
+                result = err;
+            } else {
+                TypeBoundKind t = toP(F.at(pos).TypeBoundKind(isAny ? Kind.UNBOUND_ANY : Kind.UNBOUND_REF));
+                result = toP(F.at(pos).Wildcard(t, null));
+            }
+            if (!annotations.isEmpty()) {
+                result = toP(F.at(annotations.head.pos).AnnotatedType(annotations, result));
+            }
+            return result;
         } else {
-            TypeBoundKind t = toP(F.at(pos).TypeBoundKind(BoundKind.UNBOUND));
-            result = toP(F.at(pos).Wildcard(t, null));
+            return parseType(annotations);
         }
-        if (!annotations.isEmpty()) {
-            result = toP(F.at(annotations.head.pos).AnnotatedType(annotations,result));
-        }
-        return result;
     }
 
     JCTypeApply typeArguments(JCExpression t, boolean diamondAllowed) {
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/resources/compiler.properties	Wed Jul 08 15:14:54 2015 +0100
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/resources/compiler.properties	Thu Jul 09 16:14:35 2015 +0100
@@ -303,6 +303,19 @@
 compiler.err.cant.select.static.class.from.param.type=\
     cannot select a static class from a parameterized type
 
+# 0: message segment
+compiler.err.cant.select.non.virtual=\
+    cannot select a member of a type containing anyfied wildcards\n\
+    ({0})
+
+# 0: symbol
+compiler.misc.virtual.non.public=\
+    member {0} is not public
+
+# 0: symbol
+compiler.misc.virtual.anyfied.arrays=\
+    type of member {0} contains anyfied arrays
+
 # 0: symbol, 1: string, 2: string
 compiler.err.cant.inherit.diff.arg=\
     {0} cannot be inherited with different arguments: <{1}> and <{2}>
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/tree/JCTree.java	Wed Jul 08 15:14:54 2015 +0100
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/tree/JCTree.java	Thu Jul 09 16:14:35 2015 +0100
@@ -2488,7 +2488,7 @@
 
         @DefinedBy(Api.COMPILER_TREE)
         public Kind getKind() {
-            switch (kind.kind) {
+            switch (kind.asBoundKind()) {
             case UNBOUND:
                 return Kind.UNBOUNDED_WILDCARD;
             case EXTENDS:
@@ -2512,15 +2512,62 @@
     }
 
     public static class TypeBoundKind extends JCTree {
-        public BoundKind kind;
-        protected TypeBoundKind(BoundKind kind) {
+
+        /**
+         * The bound kind (as seen in the source code). Note that the bouinds expressible in the sources
+         * are richer than the set of bounds expressible in the type-system (see {@link BoundKind}).
+         */
+        public enum Kind {
+            /** as in {@code Foo<? extends T>} */
+            EXTENDS(BoundKind.EXTENDS),
+            /** as in {@code Foo<? super T>} */
+            SUPER(BoundKind.SUPER),
+            /** as in {@code Foo<?>} */
+            UNBOUND_REF(BoundKind.UNBOUND),
+            /** as in {@code Foo<any>} */
+            UNBOUND_ANY(BoundKind.UNBOUND);
+
+            final BoundKind bk;
+
+            Kind(BoundKind bk) {
+                this.bk = bk;
+            }
+
+            @Override
+            public String toString() {
+                return this == UNBOUND_ANY ?
+                        "any" : bk.toString();
+            }
+
+            /**
+             * Map a type-system bound kind back into an AST bound kind. An extra flag is needed
+             * to map unbounded wildcards (which comes in two flavors in the AST).
+             */
+            public static Kind from(boolean isAny, BoundKind bk) {
+                switch (bk) {
+                    case EXTENDS:
+                        return Kind.EXTENDS;
+                    case SUPER:
+                        return Kind.SUPER;
+                    case UNBOUND:
+                        return isAny ? Kind.UNBOUND_ANY : Kind.UNBOUND_REF;
+                    default:
+                        Assert.error("Cannot get here!");
+                        return null;
+                }
+            }
+        }
+
+        public Kind kind;
+
+        protected TypeBoundKind(Kind kind) {
             this.kind = kind;
         }
         @Override
         public void accept(Visitor v) { v.visitTypeBoundKind(this); }
 
         @DefinedBy(Api.COMPILER_TREE)
-        public Kind getKind() {
+        public Tree.Kind getKind() {
             throw new AssertionError("TypeBoundKind is not part of a public API");
         }
         @Override @DefinedBy(Api.COMPILER_TREE)
@@ -2531,6 +2578,10 @@
         public Tag getTag() {
             return TYPEBOUNDKIND;
         }
+
+        public BoundKind asBoundKind() {
+            return kind.bk;
+        }
     }
 
     public static class JCAnnotation extends JCExpression implements AnnotationTree {
@@ -2767,7 +2818,7 @@
         JCTypeApply TypeApply(JCExpression clazz, List<JCExpression> arguments);
         JCTypeParameter TypeParameter(int flags, Name name, List<JCExpression> bounds);
         JCWildcard Wildcard(TypeBoundKind kind, JCTree type);
-        TypeBoundKind TypeBoundKind(BoundKind kind);
+        TypeBoundKind TypeBoundKind(TypeBoundKind.Kind kind);
         JCAnnotation Annotation(JCTree annotationType, List<JCExpression> args);
         JCModifiers Modifiers(long flags, List<JCAnnotation> annotations);
         JCErroneous Erroneous(List<? extends JCTree> errs);
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/tree/Pretty.java	Wed Jul 08 15:14:54 2015 +0100
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/tree/Pretty.java	Thu Jul 09 16:14:35 2015 +0100
@@ -1339,7 +1339,7 @@
     public void visitWildcard(JCWildcard tree) {
         try {
             print(tree.kind);
-            if (tree.kind.kind != BoundKind.UNBOUND)
+            if (tree.kind.asBoundKind() != BoundKind.UNBOUND)
                 printExpr(tree.inner);
         } catch (IOException e) {
             throw new UncheckedIOException(e);
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/tree/TreeMaker.java	Wed Jul 08 15:14:54 2015 +0100
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/tree/TreeMaker.java	Thu Jul 09 16:14:35 2015 +0100
@@ -32,6 +32,7 @@
 import com.sun.tools.javac.code.*;
 import com.sun.tools.javac.code.Symbol.*;
 import com.sun.tools.javac.code.Type.*;
+import com.sun.tools.javac.tree.JCTree.TypeBoundKind.Kind;
 import com.sun.tools.javac.util.*;
 import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;
 
@@ -518,7 +519,7 @@
         return tree;
     }
 
-    public TypeBoundKind TypeBoundKind(BoundKind kind) {
+    public TypeBoundKind TypeBoundKind(TypeBoundKind.Kind kind) {
         TypeBoundKind tree = new TypeBoundKind(kind);
         tree.pos = pos;
         return tree;
@@ -702,7 +703,8 @@
             break;
         case WILDCARD: {
             WildcardType a = ((WildcardType) t);
-            tp = Wildcard(TypeBoundKind(a.kind), Type(a.type));
+            boolean isAny = a.type.hasTag(ANY_BOUND);
+            tp = Wildcard(TypeBoundKind(Kind.from(isAny, a.kind)), isAny ? null : Type(a.type));
             break;
         }
         case CLASS:
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/diags/examples/CantSelectNonVirtual.java	Thu Jul 09 16:14:35 2015 +0100
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+// key: compiler.err.cant.select.non.virtual
+// key: compiler.misc.virtual.non.public
+// key: compiler.misc.virtual.anyfied.arrays
+
+class CantSelectNonVirtual {
+    static class Foo<any T> {
+        T t;
+        public T[] tarr;
+    }
+
+    void test(Foo<any> fa) {
+        Object o1 = fa.t;
+        Object o2 = fa.tarr;
+    }
+}
--- a/test/tools/javac/generics/bridges/BridgeHarness.java	Wed Jul 08 15:14:54 2015 +0100
+++ b/test/tools/javac/generics/bridges/BridgeHarness.java	Thu Jul 09 16:14:35 2015 +0100
@@ -153,7 +153,7 @@
             }
 
             for (Method m : cf.methods) {
-                if (m.access_flags.is(AccessFlags.ACC_SYNTHETIC | AccessFlags.ACC_BRIDGE)) {
+                if (m.access_flags.is(AccessFlags.ACC_SYNTHETIC) && m.access_flags.is(AccessFlags.ACC_BRIDGE)) {
                     //this is a bridge - see if there's a match in the bridge list
                     Bridge match = null;
                     for (Bridge b : bridgeList) {
@@ -163,7 +163,7 @@
                         }
                     }
                     if (match == null) {
-                        error("No annotation for bridge method: " + descriptor(m, cf.constant_pool));
+                        error("No annotation for bridge method: " + descriptor(m, cf.constant_pool) + " in " + cf.getName());
                     } else {
                         bridgeList = drop(bridgeList, match);
                     }
--- a/test/tools/javac/treeannotests/TestProcessor.java	Wed Jul 08 15:14:54 2015 +0100
+++ b/test/tools/javac/treeannotests/TestProcessor.java	Thu Jul 09 16:14:35 2015 +0100
@@ -294,7 +294,7 @@
 
         @Override
         public void visitWildcard(JCWildcard tree) {
-            if (tree.kind.kind == BoundKind.UNBOUND)
+            if (tree.kind.asBoundKind() == BoundKind.UNBOUND)
                 result = tree.kind.toString();
             else
                 result = tree.kind + " " + print(tree.inner);
--- a/test/tools/javac/valhalla/typespec/Cast01.java	Wed Jul 08 15:14:54 2015 +0100
+++ b/test/tools/javac/valhalla/typespec/Cast01.java	Thu Jul 09 16:14:35 2015 +0100
@@ -26,7 +26,7 @@
         Cast01<? extends Object> t1 = ti; //fail
         Cast01<? extends Object> t2 = (Cast01<? extends Object>)ti; //fail
         Cast01<? extends Object> t3 = this; //fail
-        Cast01<? extends Object> t4 = (Cast01<? extends Object>)this; //ok
+        Cast01<? extends Object> t4 = (Cast01<? extends Object>)this; //unchecked
         Cast01<? extends Object> t5 = (Cast01<? extends Number>)this; //unchecked
     }
 }
--- a/test/tools/javac/valhalla/typespec/Cast01.out	Wed Jul 08 15:14:54 2015 +0100
+++ b/test/tools/javac/valhalla/typespec/Cast01.out	Thu Jul 09 16:14:35 2015 +0100
@@ -9,6 +9,7 @@
 Cast01.java:26:39: compiler.err.prob.found.req: (compiler.misc.inconvertible.types: Cast01<int>, Cast01<? extends java.lang.Object>)
 Cast01.java:27:65: compiler.err.prob.found.req: (compiler.misc.inconvertible.types: Cast01<int>, Cast01<? extends java.lang.Object>)
 Cast01.java:28:39: compiler.err.prob.found.req: (compiler.misc.inconvertible.types: Cast01<T>, Cast01<? extends java.lang.Object>)
+Cast01.java:29:65: compiler.warn.prob.found.req: (compiler.misc.unchecked.cast.to.type), Cast01<T>, Cast01<? extends java.lang.Object>
 Cast01.java:30:65: compiler.warn.prob.found.req: (compiler.misc.unchecked.cast.to.type), Cast01<T>, Cast01<? extends java.lang.Number>
 7 errors
-5 warnings
+6 warnings
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/valhalla/typespec/Wildcards05.java	Thu Jul 09 16:14:35 2015 +0100
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/**
+ * @test
+ * @summary smoke test for partial anyfied wildcards
+ * @clean .*
+ * @compile Wildcards05.java
+ * @run main Wildcards05
+ */
+public class Wildcards05 {
+    static class TwoBox<any U, any V> {
+        public U fst;
+        public V snd;
+
+        TwoBox(U fst, V snd) {
+            this.fst = fst;
+            this.snd = snd;
+        }
+
+        public U fst() { return fst; }
+        public V snd() { return snd; }
+    }
+
+    static class Test<any X> {
+        X x;
+
+        Test(TwoBox<X, any> tb) {
+            this.x = tb.fst; //virtual getter
+            tb.fst = this.x; //virtual setter
+            this.x = tb.fst(); //virtual bridge
+
+            Object o = tb.snd; //virtual boxing getter
+            o = tb.snd(); //virtual boxing bridge
+        }
+    }
+
+    public static void main(String[] args) {
+        new Test<int>(new TwoBox<int, int>(1, 1));
+        new Test<String>(new TwoBox<String, int>("", 1));
+        new Test<int>(new TwoBox<int, String>(1, ""));
+        new Test<String>(new TwoBox<String, String>("", ""));
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/valhalla/typespec/Wildcards06.java	Thu Jul 09 16:14:35 2015 +0100
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/**
+ * @test
+ * @summary smoke test anyfied wildcards
+ * @clean .*
+ * @compile Wildcards06.java
+ * @run main Wildcards06
+ */
+public class Wildcards06 {
+    static class Foo<any X> {
+        public X x;
+
+        Foo(X x) {
+          this.x = x;
+        }
+    }
+
+    static void testAny(Foo<any> fa) {
+        Object o = fa.x;
+        fa.x = null;
+    }
+
+    static void testRef(Foo<?> fw) {
+        Object o = fw.x;
+        fw.x = null;
+    }
+
+    public static void main(String[] args) {
+        try {
+            testAny(new Foo<int>(1)); //NPE here!
+            throw new AssertionError("Expected boxing exception here!");
+        } catch (NullPointerException ex) {
+            //ok
+        }
+        testAny(new Foo<String>(""));
+        testRef(new Foo<String>(""));
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/valhalla/typespec/Wildcards07.java	Thu Jul 09 16:14:35 2015 +0100
@@ -0,0 +1,241 @@
+/*
+ * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/**
+ * @test
+ * @summary matrix test anyfied wildcards subtyping
+ * @compile/fail/ref=Wildcards07.out -Xmaxerrs 200 -XDrawDiagnostics Wildcards07.java
+ */
+class Wildcards07 {
+    static class TwoBox<any X, any Y> { }
+
+    void testrefref(TwoBox<String, String> tss) {
+        testrefref(tss);
+        testrefval(tss); //error
+        testvalref(tss); //error
+        testvalval(tss); //error
+        testrefany(tss);
+        testvalany(tss); //error
+        testanyref(tss);
+        testanyval(tss); //error
+        testrefwild(tss);
+        testvalwild(tss); //error
+        testwildref(tss);
+        testwildval(tss); //error
+        testraw(tss);
+    }
+
+    void testrefval(TwoBox<String, int> tsi) {
+        testrefref(tsi); //error
+        testrefval(tsi);
+        testvalref(tsi); //error
+        testvalval(tsi); //error
+        testrefany(tsi);
+        testvalany(tsi); //error
+        testanyref(tsi); //error
+        testanyval(tsi);
+        testrefwild(tsi); //error
+        testvalwild(tsi); //error
+        testwildref(tsi); //error
+        testwildval(tsi);
+        testraw(tsi); //error
+    }
+
+    void testvalref(TwoBox<int, String> tis) {
+        testrefref(tis); //error
+        testrefval(tis); //error
+        testvalref(tis);
+        testvalval(tis); //error
+        testrefany(tis); //error
+        testvalany(tis);
+        testanyref(tis);
+        testanyval(tis); //error
+        testrefwild(tis); //error
+        testvalwild(tis);
+        testwildref(tis); //error
+        testwildval(tis); //error
+        testraw(tis); //error
+    }
+
+    void testvalval(TwoBox<int, int> tii) {
+        testrefref(tii); //error
+        testrefval(tii); //error
+        testvalref(tii); //error
+        testvalval(tii);
+        testrefany(tii); //error
+        testvalany(tii);
+        testanyref(tii); //error
+        testanyval(tii);
+        testrefwild(tii); //error
+        testvalwild(tii); //error
+        testwildref(tii); //error
+        testwildval(tii); //error
+        testraw(tii); //error
+    }
+
+    void testrefany(TwoBox<String, any> tsa) {
+        testrefref(tsa); //error
+        testrefval(tsa); //error
+        testvalref(tsa); //error
+        testvalval(tsa); //error
+        testrefany(tsa);
+        testvalany(tsa); //error
+        testanyref(tsa); //error
+        testanyval(tsa); //error
+        testrefwild(tsa); //error
+        testvalwild(tsa); //error
+        testwildref(tsa); //error
+        testwildval(tsa); //error
+        testraw(tsa); //error
+    }
+
+    void testvalany(TwoBox<int, any> tia) {
+        testrefref(tia); //error
+        testrefval(tia); //error
+        testvalref(tia); //error
+        testvalval(tia); //error
+        testrefany(tia); //error
+        testvalany(tia);
+        testanyref(tia); //error
+        testanyval(tia); //error
+        testrefwild(tia); //error
+        testvalwild(tia); //error
+        testwildref(tia); //error
+        testwildval(tia); //error
+        testraw(tia); //error
+    }
+
+    void testanyref(TwoBox<any, String> tas) {
+        testrefref(tas); //error
+        testrefval(tas); //error
+        testvalref(tas); //error
+        testvalval(tas); //error
+        testrefany(tas); //error
+        testvalany(tas); //error
+        testanyref(tas);
+        testanyval(tas); //error
+        testrefwild(tas); //error
+        testvalwild(tas); //error
+        testwildref(tas); //error
+        testwildval(tas); //error
+        testraw(tas); //error
+    }
+
+    void testanyval(TwoBox<any, int> tai) {
+        testrefref(tai); //error
+        testrefval(tai); //error
+        testvalref(tai); //error
+        testvalval(tai); //error
+        testrefany(tai);  //error
+        testvalany(tai); //error
+        testanyref(tai); //error
+        testanyval(tai);
+        testrefwild(tai); //error
+        testvalwild(tai); //error
+        testwildref(tai); //error
+        testwildval(tai); //error
+        testraw(tai); //error
+    }
+
+    void testrefwild(TwoBox<String, ?> tsw) {
+        testrefref(tsw); //error
+        testrefval(tsw); //error
+        testvalref(tsw); //error
+        testvalval(tsw); //error
+        testrefany(tsw);
+        testvalany(tsw); //error
+        testanyref(tsw); //error
+        testanyval(tsw); //error
+        testrefwild(tsw);
+        testvalwild(tsw); //error
+        testwildref(tsw); //error
+        testwildval(tsw); //error
+        testraw(tsw);
+    }
+
+    void testvalwild(TwoBox<int, ?> tiw) {
+        testrefref(tiw); //error
+        testrefval(tiw); //error
+        testvalref(tiw); //error
+        testvalval(tiw); //error
+        testrefany(tiw); //error
+        testvalany(tiw);
+        testanyref(tiw); //error
+        testanyval(tiw); //error
+        testrefwild(tiw); //error
+        testvalwild(tiw);
+        testwildref(tiw); //error
+        testwildval(tiw); //error
+        testraw(tiw); //error
+    }
+
+    void testwildref(TwoBox<?, String> tws) {
+        testrefref(tws); //error
+        testrefval(tws); //error
+        testvalref(tws); //error
+        testvalval(tws); //error
+        testrefany(tws); //error
+        testvalany(tws); //error
+        testanyref(tws);
+        testanyval(tws); //error
+        testrefwild(tws); //error
+        testvalwild(tws); //error
+        testwildref(tws);
+        testwildval(tws); //error
+        testraw(tws);
+    }
+
+    void testwildval(TwoBox<?, int> twi) {
+        testrefref(twi); //error
+        testrefval(twi); //error
+        testvalref(twi); //error
+        testvalval(twi); //error
+        testrefany(twi); //error
+        testvalany(twi); //error
+        testanyref(twi); //error
+        testanyval(twi);
+        testrefwild(twi); //error
+        testvalwild(twi); //error
+        testwildref(twi); //error
+        testwildval(twi);
+        testraw(twi); //error
+    }
+
+    void testraw(TwoBox tr) {
+        testrefref(tr);
+        testrefval(tr); //error
+        testvalref(tr); //error
+        testvalval(tr); //error
+        testrefany(tr); //error
+        testvalany(tr); //error
+        testanyref(tr); //error
+        testanyval(tr); //error
+        testrefwild(tr);
+        testvalwild(tr); //error
+        testwildref(tr);
+        testwildval(tr); //error
+        testraw(tr);
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/valhalla/typespec/Wildcards07.out	Thu Jul 09 16:14:35 2015 +0100
@@ -0,0 +1,137 @@
+Wildcards07.java:36:9: compiler.err.cant.apply.symbol: kindname.method, testrefval, Wildcards07.TwoBox<java.lang.String,int>, Wildcards07.TwoBox<java.lang.String,java.lang.String>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<java.lang.String,java.lang.String>, Wildcards07.TwoBox<java.lang.String,int>))
+Wildcards07.java:37:9: compiler.err.cant.apply.symbol: kindname.method, testvalref, Wildcards07.TwoBox<int,java.lang.String>, Wildcards07.TwoBox<java.lang.String,java.lang.String>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<java.lang.String,java.lang.String>, Wildcards07.TwoBox<int,java.lang.String>))
+Wildcards07.java:38:9: compiler.err.cant.apply.symbol: kindname.method, testvalval, Wildcards07.TwoBox<int,int>, Wildcards07.TwoBox<java.lang.String,java.lang.String>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<java.lang.String,java.lang.String>, Wildcards07.TwoBox<int,int>))
+Wildcards07.java:40:9: compiler.err.cant.apply.symbol: kindname.method, testvalany, Wildcards07.TwoBox<int,?>, Wildcards07.TwoBox<java.lang.String,java.lang.String>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<java.lang.String,java.lang.String>, Wildcards07.TwoBox<int,?>))
+Wildcards07.java:42:9: compiler.err.cant.apply.symbol: kindname.method, testanyval, Wildcards07.TwoBox<?,int>, Wildcards07.TwoBox<java.lang.String,java.lang.String>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<java.lang.String,java.lang.String>, Wildcards07.TwoBox<?,int>))
+Wildcards07.java:44:9: compiler.err.cant.apply.symbol: kindname.method, testvalwild, Wildcards07.TwoBox<int,?>, Wildcards07.TwoBox<java.lang.String,java.lang.String>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<java.lang.String,java.lang.String>, Wildcards07.TwoBox<int,?>))
+Wildcards07.java:46:9: compiler.err.cant.apply.symbol: kindname.method, testwildval, Wildcards07.TwoBox<?,int>, Wildcards07.TwoBox<java.lang.String,java.lang.String>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<java.lang.String,java.lang.String>, Wildcards07.TwoBox<?,int>))
+Wildcards07.java:51:9: compiler.err.cant.apply.symbol: kindname.method, testrefref, Wildcards07.TwoBox<java.lang.String,java.lang.String>, Wildcards07.TwoBox<java.lang.String,int>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<java.lang.String,int>, Wildcards07.TwoBox<java.lang.String,java.lang.String>))
+Wildcards07.java:53:9: compiler.err.cant.apply.symbol: kindname.method, testvalref, Wildcards07.TwoBox<int,java.lang.String>, Wildcards07.TwoBox<java.lang.String,int>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<java.lang.String,int>, Wildcards07.TwoBox<int,java.lang.String>))
+Wildcards07.java:54:9: compiler.err.cant.apply.symbol: kindname.method, testvalval, Wildcards07.TwoBox<int,int>, Wildcards07.TwoBox<java.lang.String,int>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<java.lang.String,int>, Wildcards07.TwoBox<int,int>))
+Wildcards07.java:56:9: compiler.err.cant.apply.symbol: kindname.method, testvalany, Wildcards07.TwoBox<int,?>, Wildcards07.TwoBox<java.lang.String,int>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<java.lang.String,int>, Wildcards07.TwoBox<int,?>))
+Wildcards07.java:57:9: compiler.err.cant.apply.symbol: kindname.method, testanyref, Wildcards07.TwoBox<?,java.lang.String>, Wildcards07.TwoBox<java.lang.String,int>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<java.lang.String,int>, Wildcards07.TwoBox<?,java.lang.String>))
+Wildcards07.java:59:9: compiler.err.cant.apply.symbol: kindname.method, testrefwild, Wildcards07.TwoBox<java.lang.String,?>, Wildcards07.TwoBox<java.lang.String,int>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<java.lang.String,int>, Wildcards07.TwoBox<java.lang.String,?>))
+Wildcards07.java:60:9: compiler.err.cant.apply.symbol: kindname.method, testvalwild, Wildcards07.TwoBox<int,?>, Wildcards07.TwoBox<java.lang.String,int>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<java.lang.String,int>, Wildcards07.TwoBox<int,?>))
+Wildcards07.java:61:9: compiler.err.cant.apply.symbol: kindname.method, testwildref, Wildcards07.TwoBox<?,java.lang.String>, Wildcards07.TwoBox<java.lang.String,int>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<java.lang.String,int>, Wildcards07.TwoBox<?,java.lang.String>))
+Wildcards07.java:63:9: compiler.err.cant.apply.symbol: kindname.method, testraw, Wildcards07.TwoBox, Wildcards07.TwoBox<java.lang.String,int>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<java.lang.String,int>, Wildcards07.TwoBox))
+Wildcards07.java:67:9: compiler.err.cant.apply.symbol: kindname.method, testrefref, Wildcards07.TwoBox<java.lang.String,java.lang.String>, Wildcards07.TwoBox<int,java.lang.String>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<int,java.lang.String>, Wildcards07.TwoBox<java.lang.String,java.lang.String>))
+Wildcards07.java:68:9: compiler.err.cant.apply.symbol: kindname.method, testrefval, Wildcards07.TwoBox<java.lang.String,int>, Wildcards07.TwoBox<int,java.lang.String>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<int,java.lang.String>, Wildcards07.TwoBox<java.lang.String,int>))
+Wildcards07.java:70:9: compiler.err.cant.apply.symbol: kindname.method, testvalval, Wildcards07.TwoBox<int,int>, Wildcards07.TwoBox<int,java.lang.String>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<int,java.lang.String>, Wildcards07.TwoBox<int,int>))
+Wildcards07.java:71:9: compiler.err.cant.apply.symbol: kindname.method, testrefany, Wildcards07.TwoBox<java.lang.String,?>, Wildcards07.TwoBox<int,java.lang.String>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<int,java.lang.String>, Wildcards07.TwoBox<java.lang.String,?>))
+Wildcards07.java:74:9: compiler.err.cant.apply.symbol: kindname.method, testanyval, Wildcards07.TwoBox<?,int>, Wildcards07.TwoBox<int,java.lang.String>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<int,java.lang.String>, Wildcards07.TwoBox<?,int>))
+Wildcards07.java:75:9: compiler.err.cant.apply.symbol: kindname.method, testrefwild, Wildcards07.TwoBox<java.lang.String,?>, Wildcards07.TwoBox<int,java.lang.String>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<int,java.lang.String>, Wildcards07.TwoBox<java.lang.String,?>))
+Wildcards07.java:77:9: compiler.err.cant.apply.symbol: kindname.method, testwildref, Wildcards07.TwoBox<?,java.lang.String>, Wildcards07.TwoBox<int,java.lang.String>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<int,java.lang.String>, Wildcards07.TwoBox<?,java.lang.String>))
+Wildcards07.java:78:9: compiler.err.cant.apply.symbol: kindname.method, testwildval, Wildcards07.TwoBox<?,int>, Wildcards07.TwoBox<int,java.lang.String>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<int,java.lang.String>, Wildcards07.TwoBox<?,int>))
+Wildcards07.java:79:9: compiler.err.cant.apply.symbol: kindname.method, testraw, Wildcards07.TwoBox, Wildcards07.TwoBox<int,java.lang.String>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<int,java.lang.String>, Wildcards07.TwoBox))
+Wildcards07.java:83:9: compiler.err.cant.apply.symbol: kindname.method, testrefref, Wildcards07.TwoBox<java.lang.String,java.lang.String>, Wildcards07.TwoBox<int,int>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<int,int>, Wildcards07.TwoBox<java.lang.String,java.lang.String>))
+Wildcards07.java:84:9: compiler.err.cant.apply.symbol: kindname.method, testrefval, Wildcards07.TwoBox<java.lang.String,int>, Wildcards07.TwoBox<int,int>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<int,int>, Wildcards07.TwoBox<java.lang.String,int>))
+Wildcards07.java:85:9: compiler.err.cant.apply.symbol: kindname.method, testvalref, Wildcards07.TwoBox<int,java.lang.String>, Wildcards07.TwoBox<int,int>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<int,int>, Wildcards07.TwoBox<int,java.lang.String>))
+Wildcards07.java:87:9: compiler.err.cant.apply.symbol: kindname.method, testrefany, Wildcards07.TwoBox<java.lang.String,?>, Wildcards07.TwoBox<int,int>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<int,int>, Wildcards07.TwoBox<java.lang.String,?>))
+Wildcards07.java:89:9: compiler.err.cant.apply.symbol: kindname.method, testanyref, Wildcards07.TwoBox<?,java.lang.String>, Wildcards07.TwoBox<int,int>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<int,int>, Wildcards07.TwoBox<?,java.lang.String>))
+Wildcards07.java:91:9: compiler.err.cant.apply.symbol: kindname.method, testrefwild, Wildcards07.TwoBox<java.lang.String,?>, Wildcards07.TwoBox<int,int>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<int,int>, Wildcards07.TwoBox<java.lang.String,?>))
+Wildcards07.java:92:9: compiler.err.cant.apply.symbol: kindname.method, testvalwild, Wildcards07.TwoBox<int,?>, Wildcards07.TwoBox<int,int>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<int,int>, Wildcards07.TwoBox<int,?>))
+Wildcards07.java:93:9: compiler.err.cant.apply.symbol: kindname.method, testwildref, Wildcards07.TwoBox<?,java.lang.String>, Wildcards07.TwoBox<int,int>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<int,int>, Wildcards07.TwoBox<?,java.lang.String>))
+Wildcards07.java:94:9: compiler.err.cant.apply.symbol: kindname.method, testwildval, Wildcards07.TwoBox<?,int>, Wildcards07.TwoBox<int,int>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<int,int>, Wildcards07.TwoBox<?,int>))
+Wildcards07.java:95:9: compiler.err.cant.apply.symbol: kindname.method, testraw, Wildcards07.TwoBox, Wildcards07.TwoBox<int,int>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<int,int>, Wildcards07.TwoBox))
+Wildcards07.java:99:9: compiler.err.cant.apply.symbol: kindname.method, testrefref, Wildcards07.TwoBox<java.lang.String,java.lang.String>, Wildcards07.TwoBox<java.lang.String,compiler.misc.type.captureof: 1, ?>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<java.lang.String,compiler.misc.type.captureof: 1, ?>, Wildcards07.TwoBox<java.lang.String,java.lang.String>))
+Wildcards07.java:100:9: compiler.err.cant.apply.symbol: kindname.method, testrefval, Wildcards07.TwoBox<java.lang.String,int>, Wildcards07.TwoBox<java.lang.String,compiler.misc.type.captureof: 1, ?>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<java.lang.String,compiler.misc.type.captureof: 1, ?>, Wildcards07.TwoBox<java.lang.String,int>))
+Wildcards07.java:101:9: compiler.err.cant.apply.symbol: kindname.method, testvalref, Wildcards07.TwoBox<int,java.lang.String>, Wildcards07.TwoBox<java.lang.String,compiler.misc.type.captureof: 1, ?>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<java.lang.String,compiler.misc.type.captureof: 1, ?>, Wildcards07.TwoBox<int,java.lang.String>))
+Wildcards07.java:102:9: compiler.err.cant.apply.symbol: kindname.method, testvalval, Wildcards07.TwoBox<int,int>, Wildcards07.TwoBox<java.lang.String,compiler.misc.type.captureof: 1, ?>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<java.lang.String,compiler.misc.type.captureof: 1, ?>, Wildcards07.TwoBox<int,int>))
+Wildcards07.java:104:9: compiler.err.cant.apply.symbol: kindname.method, testvalany, Wildcards07.TwoBox<int,?>, Wildcards07.TwoBox<java.lang.String,compiler.misc.type.captureof: 1, ?>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<java.lang.String,compiler.misc.type.captureof: 1, ?>, Wildcards07.TwoBox<int,?>))
+Wildcards07.java:105:9: compiler.err.cant.apply.symbol: kindname.method, testanyref, Wildcards07.TwoBox<?,java.lang.String>, Wildcards07.TwoBox<java.lang.String,compiler.misc.type.captureof: 1, ?>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<java.lang.String,compiler.misc.type.captureof: 1, ?>, Wildcards07.TwoBox<?,java.lang.String>))
+Wildcards07.java:106:9: compiler.err.cant.apply.symbol: kindname.method, testanyval, Wildcards07.TwoBox<?,int>, Wildcards07.TwoBox<java.lang.String,compiler.misc.type.captureof: 1, ?>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<java.lang.String,compiler.misc.type.captureof: 1, ?>, Wildcards07.TwoBox<?,int>))
+Wildcards07.java:107:9: compiler.err.cant.apply.symbol: kindname.method, testrefwild, Wildcards07.TwoBox<java.lang.String,?>, Wildcards07.TwoBox<java.lang.String,compiler.misc.type.captureof: 1, ?>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<java.lang.String,compiler.misc.type.captureof: 1, ?>, Wildcards07.TwoBox<java.lang.String,?>))
+Wildcards07.java:108:9: compiler.err.cant.apply.symbol: kindname.method, testvalwild, Wildcards07.TwoBox<int,?>, Wildcards07.TwoBox<java.lang.String,compiler.misc.type.captureof: 1, ?>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<java.lang.String,compiler.misc.type.captureof: 1, ?>, Wildcards07.TwoBox<int,?>))
+Wildcards07.java:109:9: compiler.err.cant.apply.symbol: kindname.method, testwildref, Wildcards07.TwoBox<?,java.lang.String>, Wildcards07.TwoBox<java.lang.String,compiler.misc.type.captureof: 1, ?>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<java.lang.String,compiler.misc.type.captureof: 1, ?>, Wildcards07.TwoBox<?,java.lang.String>))
+Wildcards07.java:110:9: compiler.err.cant.apply.symbol: kindname.method, testwildval, Wildcards07.TwoBox<?,int>, Wildcards07.TwoBox<java.lang.String,compiler.misc.type.captureof: 1, ?>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<java.lang.String,compiler.misc.type.captureof: 1, ?>, Wildcards07.TwoBox<?,int>))
+Wildcards07.java:111:9: compiler.err.cant.apply.symbol: kindname.method, testraw, Wildcards07.TwoBox, Wildcards07.TwoBox<java.lang.String,compiler.misc.type.captureof: 1, ?>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<java.lang.String,compiler.misc.type.captureof: 1, ?>, Wildcards07.TwoBox))
+Wildcards07.java:115:9: compiler.err.cant.apply.symbol: kindname.method, testrefref, Wildcards07.TwoBox<java.lang.String,java.lang.String>, Wildcards07.TwoBox<int,compiler.misc.type.captureof: 1, ?>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<int,compiler.misc.type.captureof: 1, ?>, Wildcards07.TwoBox<java.lang.String,java.lang.String>))
+Wildcards07.java:116:9: compiler.err.cant.apply.symbol: kindname.method, testrefval, Wildcards07.TwoBox<java.lang.String,int>, Wildcards07.TwoBox<int,compiler.misc.type.captureof: 1, ?>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<int,compiler.misc.type.captureof: 1, ?>, Wildcards07.TwoBox<java.lang.String,int>))
+Wildcards07.java:117:9: compiler.err.cant.apply.symbol: kindname.method, testvalref, Wildcards07.TwoBox<int,java.lang.String>, Wildcards07.TwoBox<int,compiler.misc.type.captureof: 1, ?>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<int,compiler.misc.type.captureof: 1, ?>, Wildcards07.TwoBox<int,java.lang.String>))
+Wildcards07.java:118:9: compiler.err.cant.apply.symbol: kindname.method, testvalval, Wildcards07.TwoBox<int,int>, Wildcards07.TwoBox<int,compiler.misc.type.captureof: 1, ?>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<int,compiler.misc.type.captureof: 1, ?>, Wildcards07.TwoBox<int,int>))
+Wildcards07.java:119:9: compiler.err.cant.apply.symbol: kindname.method, testrefany, Wildcards07.TwoBox<java.lang.String,?>, Wildcards07.TwoBox<int,compiler.misc.type.captureof: 1, ?>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<int,compiler.misc.type.captureof: 1, ?>, Wildcards07.TwoBox<java.lang.String,?>))
+Wildcards07.java:121:9: compiler.err.cant.apply.symbol: kindname.method, testanyref, Wildcards07.TwoBox<?,java.lang.String>, Wildcards07.TwoBox<int,compiler.misc.type.captureof: 1, ?>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<int,compiler.misc.type.captureof: 1, ?>, Wildcards07.TwoBox<?,java.lang.String>))
+Wildcards07.java:122:9: compiler.err.cant.apply.symbol: kindname.method, testanyval, Wildcards07.TwoBox<?,int>, Wildcards07.TwoBox<int,compiler.misc.type.captureof: 1, ?>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<int,compiler.misc.type.captureof: 1, ?>, Wildcards07.TwoBox<?,int>))
+Wildcards07.java:123:9: compiler.err.cant.apply.symbol: kindname.method, testrefwild, Wildcards07.TwoBox<java.lang.String,?>, Wildcards07.TwoBox<int,compiler.misc.type.captureof: 1, ?>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<int,compiler.misc.type.captureof: 1, ?>, Wildcards07.TwoBox<java.lang.String,?>))
+Wildcards07.java:124:9: compiler.err.cant.apply.symbol: kindname.method, testvalwild, Wildcards07.TwoBox<int,?>, Wildcards07.TwoBox<int,compiler.misc.type.captureof: 1, ?>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<int,compiler.misc.type.captureof: 1, ?>, Wildcards07.TwoBox<int,?>))
+Wildcards07.java:125:9: compiler.err.cant.apply.symbol: kindname.method, testwildref, Wildcards07.TwoBox<?,java.lang.String>, Wildcards07.TwoBox<int,compiler.misc.type.captureof: 1, ?>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<int,compiler.misc.type.captureof: 1, ?>, Wildcards07.TwoBox<?,java.lang.String>))
+Wildcards07.java:126:9: compiler.err.cant.apply.symbol: kindname.method, testwildval, Wildcards07.TwoBox<?,int>, Wildcards07.TwoBox<int,compiler.misc.type.captureof: 1, ?>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<int,compiler.misc.type.captureof: 1, ?>, Wildcards07.TwoBox<?,int>))
+Wildcards07.java:127:9: compiler.err.cant.apply.symbol: kindname.method, testraw, Wildcards07.TwoBox, Wildcards07.TwoBox<int,compiler.misc.type.captureof: 1, ?>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<int,compiler.misc.type.captureof: 1, ?>, Wildcards07.TwoBox))
+Wildcards07.java:131:9: compiler.err.cant.apply.symbol: kindname.method, testrefref, Wildcards07.TwoBox<java.lang.String,java.lang.String>, Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,java.lang.String>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,java.lang.String>, Wildcards07.TwoBox<java.lang.String,java.lang.String>))
+Wildcards07.java:132:9: compiler.err.cant.apply.symbol: kindname.method, testrefval, Wildcards07.TwoBox<java.lang.String,int>, Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,java.lang.String>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,java.lang.String>, Wildcards07.TwoBox<java.lang.String,int>))
+Wildcards07.java:133:9: compiler.err.cant.apply.symbol: kindname.method, testvalref, Wildcards07.TwoBox<int,java.lang.String>, Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,java.lang.String>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,java.lang.String>, Wildcards07.TwoBox<int,java.lang.String>))
+Wildcards07.java:134:9: compiler.err.cant.apply.symbol: kindname.method, testvalval, Wildcards07.TwoBox<int,int>, Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,java.lang.String>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,java.lang.String>, Wildcards07.TwoBox<int,int>))
+Wildcards07.java:135:9: compiler.err.cant.apply.symbol: kindname.method, testrefany, Wildcards07.TwoBox<java.lang.String,?>, Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,java.lang.String>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,java.lang.String>, Wildcards07.TwoBox<java.lang.String,?>))
+Wildcards07.java:136:9: compiler.err.cant.apply.symbol: kindname.method, testvalany, Wildcards07.TwoBox<int,?>, Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,java.lang.String>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,java.lang.String>, Wildcards07.TwoBox<int,?>))
+Wildcards07.java:138:9: compiler.err.cant.apply.symbol: kindname.method, testanyval, Wildcards07.TwoBox<?,int>, Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,java.lang.String>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,java.lang.String>, Wildcards07.TwoBox<?,int>))
+Wildcards07.java:139:9: compiler.err.cant.apply.symbol: kindname.method, testrefwild, Wildcards07.TwoBox<java.lang.String,?>, Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,java.lang.String>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,java.lang.String>, Wildcards07.TwoBox<java.lang.String,?>))
+Wildcards07.java:140:9: compiler.err.cant.apply.symbol: kindname.method, testvalwild, Wildcards07.TwoBox<int,?>, Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,java.lang.String>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,java.lang.String>, Wildcards07.TwoBox<int,?>))
+Wildcards07.java:141:9: compiler.err.cant.apply.symbol: kindname.method, testwildref, Wildcards07.TwoBox<?,java.lang.String>, Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,java.lang.String>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,java.lang.String>, Wildcards07.TwoBox<?,java.lang.String>))
+Wildcards07.java:142:9: compiler.err.cant.apply.symbol: kindname.method, testwildval, Wildcards07.TwoBox<?,int>, Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,java.lang.String>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,java.lang.String>, Wildcards07.TwoBox<?,int>))
+Wildcards07.java:143:9: compiler.err.cant.apply.symbol: kindname.method, testraw, Wildcards07.TwoBox, Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,java.lang.String>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,java.lang.String>, Wildcards07.TwoBox))
+Wildcards07.java:147:9: compiler.err.cant.apply.symbol: kindname.method, testrefref, Wildcards07.TwoBox<java.lang.String,java.lang.String>, Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,int>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,int>, Wildcards07.TwoBox<java.lang.String,java.lang.String>))
+Wildcards07.java:148:9: compiler.err.cant.apply.symbol: kindname.method, testrefval, Wildcards07.TwoBox<java.lang.String,int>, Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,int>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,int>, Wildcards07.TwoBox<java.lang.String,int>))
+Wildcards07.java:149:9: compiler.err.cant.apply.symbol: kindname.method, testvalref, Wildcards07.TwoBox<int,java.lang.String>, Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,int>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,int>, Wildcards07.TwoBox<int,java.lang.String>))
+Wildcards07.java:150:9: compiler.err.cant.apply.symbol: kindname.method, testvalval, Wildcards07.TwoBox<int,int>, Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,int>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,int>, Wildcards07.TwoBox<int,int>))
+Wildcards07.java:151:9: compiler.err.cant.apply.symbol: kindname.method, testrefany, Wildcards07.TwoBox<java.lang.String,?>, Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,int>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,int>, Wildcards07.TwoBox<java.lang.String,?>))
+Wildcards07.java:152:9: compiler.err.cant.apply.symbol: kindname.method, testvalany, Wildcards07.TwoBox<int,?>, Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,int>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,int>, Wildcards07.TwoBox<int,?>))
+Wildcards07.java:153:9: compiler.err.cant.apply.symbol: kindname.method, testanyref, Wildcards07.TwoBox<?,java.lang.String>, Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,int>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,int>, Wildcards07.TwoBox<?,java.lang.String>))
+Wildcards07.java:155:9: compiler.err.cant.apply.symbol: kindname.method, testrefwild, Wildcards07.TwoBox<java.lang.String,?>, Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,int>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,int>, Wildcards07.TwoBox<java.lang.String,?>))
+Wildcards07.java:156:9: compiler.err.cant.apply.symbol: kindname.method, testvalwild, Wildcards07.TwoBox<int,?>, Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,int>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,int>, Wildcards07.TwoBox<int,?>))
+Wildcards07.java:157:9: compiler.err.cant.apply.symbol: kindname.method, testwildref, Wildcards07.TwoBox<?,java.lang.String>, Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,int>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,int>, Wildcards07.TwoBox<?,java.lang.String>))
+Wildcards07.java:158:9: compiler.err.cant.apply.symbol: kindname.method, testwildval, Wildcards07.TwoBox<?,int>, Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,int>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,int>, Wildcards07.TwoBox<?,int>))
+Wildcards07.java:159:9: compiler.err.cant.apply.symbol: kindname.method, testraw, Wildcards07.TwoBox, Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,int>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,int>, Wildcards07.TwoBox))
+Wildcards07.java:163:9: compiler.err.cant.apply.symbol: kindname.method, testrefref, Wildcards07.TwoBox<java.lang.String,java.lang.String>, Wildcards07.TwoBox<java.lang.String,compiler.misc.type.captureof: 1, ?>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<java.lang.String,compiler.misc.type.captureof: 1, ?>, Wildcards07.TwoBox<java.lang.String,java.lang.String>))
+Wildcards07.java:164:9: compiler.err.cant.apply.symbol: kindname.method, testrefval, Wildcards07.TwoBox<java.lang.String,int>, Wildcards07.TwoBox<java.lang.String,compiler.misc.type.captureof: 1, ?>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<java.lang.String,compiler.misc.type.captureof: 1, ?>, Wildcards07.TwoBox<java.lang.String,int>))
+Wildcards07.java:165:9: compiler.err.cant.apply.symbol: kindname.method, testvalref, Wildcards07.TwoBox<int,java.lang.String>, Wildcards07.TwoBox<java.lang.String,compiler.misc.type.captureof: 1, ?>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<java.lang.String,compiler.misc.type.captureof: 1, ?>, Wildcards07.TwoBox<int,java.lang.String>))
+Wildcards07.java:166:9: compiler.err.cant.apply.symbol: kindname.method, testvalval, Wildcards07.TwoBox<int,int>, Wildcards07.TwoBox<java.lang.String,compiler.misc.type.captureof: 1, ?>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<java.lang.String,compiler.misc.type.captureof: 1, ?>, Wildcards07.TwoBox<int,int>))
+Wildcards07.java:168:9: compiler.err.cant.apply.symbol: kindname.method, testvalany, Wildcards07.TwoBox<int,?>, Wildcards07.TwoBox<java.lang.String,compiler.misc.type.captureof: 1, ?>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<java.lang.String,compiler.misc.type.captureof: 1, ?>, Wildcards07.TwoBox<int,?>))
+Wildcards07.java:169:9: compiler.err.cant.apply.symbol: kindname.method, testanyref, Wildcards07.TwoBox<?,java.lang.String>, Wildcards07.TwoBox<java.lang.String,compiler.misc.type.captureof: 1, ?>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<java.lang.String,compiler.misc.type.captureof: 1, ?>, Wildcards07.TwoBox<?,java.lang.String>))
+Wildcards07.java:170:9: compiler.err.cant.apply.symbol: kindname.method, testanyval, Wildcards07.TwoBox<?,int>, Wildcards07.TwoBox<java.lang.String,compiler.misc.type.captureof: 1, ?>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<java.lang.String,compiler.misc.type.captureof: 1, ?>, Wildcards07.TwoBox<?,int>))
+Wildcards07.java:172:9: compiler.err.cant.apply.symbol: kindname.method, testvalwild, Wildcards07.TwoBox<int,?>, Wildcards07.TwoBox<java.lang.String,compiler.misc.type.captureof: 1, ?>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<java.lang.String,compiler.misc.type.captureof: 1, ?>, Wildcards07.TwoBox<int,?>))
+Wildcards07.java:173:9: compiler.err.cant.apply.symbol: kindname.method, testwildref, Wildcards07.TwoBox<?,java.lang.String>, Wildcards07.TwoBox<java.lang.String,compiler.misc.type.captureof: 1, ?>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<java.lang.String,compiler.misc.type.captureof: 1, ?>, Wildcards07.TwoBox<?,java.lang.String>))
+Wildcards07.java:174:9: compiler.err.cant.apply.symbol: kindname.method, testwildval, Wildcards07.TwoBox<?,int>, Wildcards07.TwoBox<java.lang.String,compiler.misc.type.captureof: 1, ?>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<java.lang.String,compiler.misc.type.captureof: 1, ?>, Wildcards07.TwoBox<?,int>))
+Wildcards07.java:179:9: compiler.err.cant.apply.symbol: kindname.method, testrefref, Wildcards07.TwoBox<java.lang.String,java.lang.String>, Wildcards07.TwoBox<int,compiler.misc.type.captureof: 1, ?>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<int,compiler.misc.type.captureof: 1, ?>, Wildcards07.TwoBox<java.lang.String,java.lang.String>))
+Wildcards07.java:180:9: compiler.err.cant.apply.symbol: kindname.method, testrefval, Wildcards07.TwoBox<java.lang.String,int>, Wildcards07.TwoBox<int,compiler.misc.type.captureof: 1, ?>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<int,compiler.misc.type.captureof: 1, ?>, Wildcards07.TwoBox<java.lang.String,int>))
+Wildcards07.java:181:9: compiler.err.cant.apply.symbol: kindname.method, testvalref, Wildcards07.TwoBox<int,java.lang.String>, Wildcards07.TwoBox<int,compiler.misc.type.captureof: 1, ?>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<int,compiler.misc.type.captureof: 1, ?>, Wildcards07.TwoBox<int,java.lang.String>))
+Wildcards07.java:182:9: compiler.err.cant.apply.symbol: kindname.method, testvalval, Wildcards07.TwoBox<int,int>, Wildcards07.TwoBox<int,compiler.misc.type.captureof: 1, ?>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<int,compiler.misc.type.captureof: 1, ?>, Wildcards07.TwoBox<int,int>))
+Wildcards07.java:183:9: compiler.err.cant.apply.symbol: kindname.method, testrefany, Wildcards07.TwoBox<java.lang.String,?>, Wildcards07.TwoBox<int,compiler.misc.type.captureof: 1, ?>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<int,compiler.misc.type.captureof: 1, ?>, Wildcards07.TwoBox<java.lang.String,?>))
+Wildcards07.java:185:9: compiler.err.cant.apply.symbol: kindname.method, testanyref, Wildcards07.TwoBox<?,java.lang.String>, Wildcards07.TwoBox<int,compiler.misc.type.captureof: 1, ?>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<int,compiler.misc.type.captureof: 1, ?>, Wildcards07.TwoBox<?,java.lang.String>))
+Wildcards07.java:186:9: compiler.err.cant.apply.symbol: kindname.method, testanyval, Wildcards07.TwoBox<?,int>, Wildcards07.TwoBox<int,compiler.misc.type.captureof: 1, ?>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<int,compiler.misc.type.captureof: 1, ?>, Wildcards07.TwoBox<?,int>))
+Wildcards07.java:187:9: compiler.err.cant.apply.symbol: kindname.method, testrefwild, Wildcards07.TwoBox<java.lang.String,?>, Wildcards07.TwoBox<int,compiler.misc.type.captureof: 1, ?>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<int,compiler.misc.type.captureof: 1, ?>, Wildcards07.TwoBox<java.lang.String,?>))
+Wildcards07.java:189:9: compiler.err.cant.apply.symbol: kindname.method, testwildref, Wildcards07.TwoBox<?,java.lang.String>, Wildcards07.TwoBox<int,compiler.misc.type.captureof: 1, ?>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<int,compiler.misc.type.captureof: 1, ?>, Wildcards07.TwoBox<?,java.lang.String>))
+Wildcards07.java:190:9: compiler.err.cant.apply.symbol: kindname.method, testwildval, Wildcards07.TwoBox<?,int>, Wildcards07.TwoBox<int,compiler.misc.type.captureof: 1, ?>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<int,compiler.misc.type.captureof: 1, ?>, Wildcards07.TwoBox<?,int>))
+Wildcards07.java:191:9: compiler.err.cant.apply.symbol: kindname.method, testraw, Wildcards07.TwoBox, Wildcards07.TwoBox<int,compiler.misc.type.captureof: 1, ?>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<int,compiler.misc.type.captureof: 1, ?>, Wildcards07.TwoBox))
+Wildcards07.java:195:9: compiler.err.cant.apply.symbol: kindname.method, testrefref, Wildcards07.TwoBox<java.lang.String,java.lang.String>, Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,java.lang.String>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,java.lang.String>, Wildcards07.TwoBox<java.lang.String,java.lang.String>))
+Wildcards07.java:196:9: compiler.err.cant.apply.symbol: kindname.method, testrefval, Wildcards07.TwoBox<java.lang.String,int>, Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,java.lang.String>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,java.lang.String>, Wildcards07.TwoBox<java.lang.String,int>))
+Wildcards07.java:197:9: compiler.err.cant.apply.symbol: kindname.method, testvalref, Wildcards07.TwoBox<int,java.lang.String>, Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,java.lang.String>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,java.lang.String>, Wildcards07.TwoBox<int,java.lang.String>))
+Wildcards07.java:198:9: compiler.err.cant.apply.symbol: kindname.method, testvalval, Wildcards07.TwoBox<int,int>, Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,java.lang.String>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,java.lang.String>, Wildcards07.TwoBox<int,int>))
+Wildcards07.java:199:9: compiler.err.cant.apply.symbol: kindname.method, testrefany, Wildcards07.TwoBox<java.lang.String,?>, Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,java.lang.String>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,java.lang.String>, Wildcards07.TwoBox<java.lang.String,?>))
+Wildcards07.java:200:9: compiler.err.cant.apply.symbol: kindname.method, testvalany, Wildcards07.TwoBox<int,?>, Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,java.lang.String>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,java.lang.String>, Wildcards07.TwoBox<int,?>))
+Wildcards07.java:202:9: compiler.err.cant.apply.symbol: kindname.method, testanyval, Wildcards07.TwoBox<?,int>, Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,java.lang.String>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,java.lang.String>, Wildcards07.TwoBox<?,int>))
+Wildcards07.java:203:9: compiler.err.cant.apply.symbol: kindname.method, testrefwild, Wildcards07.TwoBox<java.lang.String,?>, Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,java.lang.String>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,java.lang.String>, Wildcards07.TwoBox<java.lang.String,?>))
+Wildcards07.java:204:9: compiler.err.cant.apply.symbol: kindname.method, testvalwild, Wildcards07.TwoBox<int,?>, Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,java.lang.String>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,java.lang.String>, Wildcards07.TwoBox<int,?>))
+Wildcards07.java:206:9: compiler.err.cant.apply.symbol: kindname.method, testwildval, Wildcards07.TwoBox<?,int>, Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,java.lang.String>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,java.lang.String>, Wildcards07.TwoBox<?,int>))
+Wildcards07.java:211:9: compiler.err.cant.apply.symbol: kindname.method, testrefref, Wildcards07.TwoBox<java.lang.String,java.lang.String>, Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,int>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,int>, Wildcards07.TwoBox<java.lang.String,java.lang.String>))
+Wildcards07.java:212:9: compiler.err.cant.apply.symbol: kindname.method, testrefval, Wildcards07.TwoBox<java.lang.String,int>, Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,int>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,int>, Wildcards07.TwoBox<java.lang.String,int>))
+Wildcards07.java:213:9: compiler.err.cant.apply.symbol: kindname.method, testvalref, Wildcards07.TwoBox<int,java.lang.String>, Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,int>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,int>, Wildcards07.TwoBox<int,java.lang.String>))
+Wildcards07.java:214:9: compiler.err.cant.apply.symbol: kindname.method, testvalval, Wildcards07.TwoBox<int,int>, Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,int>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,int>, Wildcards07.TwoBox<int,int>))
+Wildcards07.java:215:9: compiler.err.cant.apply.symbol: kindname.method, testrefany, Wildcards07.TwoBox<java.lang.String,?>, Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,int>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,int>, Wildcards07.TwoBox<java.lang.String,?>))
+Wildcards07.java:216:9: compiler.err.cant.apply.symbol: kindname.method, testvalany, Wildcards07.TwoBox<int,?>, Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,int>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,int>, Wildcards07.TwoBox<int,?>))
+Wildcards07.java:217:9: compiler.err.cant.apply.symbol: kindname.method, testanyref, Wildcards07.TwoBox<?,java.lang.String>, Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,int>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,int>, Wildcards07.TwoBox<?,java.lang.String>))
+Wildcards07.java:219:9: compiler.err.cant.apply.symbol: kindname.method, testrefwild, Wildcards07.TwoBox<java.lang.String,?>, Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,int>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,int>, Wildcards07.TwoBox<java.lang.String,?>))
+Wildcards07.java:220:9: compiler.err.cant.apply.symbol: kindname.method, testvalwild, Wildcards07.TwoBox<int,?>, Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,int>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,int>, Wildcards07.TwoBox<int,?>))
+Wildcards07.java:221:9: compiler.err.cant.apply.symbol: kindname.method, testwildref, Wildcards07.TwoBox<?,java.lang.String>, Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,int>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,int>, Wildcards07.TwoBox<?,java.lang.String>))
+Wildcards07.java:223:9: compiler.err.cant.apply.symbol: kindname.method, testraw, Wildcards07.TwoBox, Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,int>, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox<compiler.misc.type.captureof: 1, ?,int>, Wildcards07.TwoBox))
+Wildcards07.java:228:9: compiler.err.cant.apply.symbol: kindname.method, testrefval, Wildcards07.TwoBox<java.lang.String,int>, Wildcards07.TwoBox, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox, Wildcards07.TwoBox<java.lang.String,int>))
+Wildcards07.java:229:9: compiler.err.cant.apply.symbol: kindname.method, testvalref, Wildcards07.TwoBox<int,java.lang.String>, Wildcards07.TwoBox, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox, Wildcards07.TwoBox<int,java.lang.String>))
+Wildcards07.java:230:9: compiler.err.cant.apply.symbol: kindname.method, testvalval, Wildcards07.TwoBox<int,int>, Wildcards07.TwoBox, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox, Wildcards07.TwoBox<int,int>))
+Wildcards07.java:231:9: compiler.err.cant.apply.symbol: kindname.method, testrefany, Wildcards07.TwoBox<java.lang.String,?>, Wildcards07.TwoBox, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox, Wildcards07.TwoBox<java.lang.String,?>))
+Wildcards07.java:232:9: compiler.err.cant.apply.symbol: kindname.method, testvalany, Wildcards07.TwoBox<int,?>, Wildcards07.TwoBox, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox, Wildcards07.TwoBox<int,?>))
+Wildcards07.java:233:9: compiler.err.cant.apply.symbol: kindname.method, testanyref, Wildcards07.TwoBox<?,java.lang.String>, Wildcards07.TwoBox, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox, Wildcards07.TwoBox<?,java.lang.String>))
+Wildcards07.java:234:9: compiler.err.cant.apply.symbol: kindname.method, testanyval, Wildcards07.TwoBox<?,int>, Wildcards07.TwoBox, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox, Wildcards07.TwoBox<?,int>))
+Wildcards07.java:236:9: compiler.err.cant.apply.symbol: kindname.method, testvalwild, Wildcards07.TwoBox<int,?>, Wildcards07.TwoBox, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox, Wildcards07.TwoBox<int,?>))
+Wildcards07.java:238:9: compiler.err.cant.apply.symbol: kindname.method, testwildval, Wildcards07.TwoBox<?,int>, Wildcards07.TwoBox, kindname.class, Wildcards07, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: Wildcards07.TwoBox, Wildcards07.TwoBox<?,int>))
+- compiler.note.unchecked.filename: Wildcards07.java
+- compiler.note.unchecked.recompile
+134 errors
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/valhalla/typespec/Wildcards08.java	Thu Jul 09 16:14:35 2015 +0100
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/**
+ * @test
+ * @summary check that compiler emits errors for unsupported anyfied wildcard access cases
+ * @compile/fail/ref=Wildcards08.out -XDrawDiagnostics Wildcards08.java
+ */
+class Wildcards08 {
+    static class Box<any X> {
+        X x;
+        public X[] xarr;
+
+        void m1(X x) { }
+        public void m2(X[] x) { }
+    }
+
+    void test(Box<any> ba) {
+        Object o1 = ba.x; //access of non-public members on anyfied wildcards not supported yet
+        Object o2 = ba.xarr; //array access on anyfied wildcards not supported yet
+        ba.m1(null); //access of non-public members on anyfied wildcards not supported yet
+        ba.m2(null); //access of members containing anyfied arrays on anyfied wildcards not supported yet
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/valhalla/typespec/Wildcards08.out	Thu Jul 09 16:14:35 2015 +0100
@@ -0,0 +1,5 @@
+Wildcards08.java:41:23: compiler.err.cant.select.non.virtual: (compiler.misc.virtual.non.public: x)
+Wildcards08.java:42:23: compiler.err.cant.select.non.virtual: (compiler.misc.virtual.anyfied.arrays: xarr)
+Wildcards08.java:43:11: compiler.err.cant.select.non.virtual: (compiler.misc.virtual.non.public: m1(X))
+Wildcards08.java:44:11: compiler.err.cant.select.non.virtual: (compiler.misc.virtual.anyfied.arrays: m2(X[]))
+4 errors
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/valhalla/typespec/Wildcards09.java	Thu Jul 09 16:14:35 2015 +0100
@@ -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.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/**
+ * @test
+ * @summary check that illegal wildcards combinations are rejected by the parser
+ * @compile/fail/ref=Wildcards09.out -XDrawDiagnostics Wildcards09.java
+ */
+class Wildcards09 {
+    void m1(Foo<any extends Bar> z) { }
+    void m2(Foo<any super Bar> z) { }
+    void m3(Foo<any ?> z) { }
+    void m4(Foo<? extends any> z) { } //parser says it's ok, 'any' is an Identifier, after all
+    void m5(Foo<? super any> z) { } //parser says it's ok, 'any' is an Identifier, after all
+    void m6(Foo<? any> z) { }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/valhalla/typespec/Wildcards09.out	Thu Jul 09 16:14:35 2015 +0100
@@ -0,0 +1,5 @@
+Wildcards09.java:32:21: compiler.err.expected: >
+Wildcards09.java:33:21: compiler.err.expected: >
+Wildcards09.java:34:21: compiler.err.expected: >
+Wildcards09.java:37:17: compiler.err.expected3: >, extends, super
+4 errors
--- a/test/tools/javac/valhalla/typespec/items/BytecodeMappingHarness.java	Wed Jul 08 15:14:54 2015 +0100
+++ b/test/tools/javac/valhalla/typespec/items/BytecodeMappingHarness.java	Thu Jul 09 16:14:35 2015 +0100
@@ -58,6 +58,7 @@
 import com.sun.source.util.TaskListener;
 import com.sun.source.util.TreeScanner;
 import com.sun.source.util.Trees;
+import com.sun.tools.classfile.AccessFlags;
 import com.sun.tools.classfile.Attribute;
 import com.sun.tools.classfile.BytecodeMapping_attribute;
 import com.sun.tools.classfile.ClassFile;
@@ -138,6 +139,9 @@
     void checkClassFile(File file)
             throws IOException, ConstantPoolException, InvalidDescriptor {
         ClassFile classFile = ClassFile.read(file);
+        if (classFile.getName().endsWith("$any")) {
+            return; //skip virtual interface
+        }
         ConstantPool constantPool = classFile.constant_pool;
         //lets get all the methods in the class file.
         for (Method method : classFile.methods) {
@@ -163,6 +167,11 @@
 
     void checkMethod(ConstantPool cp, Method method, LinkedList<BytecodeMapping> expectedMappings)
             throws ConstantPoolException, InvalidDescriptor {
+        String mname = method.getName(cp);
+        if (mname.endsWith("$get") || mname.endsWith("$set") || method.access_flags.is(AccessFlags.ACC_SYNTHETIC)) {
+            //skip virtualized accessors
+            return;
+        }
         Code_attribute code = (Code_attribute) method.attributes.get(Attribute.Code);
         BytecodeMapping_attribute bytecodeMapping =
             (BytecodeMapping_attribute) (method.attributes.get(Attribute.BytecodeMapping));