Rename dispatchtuple to indivisible_type

This is hopefully a more intuitive (type-semantic) notion of what a
"dispatch tuple" is.

Ideally, it makes two key properties more obvious:
  1. indivisible types are either type-equal or disjoint with each other
     (T == U or T != U) - they are never partially overlapping
  2. these signatures are always compilable since they are "maximally specific"

This new definition should be mostly equivalent to the existing one for
Tuples, and it extends the predicate to be be analogously defined over
other DataTypes (e.g. `Int` / `Vector{Any}`, which are also indivisible)

Author: topolarity

Compiler/src/abstractinterpretation.jl

@@ -129,7 +129,7 @@ function abstract_call_gf_by_type(interp::AbstractInterpreter, @nospecialize(fun
         local napplicable = length(applicable)
         for i = 1:napplicable
             local sig = applicable[i].match.spec_types
-            if !isdispatchtuple(sig)
+            if !isindivisibletype(sig)
                 # only infer fully concrete call sites in top-level expressions (ignoring even isa_compileable_sig matches)
                 add_remark!(interp, sv, "Refusing to infer non-concrete call site in top-level expression")
                 return Future(CallMeta(Any, Any, Effects(), NoCallInfo()))

Compiler/src/ssair/inlining.jl

@@ -1394,8 +1394,8 @@ function compute_inlining_cases(@nospecialize(info::CallInfo), flag::UInt32, sig
             # We will emit an inline MethodError in this case, but that info already came inference, so we must already have the uncovered edge for it
         end
     elseif !isempty(cases)
-        # if we've not seen all candidates, union split is valid only for dispatch tuples
-        filter!(case::InliningCase->isdispatchtuple(case.sig), cases)
+        # if we've not seen all candidates, union split is valid only for indivisible (dispatch) tuples
+        filter!(case::InliningCase->isindivisibletype(case.sig), cases)
     end
     return cases, handled_all_cases, fully_covered, joint_effects
 end

Compiler/src/typeinfer.jl

@@ -361,7 +361,7 @@ function inline_cost_model(interp::AbstractInterpreter, result::InferenceResult,
         return MAX_INLINE_COST
     end
 
-    if declared_inline && isdispatchtuple(specTypes)
+    if declared_inline && isindivisibletype(specTypes)
         # obey @inline declaration if a dispatch barrier would not help
         return MIN_INLINE_COST
     else

Compiler/test/inline.jl

@@ -816,27 +816,27 @@ let src = code_typed((Union{Tuple{Int,Int,Int}, Vector{Int}},)) do xs
     @test count(isinvoke(:g42840), src.code) == 1
 end
 
-# test single, non-dispatchtuple callsite inlining
+# test single, divisible (non-dispatchtuple) callsite inlining
 
-@constprop :none @inline test_single_nondispatchtuple(@nospecialize(t)) =
+@constprop :none @inline test_single_divisible_type(@nospecialize(t)) =
     isa(t, DataType) && t.name === Type.body.name
 let
     src = code_typed1((Any,)) do x
-        test_single_nondispatchtuple(x)
+        test_single_divisible_type(x)
     end
     @test all(src.code) do @nospecialize x
-        !(isinvoke(:test_single_nondispatchtuple, x) || iscall((src, test_single_nondispatchtuple), x))
+        !(isinvoke(:test_single_divisible_type, x) || iscall((src, test_single_divisible_type), x))
     end
 end
 
-@constprop :aggressive @inline test_single_nondispatchtuple(c, @nospecialize(t)) =
+@constprop :aggressive @inline test_single_divisible_type(c, @nospecialize(t)) =
     c && isa(t, DataType) && t.name === Type.body.name
 let
     src = code_typed1((Any,)) do x
-        test_single_nondispatchtuple(true, x)
+        test_single_divisible_type(true, x)
     end
     @test all(src.code) do @nospecialize(x)
-        !(isinvoke(:test_single_nondispatchtuple, x) || iscall((src, test_single_nondispatchtuple), x))
+        !(isinvoke(:test_single_divisible_type, x) || iscall((src, test_single_divisible_type), x))
     end
 end
 
@@ -856,7 +856,7 @@ let
     @test invoke(Any[10]) === false
 end
 
-# test union-split, non-dispatchtuple callsite inlining
+# test union-split, divisible (non-dispatchtuple) callsite inlining
 
 @constprop :none @noinline abstract_unionsplit(@nospecialize x::Any) = Base.inferencebarrier(:Any)
 @constprop :none @noinline abstract_unionsplit(@nospecialize x::Number) = Base.inferencebarrier(:Number)

base/exports.jl

@@ -818,7 +818,7 @@ export
     isprimitivetype,
     isstructtype,
     isconcretetype,
-    isdispatchtuple,
+    isindivisibletype,
     oftype,
     promote,
     promote_rule,

base/runtime_internals.jl

@@ -856,7 +856,18 @@ meaning it could appear as a type signature in dispatch
 and has no subtypes (or supertypes) which could appear in a call.
 If `T` is not a type, then return `false`.
 """
-isdispatchtuple(@nospecialize(t)) = (@_total_meta; isa(t, DataType) && (t.flags & 0x0004) == 0x0004)
+isdispatchtuple(@nospecialize(t)) = (@_total_meta; isa(t, DataType) && t.name === Tuple.name && (t.flags & 0x0004) == 0x0004)
+
+"""
+    isindivisibletype(T)
+
+Determine whether type `T` is an indivisible type, meaning that `T′ <: T`
+implies `T′ == T` for any inhabited T′. This is a conservative under-
+approximation, so it may sometimes return `false` even when T is indivisible.
+
+If `T` is not a type, then return `false`.
+"""
+isindivisibletype(@nospecialize(t)) = (@_total_meta; isa(t, DataType) && (t.flags & 0x0004) == 0x0004)
 
 datatype_ismutationfree(dt::DataType) = (@_total_meta; (dt.flags & 0x0100) == 0x0100)
 
@@ -905,7 +916,7 @@ isconcretedispatch(@nospecialize t) = isconcretetype(t) && !iskindtype(t)
 
 using Core: has_free_typevars
 
-# equivalent to isa(v, Type) && isdispatchtuple(Tuple{v}) || v === Union{}
+# equivalent to isa(v, Type) && isindivisibletype(Tuple{v}) || v === Union{}
 # and is thus perhaps most similar to the old (pre-1.0) `isconcretetype` query
 function isdispatchelem(@nospecialize v)
     return (v === Bottom) || (v === typeof(Bottom)) || isconcretedispatch(v) ||
@@ -1521,7 +1532,7 @@ function may_invoke_generator(mi::MethodInstance)
 end
 function may_invoke_generator(method::Method, @nospecialize(atype), sparams::SimpleVector)
     # If we have complete information, we may always call the generator
-    isdispatchtuple(atype) && return true
+    isindivisibletype(atype) && return true
 
     # We don't have complete information, but it is possible that the generator
     # syntactically doesn't make use of the information we don't have. Check

base/staticdata.jl

@@ -75,7 +75,7 @@ get_require_world() = unsafe_load(cglobal(:jl_require_world, UInt))
 
 function gen_staged_sig(def::Method, mi::MethodInstance)
     isdefined(def, :generator) || return nothing
-    isdispatchtuple(mi.specTypes) || return nothing
+    isindivisibletype(mi.specTypes) || return nothing
     gen = Core.Typeof(def.generator)
     return Tuple{gen, UInt, Method, Vararg}
     ## more precise method lookup, but more costly and likely not actually better?

doc/src/base/base.md

@@ -191,7 +191,7 @@ Base.typeintersect
 Base.promote_type
 Base.promote_rule
 Base.promote_typejoin
-Base.isdispatchtuple
+Base.isindivisibletype
 ```
 
 ### Declared structure

src/datatype.c

@@ -100,7 +100,7 @@ jl_datatype_t *jl_new_uninitialized_datatype(void)
     jl_set_typetagof(t, jl_datatype_tag, 0);
     t->hash = 0;
     t->hasfreetypevars = 0;
-    t->isdispatchtuple = 0;
+    t->isindivisibletype = 0;
     t->isbitstype = 0;
     t->isprimitivetype = 0;
     t->zeroinit = 0;

src/gf.c

@@ -1014,7 +1014,7 @@ static void jl_compilation_sig(
             }
         }
         else if (jl_is_kind(elt)) {
-            // not triggered for isdispatchtuple(tt), this attempts to handle
+            // not triggered for isindivisibletype(tt), this attempts to handle
             // some cases of adapting a random signature into a compilation signature
             // if we get a kind, where we don't expect to accept one, widen it to something more expected (Type{T})
             if (!(jl_subtype(elt, type_i) && !jl_subtype((jl_value_t*)jl_type_type, type_i))) {
@@ -1044,11 +1044,11 @@ static void jl_compilation_sig(
         }
 
         if (jl_types_equal(elt, (jl_value_t*)jl_type_type)) { // elt == Type{T} where T
-            // not triggered for isdispatchtuple(tt), this attempts to handle
+            // not triggered for isindivisibletype(tt), this attempts to handle
             // some cases of adapting a random signature into a compilation signature
         }
         else if (!jl_is_datatype(elt) && jl_subtype(elt, (jl_value_t*)jl_type_type)) { // elt <: Type{T}
-            // not triggered for isdispatchtuple(tt), this attempts to handle
+            // not triggered for isindivisibletype(tt), this attempts to handle
             // some cases of adapting a random signature into a compilation signature
             if (!*newparams) *newparams = jl_svec_copy(tt->parameters);
             jl_svecset(*newparams, i, jl_type_type);
@@ -1197,7 +1197,7 @@ JL_DLLEXPORT int jl_isa_compileable_sig(
     if (definition->generator) {
         // staged functions aren't optimized
         // so assume the caller was intelligent about calling us
-        return (definition->isva ? np >= nargs - 1 : np == nargs) && type->isdispatchtuple;
+        return (definition->isva ? np >= nargs - 1 : np == nargs) && type->isindivisibletype;
     }
 
     // for varargs methods, only specialize up to max_args (>= nargs + 1).
@@ -1636,9 +1636,9 @@ static jl_method_instance_t *jl_mt_assoc_by_type(jl_methtable_t *mt JL_PROPAGATE
     jl_method_match_t *matc = NULL;
     JL_GC_PUSH2(&tt, &matc);
     JL_LOCK(&mt->writelock);
-    assert(tt->isdispatchtuple || tt->hasfreetypevars);
+    assert(tt->isindivisibletype || tt->hasfreetypevars);
     jl_method_instance_t *mi = NULL;
-    if (tt->isdispatchtuple) {
+    if (tt->isindivisibletype) {
         jl_genericmemory_t *leafcache = jl_atomic_load_relaxed(&mt->leafcache);
         jl_typemap_entry_t *entry = lookup_leafcache(leafcache, (jl_value_t*)tt, world);
         if (entry)
@@ -3132,7 +3132,7 @@ JL_DLLEXPORT jl_value_t *jl_normalize_to_compilable_sig(jl_methtable_t *mt, jl_t
     jl_methtable_t *kwmt = mt == jl_kwcall_mt ? jl_kwmethod_table_for(m->sig) : mt;
     intptr_t max_varargs = get_max_varargs(m, kwmt, mt, NULL);
     jl_compilation_sig(ti, env, m, max_varargs, &newparams);
-    int is_compileable = ((jl_datatype_t*)ti)->isdispatchtuple;
+    int is_compileable = ((jl_datatype_t*)ti)->isindivisibletype;
     if (newparams) {
         tt = (jl_datatype_t*)jl_apply_tuple_type(newparams, 1);
         if (!is_compileable) {
@@ -3184,7 +3184,7 @@ JL_DLLEXPORT jl_method_instance_t *jl_method_match_to_mi(jl_method_match_t *matc
         assert(mt != NULL);
         if ((jl_value_t*)mt != jl_nothing) {
             // get the specialization, possibly also caching it
-            if (mt_cache && ((jl_datatype_t*)ti)->isdispatchtuple) {
+            if (mt_cache && ((jl_datatype_t*)ti)->isindivisibletype) {
                 // Since we also use this presence in the cache
                 // to trigger compilation when producing `.ji` files,
                 // inject it there now if we think it will be
@@ -3334,7 +3334,7 @@ JL_DLLEXPORT void jl_compile_method_instance(jl_method_instance_t *mi, jl_tuplet
         // In addition to full compilation of the compilation-signature, if `types` is more specific (e.g. due to nospecialize),
         // also run inference now on the original `types`, since that may help us guide inference to find
         // additional useful methods that should be compiled
-        //ALT: if (jl_is_datatype(types) && ((jl_datatype_t*)types)->isdispatchtuple && !jl_egal(mi->specTypes, types))
+        //ALT: if (jl_is_datatype(types) && ((jl_datatype_t*)types)->isindivisibletype && !jl_egal(mi->specTypes, types))
         //ALT: if (jl_subtype(types, mi->specTypes))
         if (types && !jl_subtype(mi->specTypes, (jl_value_t*)types)) {
             jl_svec_t *tpenv2 = jl_emptysvec;
@@ -3882,7 +3882,7 @@ static int ml_matches_visitor(jl_typemap_entry_t *ml, struct typemap_intersectio
         return 1;
     }
     jl_method_t *meth = ml->func.method;
-    if (closure->lim >= 0 && jl_is_dispatch_tupletype(meth->sig)) {
+    if (closure->lim >= 0 && jl_is_indivisible_type(meth->sig)) {
         int replaced = 0;
         // check if this is replaced, in which case we need to avoid double-counting it against the limit
         // (although it will figure out later which one to keep and return)
@@ -4233,7 +4233,7 @@ static jl_value_t *ml_matches(jl_methtable_t *mt,
 
     if (mt) {
         // check the leaf cache if this type can be in there
-        if (((jl_datatype_t*)unw)->isdispatchtuple) {
+        if (((jl_datatype_t*)unw)->isindivisibletype) {
             jl_genericmemory_t *leafcache = jl_atomic_load_relaxed(&mt->leafcache);
             jl_typemap_entry_t *entry = lookup_leafcache(leafcache, (jl_value_t*)type, world);
             if (entry) {
@@ -4266,12 +4266,12 @@ static jl_value_t *ml_matches(jl_methtable_t *mt,
             }
         }
         // then check the full cache if it seems profitable
-        if (((jl_datatype_t*)unw)->isdispatchtuple) {
+        if (((jl_datatype_t*)unw)->isindivisibletype) {
             jl_typemap_entry_t *entry = jl_typemap_assoc_by_type(jl_atomic_load_relaxed(&mt->cache), &search, jl_cachearg_offset(mt), /*subtype*/1);
-            if (entry && (((jl_datatype_t*)unw)->isdispatchtuple || entry->guardsigs == jl_emptysvec)) {
+            if (entry && (((jl_datatype_t*)unw)->isindivisibletype || entry->guardsigs == jl_emptysvec)) {
                 jl_method_instance_t *mi = entry->func.linfo;
                 jl_method_t *meth = mi->def.method;
-                if (!jl_is_unionall(meth->sig) && ((jl_datatype_t*)unw)->isdispatchtuple) {
+                if (!jl_is_unionall(meth->sig) && ((jl_datatype_t*)unw)->isindivisibletype) {
                     env.match.env = jl_emptysvec;
                     env.match.ti = unw;
                 }
@@ -4560,7 +4560,7 @@ static jl_value_t *ml_matches(jl_methtable_t *mt,
         if (env.match.max_valid > max_world)
             env.match.max_valid = max_world;
     }
-    if (mt && cache_result && ((jl_datatype_t*)unw)->isdispatchtuple) { // cache_result parameter keeps this from being recursive
+    if (mt && cache_result && ((jl_datatype_t*)unw)->isindivisibletype) { // cache_result parameter keeps this from being recursive
         if (len == 1 && !has_ambiguity) {
             env.matc = (jl_method_match_t*)jl_array_ptr_ref(env.t, 0);
             jl_method_t *meth = env.matc->method;