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;

src/jltypes.c

@@ -1839,24 +1839,24 @@ void jl_precompute_memoized_dt(jl_datatype_t *dt, int cacheable)
     dt->hasfreetypevars = 0;
     dt->maybe_subtype_of_cache = 1;
     dt->isconcretetype = !dt->name->abstract;
-    dt->isdispatchtuple = istuple;
+    dt->isindivisibletype = (!dt->name->abstract && !jl_is_kind((jl_value_t*)dt)) || (dt->name == jl_type_typename);
     size_t i, l = jl_nparams(dt);
     for (i = 0; i < l; i++) {
         jl_value_t *p = jl_tparam(dt, i);
-        if (!dt->hasfreetypevars) {
-            dt->hasfreetypevars = jl_has_free_typevars(p);
-            if (dt->hasfreetypevars)
-                dt->isconcretetype = 0;
+        if (!dt->hasfreetypevars && jl_has_free_typevars(p)) {
+            // XXX: this under-approximates type-indivisibility / type-concreteness in some
+            // conspicuous cases like (Tuple{T, Int} where T <: Int). Since these predicates
+            // are defined to be under-approximated, this is not a bug by itself, but this
+            // is something we may like to improve in the future
+            dt->hasfreetypevars = 1;
+            dt->isconcretetype = 0;
+            dt->isindivisibletype = 0;
         }
         if (istuple) {
             if (dt->isconcretetype)
                 dt->isconcretetype = (jl_is_datatype(p) && ((jl_datatype_t*)p)->isconcretetype) || p == jl_bottom_type;
-            if (dt->isdispatchtuple) {
-                dt->isdispatchtuple = jl_is_datatype(p) &&
-                    ((!jl_is_kind(p) && ((jl_datatype_t*)p)->isconcretetype) ||
-                     (p == (jl_value_t*)jl_typeofbottom_type) || // == Type{Union{}}, so needs to be consistent
-                     (((jl_datatype_t*)p)->name == jl_type_typename && !((jl_datatype_t*)p)->hasfreetypevars));
-            }
+            if (dt->isindivisibletype)
+                dt->isindivisibletype = jl_is_datatype(p) && ((jl_datatype_t*)p)->isindivisibletype;
         }
         if (jl_is_vararg(p))
             p = ((jl_vararg_t*)p)->T;
@@ -1871,7 +1871,7 @@ void jl_precompute_memoized_dt(jl_datatype_t *dt, int cacheable)
             dt->maybe_subtype_of_cache = !p || maybe_subtype_of_cache(p, istuple) || !jl_has_free_typevars(p);
         }
     }
