Merge branch 'JuliaLang:master' into N5N3flatten

Author: N5N3

.buildkite/pipelines/main/misc/whitespace.yml

@@ -17,8 +17,5 @@ steps:
           workspaces:
             - "/cache/repos:/cache/repos"
     timeout_in_minutes: 10
-    notify:
-      - github_commit_status:
-          context: "whitespace"
     commands: |
       make --output-sync -j$${JULIA_CPU_THREADS:?} check-whitespace

.buildkite/pipelines/main/platforms/tester_linux.arches

@@ -1,5 +1,5 @@
 # PLATFORM    LABEL         GROUP    ALLOW_FAIL    ARCH        ARCH_ROOTFS    MAKE_FLAGS     TIMEOUT_BK    TIMEOUT_RR     RETRIES    IS_RR    IS_ST    IS_MT    ROOTFS_TAG    ROOTFS_HASH
-linux         32_g1         g1       .             32          i686           .              .             .              .          .        .        .        v4.8          b6dffc772ab4c2cd7fd4f83459308f6f0d89b957
+linux         32_g1         g1       .             32          i686           .              120           .              .          .        .        .        v4.8          b6dffc772ab4c2cd7fd4f83459308f6f0d89b957
 linux         32_g2         g2       .             32          i686           .              .             .              3          .        .        .        v4.8          b6dffc772ab4c2cd7fd4f83459308f6f0d89b957
 
 linux         64_g1_mt      g1       .             64          x86_64         .              .             .              .          .        .        yes      v4.8          2a058481b567f0e91b9aa3ce4ad4f09e6419355a

Makefile

