REPLCompletions: unswitch Union of same UnionAll results (#50483)

With this commit the inference-base REPL completion algorithm converts
`Union` result of same `UnionAll` instances to `UnionAll` of `Union`s
so that it can use the field information of the `UnionAll`.

This allows us to get completions for cases like:
```julia
julia> union_somes() = rand() < 0.5 ? Some(1) : Some(2.);

julia> union_somes().| # completes to `value`
```

base/compiler/typeutils.jl

@@ -318,21 +318,32 @@ function unionall_depth(@nospecialize ua) # aka subtype_env_size
 end
 
 # convert a Union of Tuple types to a Tuple of Unions
-function unswitchtupleunion(u::Union)
+unswitchtupleunion(u::Union) = unswitchtypeunion(u, Tuple.name)
+
+function unswitchtypeunion(u::Union, typename::Union{Nothing,Core.TypeName}=nothing)
     ts = uniontypes(u)
     n = -1
     for t in ts
-        if t isa DataType && t.name === Tuple.name && length(t.parameters) != 0 && !isvarargtype(t.parameters[end])
-            if n == -1
-                n = length(t.parameters)
-            elseif n != length(t.parameters)
+        if t isa DataType
+            if typename === nothing
+                typename = t.name
+            elseif typename !== t.name
                 return u
             end
+            if length(t.parameters) != 0 && !isvarargtype(t.parameters[end])
+                if n == -1
+                    n = length(t.parameters)
+                elseif n != length(t.parameters)
+                    return u
+                end
+            end
         else
             return u
         end
     end
-    Tuple{Any[ Union{Any[(t::DataType).parameters[i] for t in ts]...} for i in 1:n ]...}
+    Head = (typename::Core.TypeName).wrapper
+    unionparams = Any[ Union{Any[(t::DataType).parameters[i] for t in ts]...} for i in 1:n ]
+    return Head{unionparams...}
 end
 
 function unwraptv_ub(@nospecialize t)

stdlib/REPL/src/REPLCompletions.jl

@@ -580,6 +580,11 @@ function repl_eval_ex(@nospecialize(ex), context_module::Module)
 
     result = frame.result.result
     result === Union{} && return nothing # for whatever reason, callers expect this as the Bottom and/or Top type instead
+    if isa(result, Union)
+        # unswitch `Union` of same `UnionAll` instances to `UnionAll` of `Union`s
+        # so that we can use the field information of the `UnionAll`
+        return CC.unswitchtypeunion(result)
+    end
     return result
 end
 

stdlib/REPL/test/replcompletions.jl

@@ -1873,3 +1873,13 @@ let s = "`abc`.e"
     # (completions for the fields of `Cmd`)
     @test c == Any["env", "exec"]
 end
+
+# Test completion for a case when type inference returned `Union` of the same types
+function union_somes()
+    return rand() < 0.5 ? Some(1) : Some(2.)
+end
+let s = "union_somes()."
+    c, r, res = test_complete_context(s, @__MODULE__)
+    @test res
+    @test "value" in c
+end