8295020: javac emits incorrect code for for-each on an intersection type.

Reviewed-by: mcimadamore

Author: Srikanth Adayapalam

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

@@ -95,6 +95,7 @@ public static Lower instance(Context context) {
     private final TypeEnvs typeEnvs;
     private final Name dollarAssertionsDisabled;
     private final Types types;
+    private final TransTypes transTypes;
     private final boolean debugLower;
     private final boolean disableProtectedAccessors; // experimental
     private final PkgInfo pkginfoOpt;
@@ -117,6 +118,7 @@ protected Lower(Context context) {
             fromString(target.syntheticNameChar() + "assertionsDisabled");
 
         types = Types.instance(context);
+        transTypes = TransTypes.instance(context);
         Options options = Options.instance(context);
         debugLower = options.isSet("debuglower");
         pkginfoOpt = PkgInfo.get(options);
@@ -3518,16 +3520,15 @@ private void visitIterableForeachLoop(JCEnhancedForLoop tree) {
                                               syms.iterableType.tsym);
             if (iterableType.getTypeArguments().nonEmpty())
                 iteratorTarget = types.erasure(iterableType.getTypeArguments().head);
-            Type eType = types.skipTypeVars(tree.expr.type, false);
-            tree.expr.type = types.erasure(eType);
-            if (eType.isCompound())
-                tree.expr = make.TypeCast(types.erasure(iterableType), tree.expr);
+            tree.expr.type = types.erasure(types.skipTypeVars(tree.expr.type, false));
+            tree.expr = transTypes.coerce(attrEnv, tree.expr, types.erasure(iterableType));
             Symbol iterator = lookupMethod(tree.expr.pos(),
                                            names.iterator,
-                                           eType,
+                                           tree.expr.type,
                                            List.nil());
+            Assert.check(types.isSameType(types.erasure(types.asSuper(iterator.type.getReturnType(), syms.iteratorType.tsym)), types.erasure(syms.iteratorType)));
             VarSymbol itvar = new VarSymbol(SYNTHETIC, names.fromString("i" + target.syntheticNameChar()),
-                                            types.erasure(types.asSuper(iterator.type.getReturnType(), syms.iteratorType.tsym)),
+                                            types.erasure(syms.iteratorType),
                                             currentMethodSym);
 
              JCStatement init = make.

test/langtools/tools/javac/foreach/CovariantIntersectIterator.java

@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) 2022, 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 8295020
+ * @summary javac emits incorrect code for for-each on an intersection type.
+ * @run main CovariantIntersectIterator
+ */
+
+import java.io.Serializable;
+import java.util.Iterator;
+
+public class CovariantIntersectIterator {
+
+    public static void main(String... args) {
+        int npeCount = 0;
+        try {
+            // JCEnhancedForLoop.expr's erased type is ALREADY an Iterable
+            // iterator() comes from expr's erased type (MyIterable) and
+            // is called using invokevirtual & returns a covariant type (MyIterable.MyIterator)
+            for (Object s : (MyIterable & Serializable) null) {}
+        } catch (NullPointerException e) {
+            npeCount++;
+        }
+        try {
+            // JCEnhancedForLoop.expr's erased type is NOT an Iterable
+            // iterator() comes from Iterable (expr's erased type casted),
+            // will be called by invokeinterface and return Iterator
+            for (Object s : (MyIterableBase & Iterable<Object>) null) {}
+        } catch (NullPointerException e) {
+            npeCount++;
+        }
+        if (npeCount != 2) {
+            throw new AssertionError("Expected NPE missing");
+        }
+    }
+
+    abstract static class MyIterableBase {
+        public abstract MyIterable.MyIterator iterator();
+    }
+
+    static class MyIterable extends MyIterableBase implements Iterable<Object> {
+
+        class MyIterator implements Iterator<Object> {
+
+            public boolean hasNext() {
+                return false;
+            }
+
+            public Object next() {
+                return null;
+            }
+
+            public void remove() {}
+        }
+
+        public MyIterator iterator() {
+            return new MyIterator();
+        }
+    }
+}