changeset 50218:0df902a00215

8196048: thrown type variables should be roots in the minimum inference graph Reviewed-by: mcimadamore
author vromero
date Tue, 22 May 2018 09:01:44 -0700
parents 843fc56f4686
children 4ab066d71956
files src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Infer.java test/langtools/tools/javac/T8196048/ThrownTypeVarsAsRootsTest.java
diffstat 2 files changed, 74 insertions(+), 4 deletions(-) [+]
line wrap: on
line diff
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Infer.java	Fri May 18 09:15:08 2018 -0700
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Infer.java	Tue May 22 09:01:44 2018 -0700
@@ -260,16 +260,21 @@
         }
 
         private List<Type> roots(MethodType mt, DeferredAttrContext deferredAttrContext) {
-            ListBuffer<Type> roots = new ListBuffer<>();
-            roots.add(mt.getReturnType());
             if (deferredAttrContext != null && deferredAttrContext.mode == AttrMode.CHECK) {
-                roots.addAll(mt.getThrownTypes());
+                ListBuffer<Type> roots = new ListBuffer<>();
+                roots.add(mt.getReturnType());
                 for (DeferredAttr.DeferredAttrNode n : deferredAttrContext.deferredAttrNodes) {
                     roots.addAll(n.deferredStuckPolicy.stuckVars());
                     roots.addAll(n.deferredStuckPolicy.depVars());
                 }
+                List<Type> thrownVars = deferredAttrContext.inferenceContext.inferencevars.stream()
+                                .filter(tv -> (tv.tsym.flags() & Flags.THROWS) != 0).collect(List.collector());
+                List<Type> result = roots.toList();
+                result = result.appendList(thrownVars.diff(result));
+                return result;
+            } else {
+                return List.of(mt.getReturnType());
             }
-            return roots.toList();
         }
 
     /**
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/langtools/tools/javac/T8196048/ThrownTypeVarsAsRootsTest.java	Tue May 22 09:01:44 2018 -0700
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2018, 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 8196048
+ * @summary thrown type variables should be roots in the minimum inference graph
+ * @compile ThrownTypeVarsAsRootsTest.java
+ */
+
+import java.io.UnsupportedEncodingException;
+import java.net.BindException;
+import java.util.function.Function;
+import java.util.Optional;
+import java.util.function.BiFunction;
+
+class ThrownTypeVarsAsRootsTest {
+    void foo() {
+        try {
+            BiFunction<String, String, Optional<String>> function = rethrowBiFunction((x, y) -> {
+                    return Optional.of(x).map(rethrowFunction(z -> createZ(z)));
+            });
+        } catch (Exception ex) {}
+    }
+
+    public static String createZ(String x) throws UnsupportedEncodingException, BindException {
+        return null;
+    }
+
+    public static <T, R, E extends Exception> Function<T, R> rethrowFunction(ThrowingFunction<T, R, E> function) throws E {
+        return null;
+    }
+
+    public static <T, U, R, E extends Exception> BiFunction<T, U, R> rethrowBiFunction(
+            ThrowingBiFunction<T, U, R, E> function) throws E {
+        return null;
+    }
+
+    public interface ThrowingBiFunction<T, U, R, E extends Exception> {
+        R apply(T t, U u) throws E;
+    }
+
+    public interface ThrowingFunction<T, R, E extends Exception> {
+        R apply(T t) throws E;
+    }
+}