Compiler.jl: use Base.[all|any] instead of Compiler's own versions (#56851)

The current `Compiler` defines its own versions of `all` and `any`,
which are separate generic functions from `Base.[all|any]`:
https://github.com/JuliaLang/julia/blob/2ed1a411e0a080f3107e75bb65105a15a0533a90/Compiler/src/utilities.jl#L15-L32

On the other hand, at the point where `Base.Compiler` is bootstrapped,
only a subset of `Base.[all|any]` are defined, specifically those
related to `Tuple`:

https://github.com/JuliaLang/julia/blob/2ed1a411e0a080f3107e75bb65105a15a0533a90/base/tuple.jl#L657-L668.
Consequently, in the type inference world, functions like
`Base.all(::Generator)` are unavailable. If `Base.Compiler` attempts to
perform operations such as `::BitSet ⊆ ::BitSet` (which internally uses
`Base.[all|any]`), a world age error occurs (while `Compiler.[all|any]`
can handle these operations, `::BitSet ⊆ ::BitSet` uses
`Base.[all|any]`, leading to this issue)

To resolve this problem, this commit removes the custom `Compiler`
versions of `[all|any]` and switches to using the Base versions.

One concern is that the previous `Compiler` versions of `[all|any]`
utilized `@nospecialize`. That annotation was introduced a long time ago
to prevent over-specialization, but it is questionable whether it is
still effective with the current compiler implementation. The results of
the nanosoldier benchmarks conducted below also seem to confirm that
the `@nospecialize`s are no longer necessary for those functions.

Author: aviatesk

Compiler/src/Compiler.jl