@@ -48,7 +48,7 @@ $(BUILDROOT)/doc/_build/html/en/index.html: $(shell find $(BUILDROOT)/base $(BUI
 
 julia-symlink: julia-cli-$(JULIA_BUILD_MODE)
 ifeq ($(OS),WINNT)
-	@echo '@"%~dp0\'"$$(echo $(call rel_path,$(BUILDROOT),$(JULIA_EXECUTABLE)) | tr / '\\')"\" '%*' > $(BUILDROOT)/julia.bat
+	echo '@"%~dp0/'"$$(echo '$(call rel_path,$(BUILDROOT),$(JULIA_EXECUTABLE))')"'" %*' | tr / '\\' > $(BUILDROOT)/julia.bat
 	chmod a+x $(BUILDROOT)/julia.bat
 else
 ifndef JULIA_VAGRANT_BUILD

NEWS.md

@@ -12,6 +12,7 @@ New language features
   to enforce the involved function calls to be (or not to be) inlined. ([#41312])
 * The default behavior of observing `@inbounds` declarations is now an option via `auto` in `--check-bounds=yes|no|auto` ([#41551])
 * New function `eachsplit(str)` for iteratively performing `split(str)`.
+* New function `allequal(itr)` for testing if all elements in an iterator are equal. ([#43354])
 * `∀`, `∃`, and `∄` are now allowed as identifier characters ([#42314]).
 * Support for Unicode 14.0.0 ([#43443]).
 * `try`-blocks can now optionally have an `else`-block which is executed right after the main body only if
@@ -72,6 +73,9 @@ Command-line option changes
 Multi-threading changes
 -----------------------
 
+* `Threads.@threads` now defaults to a new `:dynamic` schedule option which is similar to the previous behavior except
+  that iterations will be scheduled dynamically to available worker threads rather than pinned to each thread. This
+  behavior is more composable with (possibly nested) `@spawn` and `@threads` loops ([#43919], [#44136])
 
 Build system changes
 --------------------

README.md

@@ -93,7 +93,7 @@ Julia. However, most users should use the [most recent stable version](https://g
 of Julia. You can get this version by changing to the Julia directory
 and running:
 
-    git checkout v1.7.0
+    git checkout v1.7.2
 
 Now run `make` to build the `julia` executable.
 

base/Base.jl

@@ -58,6 +58,7 @@ replaceproperty!(x, f::Symbol, expected, desired, success_order::Symbol=:notatom
     (@inline; Core.replacefield!(x, f, expected, convert(fieldtype(typeof(x), f), desired), success_order, fail_order))
 
 convert(::Type{Any}, Core.@nospecialize x) = x
+convert(::Type{T}, x::T) where {T} = x
 include("coreio.jl")
 
 eval(x) = Core.eval(Base, x)

base/abstractarray.jl

@@ -1759,7 +1759,8 @@ end
 """
     vcat(A...)
 
-Concatenate along dimension 1.
+Concatenate along dimension 1. To efficiently concatenate a large vector of arrays,
+use `reduce(vcat, x)`.
 
 # Examples
 ```jldoctest
@@ -1785,13 +1786,29 @@ julia> vcat(c...)
 2×3 Matrix{Int64}:
  1  2  3
  4  5  6
+
+julia> vs = [[1, 2], [3, 4], [5, 6]]
+3-element Vector{Vector{Int64}}:
+ [1, 2]
+ [3, 4]
+ [5, 6]
+
+julia> reduce(vcat, vs)
+6-element Vector{Int64}:
+ 1
+ 2
+ 3
+ 4
+ 5
+ 6
 ```
 """
 vcat(X...) = cat(X...; dims=Val(1))
 """
     hcat(A...)
 
-Concatenate along dimension 2.
+Concatenate along dimension 2. To efficiently concatenate a large vector of arrays,
+use `reduce(hcat, x)`.
 
 # Examples
 ```jldoctest
@@ -1836,6 +1853,17 @@ julia> hcat(x, [1; 2; 3])
  1
  2
  3
+
+julia> vs = [[1, 2], [3, 4], [5, 6]]
+3-element Vector{Vector{Int64}}:
+ [1, 2]
+ [3, 4]
+ [5, 6]
+
+julia> reduce(hcat, vs)
+2×3 Matrix{Int64}:
+ 1  3  5
+ 2  4  6
 ```
 """
 hcat(X...) = cat(X...; dims=Val(2))

base/array.jl

@@ -2586,6 +2586,7 @@ end
 
 """
     keepat!(a::Vector, inds)
+    keepat!(a::BitVector, inds)
 
 Remove the items at all the indices which are not given by `inds`,
 and return the modified `a`.
@@ -2610,6 +2611,7 @@ keepat!(a::Vector, inds) = _keepat!(a, inds)
 
 """
     keepat!(a::Vector, m::AbstractVector{Bool})
+    keepat!(a::BitVector, m::AbstractVector{Bool})
 
 The in-place version of logical indexing `a = a[m]`. That is, `keepat!(a, m)` on
 vectors of equal length `a` and `m` will remove all elements from `a` for which

base/asyncmap.jl

@@ -15,7 +15,7 @@ up to 100 tasks will be used for concurrent mapping.
 
 `ntasks` can also be specified as a zero-arg function. In this case, the
 number of tasks to run in parallel is checked before processing every element and a new
-task started if the value of `ntasks_func` is less than the current number
+task started if the value of `ntasks_func` is greater than the current number
 of tasks.
 
 If `batch_size` is specified, the collection is processed in batch mode. `f` must

base/channels.jl

@@ -63,6 +63,7 @@ Channel(sz=0) = Channel{Any}(sz)
 
 Create a new task from `func`, bind it to a new channel of type
 `T` and size `size`, and schedule the task, all in a single call.
+The channel is automatically closed when the task terminates.
 
 `func` must accept the bound channel as its only argument.
 

base/client.jl

@@ -323,8 +323,8 @@ end
 function _global_julia_startup_file()
     # If the user built us with a specific Base.SYSCONFDIR, check that location first for a startup.jl file
     # If it is not found, then continue on to the relative path based on Sys.BINDIR
-    BINDIR = Sys.BINDIR::String
-    SYSCONFDIR = Base.SYSCONFDIR::String
+    BINDIR = Sys.BINDIR
+    SYSCONFDIR = Base.SYSCONFDIR
     if !isempty(SYSCONFDIR)
         p1 = abspath(BINDIR, SYSCONFDIR, "julia", "startup.jl")
         isfile(p1) && return p1

base/compiler/abstractinterpretation.jl

@@ -1482,8 +1482,17 @@ function abstract_call_known(interp::AbstractInterpreter, @nospecialize(f),
         if f === _apply_iterate
             return abstract_apply(interp, argtypes, sv, max_methods)
         elseif f === invoke
-            return abstract_invoke(interp, arginfo, sv)
+            call = abstract_invoke(interp, arginfo, sv)
+            if call.info === false
+                if call.rt === Bottom
+                    tristate_merge!(sv, Effects(EFFECTS_TOTAL, nothrow=ALWAYS_FALSE))
+                else
+                    tristate_merge!(sv, Effects())
+                end
+            end
+            return call
         elseif f === modifyfield!
+            tristate_merge!(sv, Effects()) # TODO
             return abstract_modifyfield!(interp, argtypes, sv)
         end
         rt = abstract_call_builtin(interp, f, arginfo, sv, max_methods)
@@ -1622,13 +1631,16 @@ function abstract_call(interp::AbstractInterpreter, arginfo::ArgInfo,
     if isa(ft, PartialOpaque)
         newargtypes = copy(argtypes)
         newargtypes[1] = ft.env
+        tristate_merge!(sv, Effects()) # TODO
         return abstract_call_opaque_closure(interp, ft, ArgInfo(arginfo.fargs, newargtypes), sv)
     elseif (uft = unwrap_unionall(widenconst(ft)); isa(uft, DataType) && uft.name === typename(Core.OpaqueClosure))
+        tristate_merge!(sv, Effects()) # TODO
         return CallMeta(rewrap_unionall((uft::DataType).parameters[2], widenconst(ft)), false)
     elseif f === nothing
         # non-constant function, but the number of arguments is known
         # and the ft is not a Builtin or IntrinsicFunction
         if hasintersect(widenconst(ft), Union{Builtin, Core.OpaqueClosure})
+            tristate_merge!(sv, Effects())
             add_remark!(interp, sv, "Could not identify method table for call")
             return CallMeta(Any, false)
         end
@@ -1866,7 +1878,7 @@ function abstract_eval_statement(interp::AbstractInterpreter, @nospecialize(e),
                 effects.consistent ? ALWAYS_TRUE : TRISTATE_UNKNOWN,
                 effects.effect_free ? ALWAYS_TRUE : TRISTATE_UNKNOWN,
                 effects.nothrow ? ALWAYS_TRUE : TRISTATE_UNKNOWN,
-                effects.terminates ? ALWAYS_TRUE : TRISTATE_UNKNOWN,
+                effects.terminates_globally ? ALWAYS_TRUE : TRISTATE_UNKNOWN,
             ))
         else
             tristate_merge!(sv, Effects())
@@ -2040,8 +2052,11 @@ end
 function handle_control_backedge!(frame::InferenceState, from::Int, to::Int)
     if from > to
         def = frame.linfo.def
-        if isa(def, Method) && decode_effects_override(def.purity).terminates_locally
-            return nothing
+        if isa(def, Method)
+            effects = decode_effects_override(def.purity)
+            if effects.terminates_globally || effects.terminates_locally
+                return nothing
+            end
         end
         tristate_merge!(frame, Effects(EFFECTS_TOTAL, terminates=TRISTATE_UNKNOWN))
     end

base/compiler/compiler.jl

@@ -29,6 +29,7 @@ macro inline()   Expr(:meta, :inline)   end
 macro noinline() Expr(:meta, :noinline) end
 
 convert(::Type{Any}, Core.@nospecialize x) = x
+convert(::Type{T}, x::T) where {T} = x
 
 # essential files and libraries
 include("essentials.jl")

base/compiler/ssair/inlining.jl

@@ -1168,7 +1168,6 @@ function analyze_single_call!(
     sig::Signature, state::InliningState, todo::Vector{Pair{Int, Any}})
     argtypes = sig.argtypes
     cases = InliningCase[]
-    local signature_union = Bottom
     local only_method = nothing  # keep track of whether there is one matching method
     local meth::MethodLookupResult
     local fully_covered = true
@@ -1180,6 +1179,7 @@ function analyze_single_call!(
             return nothing
         elseif length(meth) == 0
             # No applicable methods; try next union split
+            fully_covered = false
             continue
         else
             if length(meth) == 1 && only_method !== false
@@ -1193,8 +1193,8 @@ function analyze_single_call!(
             end
         end
         for match in meth
-            signature_union = Union{signature_union, match.spec_types}
             fully_covered &= handle_match!(match, argtypes, flag, state, cases)
+            fully_covered &= match.fully_covers
         end
     end
 
@@ -1214,8 +1214,6 @@ function analyze_single_call!(
         item === nothing && return nothing
         push!(cases, InliningCase(match.spec_types, item))
         fully_covered = match.fully_covers
-    else
-        fully_covered &= atype <: signature_union
     end
 
     handle_cases!(ir, idx, stmt, atype, cases, fully_covered, todo, state.params)
@@ -1230,7 +1228,6 @@ function handle_const_call!(
     infos = isa(call, MethodMatchInfo) ? MethodMatchInfo[call] : call.matches
     cases = InliningCase[]
     local fully_covered = true
-    local signature_union = Bottom
     local j = 0
     for i in 1:length(infos)
         meth = infos[i].results
@@ -1240,24 +1237,22 @@ function handle_const_call!(
             return nothing
         elseif length(meth) == 0
             # No applicable methods; try next union split
+            fully_covered = false
             continue
         end
         for match in meth
             j += 1
             result = results[j]
             if isa(result, ConstResult)
                 case = const_result_item(result, state)
-                signature_union = Union{signature_union, result.mi.specTypes}
                 push!(cases, InliningCase(result.mi.specTypes, case))
-                continue
             elseif isa(result, InferenceResult)
-                signature_union = Union{signature_union, result.linfo.specTypes}
                 fully_covered &= handle_inf_result!(result, argtypes, flag, state, cases)
             else
                 @assert result === nothing
-                signature_union = Union{signature_union, match.spec_types}
                 fully_covered &= handle_match!(match, argtypes, flag, state, cases)
             end
+            fully_covered &= match.fully_covers
         end
     end
 
@@ -1271,8 +1266,6 @@ function handle_const_call!(
         item === nothing && return nothing
         push!(cases, InliningCase(mi.specTypes, item))
         fully_covered = atype <: mi.specTypes
-    else
-        fully_covered &= atype <: signature_union
     end
 
     handle_cases!(ir, idx, stmt, atype, cases, fully_covered, todo, state.params)

base/compiler/types.jl

@@ -89,7 +89,7 @@ struct EffectsOverride
     consistent::Bool
     effect_free::Bool
     nothrow::Bool
-    terminates::Bool
+    terminates_globally::Bool
     terminates_locally::Bool
 end
 
@@ -98,7 +98,7 @@ function encode_effects_override(eo::EffectsOverride)
     eo.consistent && (e |= 0x01)
     eo.effect_free && (e |= 0x02)
     eo.nothrow && (e |= 0x04)
-    eo.terminates && (e |= 0x08)
+    eo.terminates_globally && (e |= 0x08)
     eo.terminates_locally && (e |= 0x10)
     e
 end