Merge branch 'master' into interactive-utils-functors

Author: serenity4

Compiler/src/ssair/show.jl

@@ -105,11 +105,30 @@ function print_stmt(io::IO, idx::Int, @nospecialize(stmt), code::Union{IRCode,Co
             printstyled(io, "dynamic invoke "; color = :yellow)
             abi = (ci::Core.MethodInstance).specTypes
         end
-        show_unquoted(io, stmt.args[2], indent)
-        print(io, "(")
         # XXX: this is wrong if `sig` is not a concretetype method
         # more correct would be to use `fieldtype(sig, i)`, but that would obscure / discard Varargs information in show
         sig = abi == Tuple ? Core.svec() : Base.unwrap_unionall(abi).parameters::Core.SimpleVector
+        f = stmt.args[2]
+        ft = maybe_argextype(f, code, sptypes)
+
+        # We can elide the type for arg0 if it...
+        skip_ftype = (length(sig) == 0) # doesn't exist...
+        skip_ftype = skip_ftype || (
+            # ... or, f prints as a user-accessible value...
+            (f isa GlobalRef) &&
+            # ... and matches the value of the singleton type of the invoked MethodInstance
+            (singleton_type(ft) === singleton_type(sig[1]) !== nothing)
+        )
+        if skip_ftype
+            show_unquoted(io, f, indent)
+        else
+            print(io, "(")
+            show_unquoted(io, f, indent)
+            print(io, "::", sig[1], ")")
+        end
+
+        # Print the remaining arguments (with type annotations from the invoked MethodInstance)
+        print(io, "(")
         print_arg(i) = sprint(; context=io) do io
             show_unquoted(io, stmt.args[i], indent)
             if (i - 1) <= length(sig)

base/combinatorics.jl

@@ -184,13 +184,12 @@ end
 """
     permute!(v, p)
 
-Permute vector `v` in-place, according to permutation `p`. No checking is done
-to verify that `p` is a permutation.
+Permute vector `v` according to permutation `p`, storing the result back into `v`.
+No checking is done to verify that `p` is a permutation.
 
 To return a new permutation, use `v[p]`. This is generally faster than `permute!(v, p)`;
 it is even faster to write into a pre-allocated output array with `u .= @view v[p]`.
-(Even though `permute!` overwrites `v` in-place, it internally requires some allocation
-to keep track of which elements have been moved.)
+(Even though `permute!` overwrites `v` in-place, it internally requires some allocation.)
 
 $(_DOCS_ALIASING_WARNING)
 

base/iterators.jl

@@ -1239,20 +1239,48 @@ flatten_length(f, T) = throw(ArgumentError(
 length(f::Flatten{I}) where {I} = flatten_length(f, eltype(I))
 length(f::Flatten{Tuple{}}) = 0
 
-@propagate_inbounds function iterate(f::Flatten, state=())
-    if state !== ()
-        y = iterate(tail(state)...)
-        y !== nothing && return (y[1], (state[1], state[2], y[2]))
+@propagate_inbounds function iterate(fl::Flatten)
+    it_result = iterate(fl.it)
+    it_result === nothing && return nothing
+
+    inner_iterator, next_outer_state = it_result
+    inner_it_result = iterate(inner_iterator)
+
+    while inner_it_result === nothing
+        it_result = iterate(fl.it, next_outer_state)
+        it_result === nothing && return nothing
+
+        inner_iterator, next_outer_state = it_result
+        inner_it_result = iterate(inner_iterator)
     end
-    x = (state === () ? iterate(f.it) : iterate(f.it, state[1]))
-    x === nothing && return nothing
-    y = iterate(x[1])
-    while y === nothing
-         x = iterate(f.it, x[2])
-         x === nothing && return nothing
-         y = iterate(x[1])
+
+    item, next_inner_state = inner_it_result
+    return item, (next_outer_state, inner_iterator, next_inner_state)
+end
+
+@propagate_inbounds function iterate(fl::Flatten, state)
+    next_outer_state, inner_iterator, next_inner_state = state
+
+    # try to advance the inner iterator
+    inner_it_result = iterate(inner_iterator, next_inner_state)
+    if inner_it_result !== nothing
+        item, next_inner_state = inner_it_result
+        return item, (next_outer_state, inner_iterator, next_inner_state)
+    end
+
+    # advance the outer iterator
+    while true
+        outer_it_result = iterate(fl.it, next_outer_state)
+        outer_it_result === nothing && return nothing
+
+        inner_iterator, next_outer_state = outer_it_result
+        inner_it_result = iterate(inner_iterator)
+
+        if inner_it_result !== nothing
+            item, next_inner_state = inner_it_result
+            return item, (next_outer_state, inner_iterator, next_inner_state)
+        end
     end
-    return y[1], (x[2], x[1], y[2])
 end
 
 reverse(f::Flatten) = Flatten(reverse(itr) for itr in reverse(f.it))

doc/src/manual/functions.md

@@ -178,7 +178,7 @@ julia> function hypot(x, y)
                return x*sqrt(1 + r*r)
            end
            if y == 0
-               return x
+               return float(x)
            end
            r = x/y
            return y*sqrt(1 + r*r)

doc/src/manual/profile.md

@@ -562,8 +562,7 @@ Passing `sample_rate=1.0` will make it record everything (which is slow);
 
     Since Julia 1.11, all allocations should have a type reported.
 
-For more details on how to use this tool, please see the following talk from JuliaCon 2022:
-https://www.youtube.com/watch?v=BFvpwC8hEWQ
+For more details on how to use this tool, please see [the talk from JuliaCon 2022](https://www.youtube.com/watch?v=BFvpwC8hEWQ).
 
 ##### Allocation Profiler Example
 

stdlib/Markdown/src/GitHub/table.jl

@@ -1,6 +1,6 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
 
-mutable struct Table
+mutable struct Table <: MarkdownElement
     rows::Vector{Vector{Any}}
     align::Vector{Symbol}
 end

stdlib/Markdown/src/IPython/IPython.jl

@@ -1,6 +1,6 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
 
-mutable struct LaTeX
+mutable struct LaTeX <: MarkdownElement
     formula::String
 end