@@ -41,36 +41,36 @@ ccall(:jl_set_module_uuid, Cvoid, (Any, NTuple{2, UInt64}), Compiler,
 
 using Core.Intrinsics, Core.IR
 
-import Core: print, println, show, write, unsafe_write,
-             _apply_iterate, svec, apply_type, Builtin, IntrinsicFunction,
-             MethodInstance, CodeInstance, MethodTable, MethodMatch, PartialOpaque,
-             TypeofVararg, Core, SimpleVector, donotdelete, compilerbarrier,
-             memoryref_isassigned, memoryrefnew, memoryrefoffset, memoryrefget,
-             memoryrefset!, typename
+using Core: Builtin, CodeInstance, IntrinsicFunction, MethodInstance, MethodMatch,
+    MethodTable, PartialOpaque, SimpleVector, TypeofVararg,
+    _apply_iterate, apply_type, compilerbarrier, donotdelete, memoryref_isassigned,
+    memoryrefget, memoryrefnew, memoryrefoffset, memoryrefset!, print, println, show, svec,
+    typename, unsafe_write, write
 
 using Base
-using Base: Ordering, vect, EffectsOverride, BitVector, @_gc_preserve_begin, @_gc_preserve_end, RefValue,
-    @nospecializeinfer, @_foldable_meta, fieldindex, is_function_def, indexed_iterate, isexpr, methods,
-    get_world_counter, JLOptions, _methods_by_ftype, unwrap_unionall, cconvert, unsafe_convert,
-    issingletontype, isType, rewrap_unionall, has_free_typevars, isvarargtype, hasgenerator,
-    IteratorSize, SizeUnknown, _array_for, Bottom, generating_output, diff_names,
-    ismutationfree, NUM_EFFECTS_OVERRIDES, _NAMEDTUPLE_NAME, datatype_fieldtypes,
-    argument_datatype, isfieldatomic, unwrapva, iskindtype, _bits_findnext, copy_exprargs,
-    Generator, Filter, ismutabletypename, isvatuple, datatype_fieldcount,
-    isconcretedispatch, isdispatchelem, datatype_layoutsize,
-    datatype_arrayelem, unionlen, isidentityfree, _uniontypes, uniontypes, OneTo, Callable,
-    DataTypeFieldDesc, datatype_nfields, datatype_pointerfree, midpoint, is_valid_intrinsic_elptr,
-    allocatedinline, isbitsunion, widen_diagonal, unconstrain_vararg_length,
-    rename_unionall, may_invoke_generator, is_meta_expr_head, is_meta_expr, quoted,
-    specialize_method, hasintersect, is_nospecializeinfer, is_nospecialized,
-    get_nospecializeinfer_sig, tls_world_age, uniontype_layout, kwerr,
-    moduleroot, is_file_tracked, decode_effects_override, lookup_binding_partition,
-    is_some_imported, binding_kind, is_some_guard, is_some_const_binding, partition_restriction,
-    BINDING_KIND_GLOBAL, structdiff
+using Base: @_foldable_meta, @_gc_preserve_begin, @_gc_preserve_end, @nospecializeinfer,
+    BINDING_KIND_GLOBAL, Base, BitVector, Bottom, Callable, DataTypeFieldDesc,
+    EffectsOverride, Filter, Generator, IteratorSize, JLOptions, NUM_EFFECTS_OVERRIDES,
+    OneTo, Ordering, RefValue, SizeUnknown, _NAMEDTUPLE_NAME,
+    _array_for, _bits_findnext, _methods_by_ftype, _uniontypes, all, allocatedinline, any,
+    argument_datatype, binding_kind, cconvert, copy_exprargs, datatype_arrayelem,
+    datatype_fieldcount, datatype_fieldtypes, datatype_layoutsize, datatype_nfields,
+    datatype_pointerfree, decode_effects_override, diff_names, fieldindex,
+    generating_output, get_nospecializeinfer_sig, get_world_counter, has_free_typevars,
+    hasgenerator, hasintersect, indexed_iterate, isType, is_file_tracked, is_function_def,
+    is_meta_expr, is_meta_expr_head, is_nospecialized, is_nospecializeinfer,
+    is_some_const_binding, is_some_guard, is_some_imported, is_valid_intrinsic_elptr,
+    isbitsunion, isconcretedispatch, isdispatchelem, isexpr, isfieldatomic, isidentityfree,
+    iskindtype, ismutabletypename, ismutationfree, issingletontype, isvarargtype, isvatuple,
+    kwerr, lookup_binding_partition, may_invoke_generator, methods, midpoint, moduleroot,
+    partition_restriction, quoted, rename_unionall, rewrap_unionall, specialize_method,
+    structdiff, tls_world_age, unconstrain_vararg_length, unionlen, uniontype_layout,
+    uniontypes, unsafe_convert, unwrap_unionall, unwrapva, vect, widen_diagonal
 using Base.Order
-import Base: getindex, setindex!, length, iterate, push!, isempty, first, convert, ==,
-    copy, popfirst!, in, haskey, resize!, copy!, append!, last, get!, size,
-    get, iterate, findall, min_world, max_world, _topmod, isready
+
+import Base: ==, _topmod, append!, convert, copy, copy!, findall, first, get, get!,
+    getindex, haskey, in, isempty, isready, iterate, iterate, last, length, max_world,
+    min_world, popfirst!, push!, resize!, setindex!, size
 
 const getproperty = Core.getfield
 const setproperty! = Core.setfield!

Compiler/src/utilities.jl

@@ -12,25 +12,6 @@ if !@isdefined(var"@timeit")
     end
 end
 
-# avoid cycle due to over-specializing `any` when used by inference
-function _any(@nospecialize(f), a)
-    for x in a
-        f(x) && return true
-    end
-    return false
-end
-any(@nospecialize(f), itr) = _any(f, itr)
-any(itr) = _any(identity, itr)
-
-function _all(@nospecialize(f), a)
-    for x in a
-        f(x) || return false
-    end
-    return true
-end
-all(@nospecialize(f), itr) = _all(f, itr)
-all(itr) = _all(identity, itr)
-
 function contains_is(itr, @nospecialize(x))
     for y in itr
         if y === x

base/Base_compiler.jl

@@ -249,6 +249,8 @@ using .Iterators: Flatten, Filter, product  # for generators
 using .Iterators: Stateful    # compat (was formerly used in reinterpretarray.jl)
 include("namedtuple.jl")
 
+include("anyall.jl")
+
 include("ordering.jl")
 using .Order
 

base/anyall.jl

@@ -0,0 +1,231 @@
+# This file is a part of Julia. License is MIT: https://julialang.org/license
+
+## all & any
+
+"""
+    any(itr) -> Bool
+
+Test whether any elements of a boolean collection are `true`, returning `true` as
+soon as the first `true` value in `itr` is encountered (short-circuiting). To
+short-circuit on `false`, use [`all`](@ref).
+
+If the input contains [`missing`](@ref) values, return `missing` if all non-missing
+values are `false` (or equivalently, if the input contains no `true` value), following
+[three-valued logic](https://en.wikipedia.org/wiki/Three-valued_logic).
+
+See also: [`all`](@ref), [`count`](@ref), [`sum`](@ref), [`|`](@ref), [`||`](@ref).
+
+# Examples
+```jldoctest
+julia> a = [true,false,false,true]
+4-element Vector{Bool}:
+ 1
+ 0
+ 0
+ 1
+
+julia> any(a)
+true
+
+julia> any((println(i); v) for (i, v) in enumerate(a))
+1
+true
+
+julia> any([missing, true])
+true
+
+julia> any([false, missing])
+missing
+```
+"""
+any(itr) = any(identity, itr)
+
+"""
+    all(itr) -> Bool
+
+Test whether all elements of a boolean collection are `true`, returning `false` as
+soon as the first `false` value in `itr` is encountered (short-circuiting). To
+short-circuit on `true`, use [`any`](@ref).
+
+If the input contains [`missing`](@ref) values, return `missing` if all non-missing
+values are `true` (or equivalently, if the input contains no `false` value), following
+[three-valued logic](https://en.wikipedia.org/wiki/Three-valued_logic).
+
+See also: [`all!`](@ref), [`any`](@ref), [`count`](@ref), [`&`](@ref), [`&&`](@ref), [`allunique`](@ref).
+
+# Examples
+```jldoctest
+julia> a = [true,false,false,true]
+4-element Vector{Bool}:
+ 1
+ 0
+ 0
+ 1
+
+julia> all(a)
+false
+
+julia> all((println(i); v) for (i, v) in enumerate(a))
+1
+2
+false
+
+julia> all([missing, false])
+false
+
+julia> all([true, missing])
+missing
+```
+"""
+all(itr) = all(identity, itr)
+
+"""
+    any(p, itr) -> Bool
+
+Determine whether predicate `p` returns `true` for any elements of `itr`, returning
+`true` as soon as the first item in `itr` for which `p` returns `true` is encountered
+(short-circuiting). To short-circuit on `false`, use [`all`](@ref).
+
+If the input contains [`missing`](@ref) values, return `missing` if all non-missing
+values are `false` (or equivalently, if the input contains no `true` value), following
+[three-valued logic](https://en.wikipedia.org/wiki/Three-valued_logic).
+
+# Examples
+```jldoctest
+julia> any(i->(4<=i<=6), [3,5,7])
+true
+
+julia> any(i -> (println(i); i > 3), 1:10)
+1
+2
+3
+4
+true
+
+julia> any(i -> i > 0, [1, missing])
+true
+
+julia> any(i -> i > 0, [-1, missing])
+missing
+
+julia> any(i -> i > 0, [-1, 0])
+false
+```
+"""
+any(f, itr) = _any(f, itr, :)
+
+for ItrT = (Tuple,Any)
+    # define a generic method and a specialized version for `Tuple`,
+    # whose method bodies are identical, while giving better effects to the later
+    @eval function _any(f, itr::$ItrT, ::Colon)
+        $(ItrT === Tuple ? :(@_terminates_locally_meta) : :nothing)
+        anymissing = false
+        for x in itr
+            v = f(x)
+            if ismissing(v)
+                anymissing = true
+            else
+                v && return true
+            end
+        end
+        return anymissing ? missing : false
+    end
+end
+
+# Specialized versions of any(f, ::Tuple)
+# We fall back to the for loop implementation all elements have the same type or
+# if the tuple is too large.
+function any(f, itr::Tuple)
+    if itr isa NTuple || length(itr) > 32
+        return _any(f, itr, :)
+    end
+    _any_tuple(f, false, itr...)
+end
+
+@inline function _any_tuple(f, anymissing, x, rest...)
+    v = f(x)
+    if ismissing(v)
+        anymissing = true
+    elseif v
+        return true
+    end
+    return _any_tuple(f, anymissing, rest...)
+end
+@inline _any_tuple(f, anymissing) = anymissing ? missing : false
+
+"""
+    all(p, itr) -> Bool
+
+Determine whether predicate `p` returns `true` for all elements of `itr`, returning
+`false` as soon as the first item in `itr` for which `p` returns `false` is encountered
+(short-circuiting). To short-circuit on `true`, use [`any`](@ref).
+
+If the input contains [`missing`](@ref) values, return `missing` if all non-missing
+values are `true` (or equivalently, if the input contains no `false` value), following
+[three-valued logic](https://en.wikipedia.org/wiki/Three-valued_logic).
+
+# Examples
+```jldoctest
+julia> all(i->(4<=i<=6), [4,5,6])
+true
+
+julia> all(i -> (println(i); i < 3), 1:10)
+1
+2
+3
+false
+
+julia> all(i -> i > 0, [1, missing])
+missing
+
+julia> all(i -> i > 0, [-1, missing])
+false
+
+julia> all(i -> i > 0, [1, 2])
+true
+```
+"""
+all(f, itr) = _all(f, itr, :)
+
+for ItrT = (Tuple,Any)
+    # define a generic method and a specialized version for `Tuple`,
+    # whose method bodies are identical, while giving better effects to the later
+    @eval function _all(f, itr::$ItrT, ::Colon)
+        $(ItrT === Tuple ? :(@_terminates_locally_meta) : :nothing)
+        anymissing = false
+        for x in itr
+            v = f(x)
+            if ismissing(v)
+                anymissing = true
+            else
+                v || return false
+            end
+        end
+        return anymissing ? missing : true
+    end
+end
+
+# Specialized versions of all(f, ::Tuple),
+# This is similar to any(f, ::Tuple) defined above.
+function all(f, itr::Tuple)
+    if itr isa NTuple || length(itr) > 32
+        return _all(f, itr, :)
+    end
+    _all_tuple(f, false, itr...)
+end
+
+@inline function _all_tuple(f, anymissing, x, rest...)
+    v = f(x)
+    if ismissing(v)
+        anymissing = true
+    # this syntax allows throwing a TypeError for non-Bool, for consistency with any
+    elseif v
+        nothing
+    else
+        return false
+    end
+    return _all_tuple(f, anymissing, rest...)
+end
+@inline _all_tuple(f, anymissing) = anymissing ? missing : true
+
+all(::Tuple{Missing}) = missing