Fix some invalidations that occur during bootstrap

Author: timholy

base/Base.jl

@@ -129,6 +129,7 @@ include("abstractarraymath.jl")
 include("arraymath.jl")
 
 # SIMD loops
+@pure sizeof(s::String) = Core.sizeof(s)  # needed by gensym as called from simdloop
 include("simdloop.jl")
 using .SimdLoop
 

base/abstractarray.jl

@@ -1047,6 +1047,9 @@ function getindex(A::AbstractArray, I...)
     error_if_canonical_getindex(IndexStyle(A), A, I...)
     _getindex(IndexStyle(A), A, to_indices(A, I)...)
 end
+# To avoid invalidations from multidimensional.jl: getindex(A::Array, i1::Union{Integer, CartesianIndex}, I::Union{Integer, CartesianIndex}...)
+getindex(A::Array, i1::Integer, I::Integer...) = A[to_indices(A, (i1, I...))...]
+
 function unsafe_getindex(A::AbstractArray, I...)
     @_inline_meta
     @inbounds r = getindex(A, I...)
@@ -2150,7 +2153,7 @@ end
 # map on collections
 map(f, A::AbstractArray) = collect_similar(A, Generator(f,A))
 
-mapany(f, itr) = map!(f, Vector{Any}(undef, length(itr)), itr)  # convenient for Expr.args
+mapany(f, itr) = map!(f, Vector{Any}(undef, length(itr)::Int), itr)  # convenient for Expr.args
 
 # default to returning an Array for `map` on general iterators
 """

base/docs/Docs.jl

@@ -96,7 +96,7 @@ function signature!(tv, expr::Expr)
             push!(sig.args[end].args, argtype(arg))
         end
         if isexpr(expr.args[1], :curly) && isempty(tv)
-            append!(tv, mapany(tvar, expr.args[1].args[2:end]))
+            append!(tv, mapany(tvar, (expr.args[1]::Expr).args[2:end]))
         end
         for i = length(tv):-1:1
             push!(sig.args, :(Tuple{$(tv[i].args[1])}))

base/essentials.jl

@@ -172,6 +172,8 @@ convert(::Type{T}, x::T) where {T} = x
 convert(::Type{Type}, x::Type) = x # the ssair optimizer is strongly dependent on this method existing to avoid over-specialization
                                    # in the absence of inlining-enabled
                                    # (due to fields typed as `Type`, which is generally a bad idea)
+# These end up being called during bootstrap and then would be invalidated if not for the following:
+convert(::Type{String}, x::String) = x
 
 """
     @eval [mod,] ex

base/indices.jl