-    assert(dt->isconcretetype || dt->isdispatchtuple ? dt->maybe_subtype_of_cache : 1);
+    assert(dt->isconcretetype || dt->isindivisibletype ? dt->maybe_subtype_of_cache : 1);
     if (dt->name == jl_type_typename) {
         jl_value_t *p = jl_tparam(dt, 0);
         if (!jl_is_type(p) && !jl_is_typevar(p)) // Type{v} has no subtypes, if v is not a Type
@@ -2986,7 +2986,7 @@ void jl_init_types(void) JL_GC_DISABLED
             "instance",
             "layout",
             "hash",
-            "flags"); // "hasfreetypevars", "isconcretetype", "isdispatchtuple", "isbitstype", "zeroinit", "has_concrete_subtype", "maybe_subtype_of_cache"
+            "flags"); // "hasfreetypevars", "isconcretetype", "isindivisibletype", "isbitstype", "zeroinit", "has_concrete_subtype", "maybe_subtype_of_cache"
     jl_datatype_type->types = jl_svec(8,
             jl_typename_type,
             jl_datatype_type,
@@ -3092,6 +3092,7 @@ void jl_init_types(void) JL_GC_DISABLED
     jl_bottom_type = jl_gc_permobj(0, jl_typeofbottom_type, 0);
     jl_set_typetagof(jl_bottom_type, jl_typeofbottom_tag, GC_OLD_MARKED);
     jl_typeofbottom_type->instance = jl_bottom_type;
+    jl_typeofbottom_type->isindivisibletype = 1;
 
     jl_unionall_type = jl_new_datatype(jl_symbol("UnionAll"), core, type_type, jl_emptysvec,
                                        jl_perm_symsvec(2, "var", "body"),
@@ -3133,6 +3134,7 @@ void jl_init_types(void) JL_GC_DISABLED
     // fix some miscomputed values, since we didn't know this was going to be a Tuple in jl_precompute_memoized_dt
     jl_tuple_typename->wrapper = (jl_value_t*)jl_anytuple_type; // remove UnionAll wrappers
     jl_anytuple_type->isconcretetype = 0;
+    jl_anytuple_type->isindivisibletype = 0;
     jl_anytuple_type->maybe_subtype_of_cache = 0;
     jl_anytuple_type->layout = NULL;
 

src/julia.h

@@ -606,8 +606,20 @@ typedef struct _jl_datatype_t {
     // memoized properties (set on construction)
     uint32_t hash;
     uint16_t hasfreetypevars:1; // majority part of isconcrete computation
-    uint16_t isconcretetype:1; // whether this type can have instances
-    uint16_t isdispatchtuple:1; // aka isleaftupletype
+
+    // whether there is an object x such that T == typeof(x)
+    //
+    // in many cases this implies indivisibility, with the notable exception of singleton types
+    // (`Type{T}`) which make, e.g., DataType a divisible type despite being concrete
+    uint16_t isconcretetype:1; // conservative under-approximation (false implies nothing)
+
+    // whether T is an indivisible type (aka "leaf" type for tuples), i.e. T is "maximally-specific"
+    // in the sense that for all inhabited T′, (T′ <: T) implies (T′ == T)
+    //
+    // if false, T may or may not be indivisible and may even be type-equal to another type which
+    // has this flag set
+    uint16_t isindivisibletype:1; // conservative under-approximation (false implies nothing)
+
     uint16_t isbitstype:1; // relevant query for C-api and type-parameters
     uint16_t zeroinit:1; // if one or more fields requires zero-initialization
     uint16_t has_concrete_subtype:1; // If clear, no value will have this datatype
@@ -1875,9 +1887,9 @@ JL_DLLEXPORT const char *jl_typeof_str(jl_value_t *v) JL_NOTSAFEPOINT;
 JL_DLLEXPORT int jl_type_morespecific(jl_value_t *a, jl_value_t *b);
 JL_DLLEXPORT int jl_method_morespecific(jl_method_t *ma, jl_method_t *mb);
 
-STATIC_INLINE int jl_is_dispatch_tupletype(jl_value_t *v) JL_NOTSAFEPOINT
+STATIC_INLINE int jl_is_indivisible_type(jl_value_t *v) JL_NOTSAFEPOINT
 {
-    return jl_is_datatype(v) && ((jl_datatype_t*)v)->isdispatchtuple;
+    return jl_is_datatype(v) && ((jl_datatype_t*)v)->isindivisibletype;
 }
 
 STATIC_INLINE int jl_is_concrete_type(jl_value_t *v) JL_NOTSAFEPOINT

src/precompile_utils.c

@@ -229,7 +229,7 @@ static int precompile_enq_all_specializations__(jl_typemap_entry_t *def, void *c
     jl_method_t *m = def->func.method;
     if (m->external_mt)
         return 1;
-    if ((m->name == jl_symbol("__init__") || m->ccallable) && jl_is_dispatch_tupletype(m->sig)) {
+    if ((m->name == jl_symbol("__init__") || m->ccallable) && jl_is_indivisible_type(m->sig)) {
         // ensure `__init__()` and @ccallables get strongly-hinted, specialized, and compiled
         jl_method_instance_t *mi = jl_specializations_get_linfo(m, m->sig, jl_emptysvec);
         jl_array_ptr_1d_push((jl_array_t*)closure, (jl_value_t*)mi);