From 684587d83e9a6e5cd6901d8e6ed174322935d3f7 Mon Sep 17 00:00:00 2001
From: Jeff Bezanson <jeff.bezanson@gmail.com>
Date: Tue, 16 Feb 2021 22:08:42 -0500
Subject: [PATCH] avoid excessive renaming in subtype of intersection result
 (#39623)

fixes #39505, fixes #39394

do fewer subtype checks in `jl_type_intersection2`

(cherry picked from commit 093b2a6ea943f4c70fef4742453e73dd1aba255c)
---
 src/gf.c        | 30 +++++++++++++-----------------
 src/subtype.c   | 22 +++++++++++++++++++---
 test/subtype.jl |  8 +++++++-
 3 files changed, 39 insertions(+), 21 deletions(-)

diff --git a/src/gf.c b/src/gf.c
index fe9d904f2c9d5..8861144e92e38 100644
--- a/src/gf.c
+++ b/src/gf.c
@@ -1586,26 +1586,22 @@ JL_DLLEXPORT void jl_method_table_disable(jl_methtable_t *mt, jl_method_t *metho
 static int jl_type_intersection2(jl_value_t *t1, jl_value_t *t2, jl_value_t **isect, jl_value_t **isect2)
 {
     *isect2 = NULL;
-    *isect = jl_type_intersection(t1, t2);
+    int is_subty = 0;
+    *isect = jl_type_intersection_env_s(t1, t2, NULL, &is_subty);
     if (*isect == jl_bottom_type)
         return 0;
+    if (is_subty)
+        return 1;
     // determine if type-intersection can be convinced to give a better, non-bad answer
-    if (!(jl_subtype(*isect, t1) && jl_subtype(*isect, t2))) {
-        // if the intersection was imprecise, see if we can do
-        // better by switching the types
-        *isect2 = jl_type_intersection(t2, t1);
-        if (*isect2 == jl_bottom_type) {
-            *isect = jl_bottom_type;
-            *isect2 = NULL;
-            return 0;
-        }
-        if (jl_subtype(*isect2, t1) && jl_subtype(*isect2, t2)) {
-            *isect = *isect2;
-            *isect2 = NULL;
-        }
-        else if (jl_types_equal(*isect2, *isect)) {
-            *isect2 = NULL;
-        }
+    // if the intersection was imprecise, see if we can do better by switching the types
+    *isect2 = jl_type_intersection(t2, t1);
+    if (*isect2 == jl_bottom_type) {
+        *isect = jl_bottom_type;
+        *isect2 = NULL;
+        return 0;
+    }
+    if (jl_types_egal(*isect2, *isect)) {
+        *isect2 = NULL;
     }
     return 1;
 }
diff --git a/src/subtype.c b/src/subtype.c
index 9869b2c993886..76fcab4c0a301 100644
--- a/src/subtype.c
+++ b/src/subtype.c
@@ -2431,7 +2431,9 @@ static jl_value_t *finish_unionall(jl_value_t *res JL_MAYBE_UNROOTED, jl_varbind
         }
     }
 
-    if (!varval && (vb->lb != vb->var->lb || vb->ub != vb->var->ub))
+    // prefer generating a fresh typevar, to avoid repeated renaming if the result
+    // is compared to one of the intersected types later.
+    if (!varval)
         newvar = jl_new_typevar(vb->var->name, vb->lb, vb->ub);
 
     // remove/replace/rewrap free occurrences of this var in the environment
@@ -3268,11 +3270,25 @@ jl_svec_t *jl_outer_unionall_vars(jl_value_t *u)
 static jl_value_t *switch_union_tuple(jl_value_t *a, jl_value_t *b)
 {
     if (jl_is_unionall(a)) {
-        jl_value_t *ans = switch_union_tuple(((jl_unionall_t*)a)->body, b);
+        jl_unionall_t *ua = (jl_unionall_t*)a;
+        if (jl_is_unionall(b)) {
+            jl_unionall_t *ub = (jl_unionall_t*)b;
+            if (ub->var->lb == ua->var->lb && ub->var->ub == ua->var->ub) {
+                jl_value_t *ub2 = jl_instantiate_unionall(ub, (jl_value_t*)ua->var);
+                jl_value_t *ans = NULL;
+                JL_GC_PUSH2(&ub2, &ans);
+                ans = switch_union_tuple(ua->body, ub2);
+                if (ans != NULL)
+                    ans = jl_type_unionall(ua->var, ans);
+                JL_GC_POP();
+                return ans;
+            }
+        }
+        jl_value_t *ans = switch_union_tuple(ua->body, b);
         if (ans == NULL)
             return NULL;
         JL_GC_PUSH1(&ans);
-        ans = jl_type_unionall(((jl_unionall_t*)a)->var, ans);
+        ans = jl_type_unionall(ua->var, ans);
         JL_GC_POP();
         return ans;
     }
diff --git a/test/subtype.jl b/test/subtype.jl
index 4b4cd750bdc80..57d49bc13fa8c 100644
--- a/test/subtype.jl
+++ b/test/subtype.jl
@@ -1057,12 +1057,18 @@ function test_intersection()
 end
 
 function test_intersection_properties()
+    approx = Tuple{Vector{Vector{T}} where T, Vector{Vector{T}} where T}
     for T in menagerie
         for S in menagerie
             I = _type_intersect(T,S)
             I2 = _type_intersect(S,T)
             @test isequal_type(I, I2)
-            @test issub(I, T) && issub(I, S)
+            if I == approx
+                # TODO: some of these cases give a conservative answer
+                @test issub(I, T) || issub(I, S)
+            else
+                @test issub(I, T) && issub(I, S)
+            end
             if issub(T, S)
                 @test isequal_type(I, T)
             end