@@ -320,6 +320,10 @@ not all index types are guaranteed to propagate to `Base.to_index`.
 """
 to_indices(A, I::Tuple) = (@_inline_meta; to_indices(A, axes(A), I))
 to_indices(A, I::Tuple{Any}) = (@_inline_meta; to_indices(A, (eachindex(IndexLinear(), A),), I))
+# In simple cases, we know that we don't need to use axes(A), optimize those.
+# Having this here avoids invalidations from multidimensional.jl: to_indices(A, I::Tuple{Vararg{Union{Integer, CartesianIndex}}})
+to_indices(A, I::Tuple{}) = ()
+to_indices(A, I::Tuple{Vararg{Integer}}) = (@_inline_meta; to_indices(A, (), I))
 to_indices(A, inds, ::Tuple{}) = ()
 to_indices(A, inds, I::Tuple{Any, Vararg{Any}}) =
     (@_inline_meta; (to_index(A, I[1]), to_indices(A, _maybetail(inds), tail(I))...))

base/initdefs.jl

@@ -266,6 +266,9 @@ function active_project(search_load_path::Bool=true)
         project == "@" && continue
         project = load_path_expand(project)
         project === nothing && continue
+        # while this seems well-inferred, nevertheless without the type annotation below
+        # there are backedges here from abspath(::AbstractString, ::String)
+        project = project::String
         if !isfile_casesensitive(project) && basename(project) ∉ project_names
             project = abspath(project, "Project.toml")
         end

base/multidimensional.jl

@@ -701,7 +701,6 @@ ensure_indexable(I::Tuple{}) = ()
 
 # In simple cases, we know that we don't need to use axes(A). Optimize those
 # until Julia gets smart enough to elide the call on its own:
-to_indices(A, I::Tuple{}) = ()
 @inline to_indices(A, I::Tuple{Vararg{Union{Integer, CartesianIndex}}}) = to_indices(A, (), I)
 # But some index types require more context spanning multiple indices
 # CartesianIndexes are simple; they just splat out

base/shell.jl

@@ -17,7 +17,7 @@ end
 
 function shell_parse(str::AbstractString, interpolate::Bool=true;
                      special::AbstractString="")
-    s::SubString = SubString(str, firstindex(str))
+    s = SubString(str, firstindex(str))
     s = rstrip_shell(lstrip(s))
 
     # N.B.: This is used by REPLCompletions
@@ -33,23 +33,25 @@ function shell_parse(str::AbstractString, interpolate::Bool=true;
     st = Iterators.Stateful(pairs(s))
 
     function update_arg(x)
-        if !isa(x,AbstractString) || !isempty(x)
-            push!(arg, x)
+        let arg = arg
+            if !isa(x,AbstractString) || !isempty(x)
+                push!(arg, x)
+            end
         end
     end
-    function consume_upto(j)
+    function consume_upto(s, i, j)
         update_arg(s[i:prevind(s, j)])
-        i = something(peek(st), (lastindex(s)+1,'\0'))[1]
+        something(peek(st), (lastindex(s)+1,'\0'))[1]
     end
     function append_arg()
         if isempty(arg); arg = Any["",]; end
         push!(args, arg)
         arg = []
     end
 
-    for (j, c) in st
+    for (j::Int, c) in st
         if !in_single_quotes && !in_double_quotes && isspace(c)
-            consume_upto(j)
+            i = consume_upto(s, i, j)
             append_arg()
             while !isempty(st)
                 # We've made sure above that we don't end in whitespace,
@@ -59,7 +61,7 @@ function shell_parse(str::AbstractString, interpolate::Bool=true;
                 popfirst!(st)
             end
         elseif interpolate && !in_single_quotes && c == '$'
-            consume_upto(j)
+            i = consume_upto(s, i, j)
             isempty(st) && error("\$ right before end of command")
             stpos, c = popfirst!(st)
             isspace(c) && error("space not allowed right after \$")
@@ -79,21 +81,21 @@ function shell_parse(str::AbstractString, interpolate::Bool=true;
         else
             if !in_double_quotes && c == '\''
                 in_single_quotes = !in_single_quotes
-                consume_upto(j)
+                i = consume_upto(s, i, j)
             elseif !in_single_quotes && c == '"'
                 in_double_quotes = !in_double_quotes
-                consume_upto(j)
+                i = consume_upto(s, i, j)
             elseif c == '\\'
                 if in_double_quotes
                     isempty(st) && error("unterminated double quote")
                     k, c′ = peek(st)
                     if c′ == '"' || c′ == '$' || c′ == '\\'
-                        consume_upto(j)
+                        i = consume_upto(s, i, j)
                         _ = popfirst!(st)
                     end
                 elseif !in_single_quotes
                     isempty(st) && error("dangling backslash")
-                    consume_upto(j)
+                    i = consume_upto(s, i, j)
                     _ = popfirst!(st)
                 end
             elseif !in_single_quotes && !in_double_quotes && c in special

base/simdloop.jl

@@ -26,7 +26,7 @@ function check_body!(x::Expr)
     if x.head === :break || x.head === :continue
         throw(SimdError("$(x.head) is not allowed inside a @simd loop body"))
     elseif x.head === :macrocall && x.args[1] === Symbol("@goto")
-        throw(SimdError("$(x.args[1]) is not allowed inside a @simd loop body"))
+        throw(SimdError("@goto is not allowed inside a @simd loop body"))
     end
     for arg in x.args
         check_body!(arg)

base/strings/string.jl

@@ -95,7 +95,6 @@ pointer(s::String) = unsafe_convert(Ptr{UInt8}, s)
 pointer(s::String, i::Integer) = pointer(s)+(i-1)
 
 @pure ncodeunits(s::String) = Core.sizeof(s)
-@pure sizeof(s::String) = Core.sizeof(s)
 codeunit(s::String) = UInt8
 
 @inline function codeunit(s::String, i::Integer)