prevent stack overflows from faulty user-defined constructor methods (#59506)

`Base` code often assumes that a constructor will return a value of the
stated type. This is false, cross-reference issue #42372.

This change prevents several stack overflows that arise when a generic
method is called with a newly-defined type with such a weird constructor
for some `Base`-defined type.

Author: nsajko

base/char.jl

@@ -47,7 +47,7 @@ represents a valid Unicode character.
 """
 Char
 
-@constprop :aggressive (::Type{T})(x::Number) where {T<:AbstractChar} = T(UInt32(x))
+@constprop :aggressive (::Type{T})(x::Number) where {T<:AbstractChar} = T(UInt32(x)::UInt32)
 @constprop :aggressive AbstractChar(x::Number) = Char(x)
 @constprop :aggressive (::Type{T})(x::AbstractChar) where {T<:Union{Number,AbstractChar}} = T(codepoint(x))
 @constprop :aggressive (::Type{T})(x::AbstractChar) where {T<:Union{Int32,Int64}} = codepoint(x) % T
@@ -225,9 +225,9 @@ hash(x::Char, h::UInt) =
     hash_finalizer(((bitcast(UInt32, x) + UInt64(0xd4d64234)) << 32) ⊻ UInt64(h)) % UInt
 
 # fallbacks:
-isless(x::AbstractChar, y::AbstractChar) = isless(Char(x), Char(y))
-==(x::AbstractChar, y::AbstractChar) = Char(x) == Char(y)
-hash(x::AbstractChar, h::UInt) = hash(Char(x), h)
+isless(x::AbstractChar, y::AbstractChar) = isless(Char(x)::Char, Char(y)::Char)
+==(x::AbstractChar, y::AbstractChar) = Char(x)::Char == Char(y)::Char
+hash(x::AbstractChar, h::UInt) = hash(Char(x)::Char, h)
 widen(::Type{T}) where {T<:AbstractChar} = T
 
 @inline -(x::AbstractChar, y::AbstractChar) = Int(x) - Int(y)
@@ -257,7 +257,7 @@ end
 # (Packages may implement other IO subtypes to specify different encodings.)
 # In contrast, `write(io, c)` outputs a `c` in an encoding determined by typeof(c).
 print(io::IO, c::Char) = (write(io, c); nothing)
-print(io::IO, c::AbstractChar) = print(io, Char(c)) # fallback: convert to output UTF-8
+print(io::IO, c::AbstractChar) = print(io, Char(c)::Char) # fallback: convert to output UTF-8
 
 const hex_chars = UInt8['0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
                         'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i',

base/filesystem.jl

@@ -390,7 +390,7 @@ function isexecutable(path::String)
     X_OK = 0x01
     return ccall(:jl_fs_access, Cint, (Cstring, Cint), path, X_OK) == 0
 end
-isexecutable(path::AbstractString) = isexecutable(String(path))
+isexecutable(path::AbstractString) = isexecutable(String(path)::String)
 
 """
     isreadable(path::String)
@@ -417,7 +417,7 @@ function isreadable(path::String)
     R_OK = 0x04
     return ccall(:jl_fs_access, Cint, (Cstring, Cint), path, R_OK) == 0
 end
-isreadable(path::AbstractString) = isreadable(String(path))
+isreadable(path::AbstractString) = isreadable(String(path)::String)
 
 """
     iswritable(path::String)
@@ -444,7 +444,7 @@ function iswritable(path::String)
     W_OK = 0x02
     return ccall(:jl_fs_access, Cint, (Cstring, Cint), path, W_OK) == 0
 end
-iswritable(path::AbstractString) = iswritable(String(path))
+iswritable(path::AbstractString) = iswritable(String(path)::String)
 
 
 end

base/iobuffer.jl

@@ -953,7 +953,7 @@ end
     return sizeof(UInt8)
 end
 
-readbytes!(io::GenericIOBuffer, b::MutableDenseArrayType{UInt8}, nb=length(b)) = readbytes!(io, b, Int(nb))
+readbytes!(io::GenericIOBuffer, b::MutableDenseArrayType{UInt8}, nb=length(b)) = readbytes!(io, b, Int(nb)::Int)
 
 function readbytes!(io::GenericIOBuffer, b::MutableDenseArrayType{UInt8}, nb::Int)
     io.readable || _throw_not_readable()

base/parse.jl

@@ -299,7 +299,7 @@ function tryparse_internal(::Type{Float32}, s::SubString{String}, startpos::Int,
                           (Ptr{UInt8},Csize_t,Csize_t), s.string, s.offset+startpos-1, endpos-startpos+1)
     hasvalue ? val : nothing
 end
-tryparse(::Type{T}, s::AbstractString) where {T<:Union{Float32,Float64}} = tryparse(T, String(s))
+tryparse(::Type{T}, s::AbstractString) where {T<:Union{Float32,Float64}} = tryparse(T, String(s)::String)
 tryparse(::Type{Float16}, s::AbstractString) =
     convert(Union{Float16, Nothing}, tryparse(Float32, s))
 tryparse_internal(::Type{Float16}, s::AbstractString, startpos::Int, endpos::Int) =

base/path.jl

@@ -253,7 +253,7 @@ julia> splitpath("/home/myuser/example.jl")
  "example.jl"
 ```
 """
-splitpath(p::AbstractString) = splitpath(String(p))
+splitpath(p::AbstractString) = splitpath(String(p)::String)
 
 function splitpath(p::String)
     drive, p = splitdrive(p)
@@ -608,10 +608,10 @@ function relpath(path::String, startpath::String = ".")
     return isempty(relpath_) ? curdir :  relpath_
 end
 relpath(path::AbstractString, startpath::AbstractString) =
-    relpath(String(path), String(startpath))
+    relpath(String(path)::String, String(startpath)::String)
 
 for f in (:isdirpath, :splitdir, :splitdrive, :splitext, :normpath, :abspath)
-    @eval $f(path::AbstractString) = $f(String(path))
+    @eval $f(path::AbstractString) = $f(String(path)::String)
 end
 
 # RFC3986 Section 2.1
@@ -665,4 +665,4 @@ else
     end
 end
 
-uripath(path::AbstractString) = uripath(String(path))
+uripath(path::AbstractString) = uripath(String(path)::String)

base/stat.jl

@@ -380,7 +380,7 @@ function ispath(path::String)
     end
     return r == 0
 end
-ispath(path::AbstractString) = ispath(String(path))
+ispath(path::AbstractString) = ispath(String(path)::String)
 
 """
     isfifo(path)::Bool

base/strings/basic.jl

@@ -221,7 +221,7 @@ Vector{UInt8}(s::AbstractString) = unsafe_wrap(Vector{UInt8}, String(s))
 Array{UInt8}(s::AbstractString) = unsafe_wrap(Vector{UInt8}, String(s))
 Vector{T}(s::AbstractString) where {T<:AbstractChar} = collect(T, s)
 
-Symbol(s::AbstractString) = Symbol(String(s))
+Symbol(s::AbstractString) = Symbol(String(s)::String)
 Symbol(x...) = Symbol(string(x...))
 
 convert(::Type{T}, s::T) where {T<:AbstractString} = s
@@ -364,7 +364,7 @@ isless(a::Symbol, b::Symbol) = cmp(a, b) < 0
 
 # hashing
 
-hash(s::AbstractString, h::UInt) = hash(String(s), h)
+hash(s::AbstractString, h::UInt) = hash(String(s)::String, h)
 
 ## character index arithmetic ##
 
@@ -412,7 +412,7 @@ function length(s::AbstractString, i::Int, j::Int)
 end
 
 @propagate_inbounds length(s::AbstractString, i::Integer, j::Integer) =
-    length(s, Int(i), Int(j))
+    length(s, Int(i)::Int, Int(j)::Int)
 
 """
     thisind(s::AbstractString, i::Integer)::Int
@@ -446,7 +446,7 @@ ERROR: BoundsError: attempt to access 2-codeunit String at index [-1]
 [...]
 ```
 """
-thisind(s::AbstractString, i::Integer) = thisind(s, Int(i))
+thisind(s::AbstractString, i::Integer) = thisind(s, Int(i)::Int)
 
 function thisind(s::AbstractString, i::Int)
     z = ncodeunits(s)::Int + 1
@@ -502,8 +502,8 @@ julia> prevind("α", 2, 3)
 -1
 ```
 """
-prevind(s::AbstractString, i::Integer, n::Integer) = prevind(s, Int(i), Int(n))
-prevind(s::AbstractString, i::Integer)             = prevind(s, Int(i))
+prevind(s::AbstractString, i::Integer, n::Integer) = prevind(s, Int(i)::Int, Int(n)::Int)
+prevind(s::AbstractString, i::Integer)             = prevind(s, Int(i)::Int)
 prevind(s::AbstractString, i::Int)                 = prevind(s, i, 1)
 
 function prevind(s::AbstractString, i::Int, n::Int)
@@ -561,8 +561,8 @@ julia> nextind("α", 1, 2)
 4
 ```
 """
-nextind(s::AbstractString, i::Integer, n::Integer) = nextind(s, Int(i), Int(n))
-nextind(s::AbstractString, i::Integer)             = nextind(s, Int(i))
+nextind(s::AbstractString, i::Integer, n::Integer) = nextind(s, Int(i)::Int, Int(n)::Int)
+nextind(s::AbstractString, i::Integer)             = nextind(s, Int(i)::Int)
 nextind(s::AbstractString, i::Int)                 = nextind(s, i, 1)
 
 function nextind(s::AbstractString, i::Int, n::Int)
@@ -757,7 +757,7 @@ julia> repeat("ha", 3)
 "hahaha"
 ```
 """
-repeat(s::AbstractString, r::Integer) = repeat(String(s), r)
+repeat(s::AbstractString, r::Integer) = repeat(String(s)::String, r)
 
 """
     ^(s::Union{AbstractString,AbstractChar}, n::Integer)::AbstractString

base/strings/string.jl

@@ -158,7 +158,7 @@ pointer(s::String, i::Integer) = pointer(s) + Int(i)::Int - 1
 ncodeunits(s::String) = Core.sizeof(s)
 codeunit(s::String) = UInt8
 
-codeunit(s::String, i::Integer) = codeunit(s, Int(i))
+codeunit(s::String, i::Integer) = codeunit(s, Int(i)::Int)
 @assume_effects :foldable @inline function codeunit(s::String, i::Int)
     @boundscheck checkbounds(s, i)
     b = GC.@preserve s unsafe_load(pointer(s, i))

base/strings/substring.jl

@@ -48,7 +48,7 @@ end
 
 @propagate_inbounds SubString(s::T, i::Int, j::Int) where {T<:AbstractString} = SubString{T}(s, i, j)
 @propagate_inbounds SubString(s::T, i::Int, j::Int, v::Val{:noshift}) where {T<:AbstractString} = SubString{T}(s, i, j, v)
-@propagate_inbounds SubString(s::AbstractString, i::Integer, j::Integer=lastindex(s)) = SubString(s, Int(i), Int(j))
+@propagate_inbounds SubString(s::AbstractString, i::Integer, j::Integer=lastindex(s)) = SubString(s, Int(i)::Int, Int(j)::Int)
 @propagate_inbounds SubString(s::AbstractString, r::AbstractUnitRange{<:Integer}) = SubString(s, first(r), last(r))
 
 @propagate_inbounds function SubString(s::SubString, i::Int, j::Int)

base/strings/unicode.jl

@@ -191,7 +191,7 @@ const _julia_charmap = Dict{UInt32,UInt32}(
     0x210F => 0x0127, # hbar -> small letter h with stroke (#48870)
 )
 
-utf8proc_map(s::AbstractString, flags::Integer, chartransform::F = identity) where F = utf8proc_map(String(s), flags, chartransform)
+utf8proc_map(s::AbstractString, flags::Integer, chartransform::F = identity) where F = utf8proc_map(String(s)::String, flags, chartransform)
 
 # Documented in Unicode module
 function normalize(