inference: improve tmerge for Conditional and Const

Author: vtjnash

base/compiler/typeinfer.jl

@@ -319,11 +319,14 @@ function typeinf_work(frame::InferenceState)
                     else
                         # general case
                         frame.handler_at[l] = frame.cur_hand
+                        changes_else = changes
                         if isa(condt, Conditional)
-                            changes_else = StateUpdate(condt.var, VarState(condt.elsetype, false), changes)
-                            changes = StateUpdate(condt.var, VarState(condt.vtype, false), changes)
-                        else
-                            changes_else = changes
+                            if condt.elsetype !== Any && condt.elsetype !== changes[slot_id(condt.var)]
+                                changes_else = StateUpdate(condt.var, VarState(condt.elsetype, false), changes_else)
+                            end
+                            if condt.vtype !== Any && condt.vtype !== changes[slot_id(condt.var)]
+                                changes = StateUpdate(condt.var, VarState(condt.vtype, false), changes)
+                            end
                         end
                         newstate_else = stupdate!(s[l], changes_else)
                         if newstate_else !== false

base/compiler/typelimits.jl

@@ -302,14 +302,34 @@ function type_more_complex(@nospecialize(t), @nospecialize(c), sources::SimpleVe
     return true
 end
 
+# pick a wider type that contains both typea and typeb,
+# with some limits on how "large" it can get,
+# but without losing too much precision in common cases
+# and also trying to be associative and commutative
 function tmerge(@nospecialize(typea), @nospecialize(typeb))
     typea ⊑ typeb && return typeb
     typeb ⊑ typea && return typea
+    # type-lattice for MaybeUndef wrapper
     if isa(typea, MaybeUndef) || isa(typeb, MaybeUndef)
         return MaybeUndef(tmerge(
             isa(typea, MaybeUndef) ? typea.typ : typea,
             isa(typeb, MaybeUndef) ? typeb.typ : typeb))
     end
+    # type-lattice for Conditional wrapper
+    if isa(typea, Conditional) && isa(typeb, Const)
+        if typeb.val === true
+            typeb = Conditional(typea.var, Any, Union{})
+        elseif typeb.val === false
+            typeb = Conditional(typea.var, Union{}, Any)
+        end
+    end
+    if isa(typeb, Conditional) && isa(typea, Const)
+        if typea.val === true
+            typea = Conditional(typeb.var, Any, Union{})
+        elseif typea.val === false
+            typea = Conditional(typeb.var, Union{}, Any)
+        end
+    end
     if isa(typea, Conditional) && isa(typeb, Conditional)
         if typea.var === typeb.var
             vtype = tmerge(typea.vtype, typeb.vtype)
@@ -320,6 +340,7 @@ function tmerge(@nospecialize(typea), @nospecialize(typeb))
         end
         return Bool
     end
+    # no special type-inference lattice, join the types
     typea, typeb = widenconst(typea), widenconst(typeb)
     typea === typeb && return typea
     if !(isa(typea, Type) || isa(typea, TypeVar)) ||