changeset 3344:e5d0d7510671

8042656: Inference produces spurious error for intersection type bounds check Summary: Fix subtyping for intersections involving capture variables Reviewed-by: vromero
author dlsmith
date Fri, 09 May 2014 14:56:59 -0600
parents 1472e30d4a7b
children 7e5918873ba1
files src/share/classes/com/sun/tools/javac/code/Types.java test/tools/javac/generics/typevars/IntersectionSubVar.java
diffstat 2 files changed, 63 insertions(+), 14 deletions(-) [+]
line wrap: on
line diff
--- a/src/share/classes/com/sun/tools/javac/code/Types.java	Fri May 09 09:28:47 2014 -0400
+++ b/src/share/classes/com/sun/tools/javac/code/Types.java	Fri May 09 14:56:59 2014 -0600
@@ -821,8 +821,9 @@
         }
 
         // Generally, if 's' is a type variable, recur on lower bound; but
-        // for alpha <: CAP, alpha should get upper bound CAP
-        if (!t.hasTag(UNDETVAR)) {
+        // for inference variables and intersections, we need to keep 's'
+        // (see JLS 4.10.2 for intersections and 18.2.3 for inference vars)
+        if (!t.hasTag(UNDETVAR) && !t.isCompound()) {
             // TODO: JDK-8039198, bounds checking sometimes passes in a wildcard as s
             Type lower = cvarLowerBound(wildLowerBound(s));
             if (s != lower)
@@ -913,14 +914,11 @@
             @Override
             public Boolean visitClassType(ClassType t, Type s) {
                 Type sup = asSuper(t, s.tsym);
-                return sup != null
-                    && sup.tsym == s.tsym
-                    // You're not allowed to write
-                    //     Vector<Object> vec = new Vector<String>();
-                    // But with wildcards you can write
-                    //     Vector<? extends Object> vec = new Vector<String>();
-                    // which means that subtype checking must be done
-                    // here instead of same-type checking (via containsType).
+                if (sup == null) 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
+                     // Check type variable containment
                     && (!s.isParameterized() || containsTypeRecursive(s, sup))
                     && isSubtypeNoCapture(sup.getEnclosingType(),
                                           s.getEnclosingType());
@@ -1970,16 +1968,18 @@
                     return t;
 
                 Type st = supertype(t);
-                if (st.hasTag(CLASS) || st.hasTag(TYPEVAR) || st.hasTag(ERROR)) {
+                if (st.hasTag(CLASS) || st.hasTag(TYPEVAR)) {
                     Type x = asSuper(st, sym);
                     if (x != null)
                         return x;
                 }
                 if ((sym.flags() & INTERFACE) != 0) {
                     for (List<Type> l = interfaces(t); l.nonEmpty(); l = l.tail) {
-                        Type x = asSuper(l.head, sym);
-                        if (x != null)
-                            return x;
+                        if (!l.head.hasTag(ERROR)) {
+                            Type x = asSuper(l.head, sym);
+                            if (x != null)
+                                return x;
+                        }
                     }
                 }
                 return null;
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/generics/typevars/IntersectionSubVar.java	Fri May 09 14:56:59 2014 -0600
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test
+ * @bug 8042656
+ * @summary Subtyping for intersection types containing type variables
+ * @compile IntersectionSubVar.java
+ */
+
+class IntersectionSubVar {
+
+    interface Box<T> {
+        void set(T arg);
+        T get();
+    }
+
+    <I> Box<I> glb(Box<? super I> arg1, Box<? super I> arg2) {
+        return null;
+    }
+
+    <E extends Cloneable> void takeBox(Box<? super E> box) {}
+
+    <T> void test(Box<T> arg1, Box<Cloneable> arg2, Box<? super T> arg3) {
+        T t = glb(arg1, arg2).get(); // assign T&Cloneable to T
+        takeBox(arg3); // inference tests Box<CAP> <: Box<? super CAP&Cloneable>
+    }
+
+}