apply the constructing functions to some code under base/

Author: nsajko

base/abstractarray.jl

@@ -108,8 +108,8 @@ If multiple arguments are passed, equivalent to `has_offset_axes(A) || has_offse
 See also [`require_one_based_indexing`](@ref).
 """
 has_offset_axes() = false
-has_offset_axes(A) = _any_tuple(x->Int(first(x))::Int != 1, false, axes(A)...)
-has_offset_axes(A::AbstractVector) = Int(firstindex(A))::Int != 1 # improve performance of a common case (ranges)
+has_offset_axes(A) = _any_tuple(!=(1) ∘ _Int ∘ first, false, axes(A)...)
+has_offset_axes(A::AbstractVector) = _Int(firstindex(A)) != 1 # improve performance of a common case (ranges)
 has_offset_axes(::Colon) = false
 has_offset_axes(::Array) = false
 # note: this could call `any` directly if the compiler can infer it. We don't use _any_tuple
@@ -212,8 +212,8 @@ String
 """
 valtype(A::Type{<:AbstractArray}) = eltype(A)
 
-prevind(::AbstractArray, i::Integer) = Int(i)-1
-nextind(::AbstractArray, i::Integer) = Int(i)+1
+prevind(::AbstractArray, i::Integer) = _Int(i)-1
+nextind(::AbstractArray, i::Integer) = _Int(i)+1
 
 
 """
@@ -838,10 +838,10 @@ to_shape(dims::Dims) = dims
 to_shape(dims::DimsOrInds) = map(to_shape, dims)::DimsOrInds
 # each dimension
 to_shape(i::Int) = i
-to_shape(i::Integer) = Int(i)
+to_shape(i::Integer) = _Int(i)
 to_shape(r::AbstractOneTo) = _to_shape(last(r))
 _to_shape(x::Integer) = to_shape(x)
-_to_shape(x) = Int(x)
+_to_shape(x) = _Int(x)
 to_shape(r::AbstractUnitRange) = r
 
 """
@@ -951,7 +951,7 @@ function copyto!(dest::AbstractArray, src)
 end
 
 function copyto!(dest::AbstractArray, dstart::Integer, src)
-    i = Int(dstart)
+    i = _Int(dstart)
     if haslength(src) && length(dest) > 0
         @boundscheck checkbounds(dest, i:(i + length(src) - 1))
         for x in src
@@ -986,7 +986,7 @@ function copyto!(dest::AbstractArray, dstart::Integer, src, sstart::Integer)
             "source has fewer elements than required, ",
             "expected at least ",sstart," got ", sstart-1)))
     end
-    i = Int(dstart)
+    i = _Int(dstart)
     while y !== nothing
         val, st = y
         dest[i] = val
@@ -1023,7 +1023,7 @@ function copyto!(dest::AbstractArray, dstart::Integer, src, sstart::Integer, n::
             "expected at least ",sstart," got ", sstart-1)))
     end
     val, st = y
-    i = Int(dstart)
+    i = _Int(dstart)
     @inbounds dest[i] = val
     for val in Iterators.take(Iterators.rest(src, st), n-1)
         i += 1
@@ -1269,7 +1269,7 @@ end
 pointer(x::AbstractArray{T}) where {T} = unsafe_convert(Ptr{T}, cconvert(Ptr{T}, x))
 function pointer(x::AbstractArray{T}, i::Integer) where T
     @inline
-    pointer(x) + Int(_memory_offset(x, i))::Int
+    pointer(x) + _Int(_memory_offset(x, i))::Int
 end
 
 # The distance from pointer(x) to the element at x[I...] in bytes
@@ -1601,8 +1601,8 @@ parts can specialize this method to return the concatenation of the `dataids` of
 their component parts.  A typical definition for an array that wraps a parent is
 `Base.dataids(C::CustomArray) = dataids(C.parent)`.
 """
-dataids(A::AbstractArray) = (UInt(objectid(A)),)
-dataids(A::Memory) = (UInt(A.ptr),)
+dataids(A::AbstractArray) = (_UInt(objectid(A)),)
+dataids(A::Memory) = (_UInt(A.ptr),)
 dataids(A::Array) = dataids(A.ref.mem)
 dataids(::AbstractRange) = ()
 dataids(x) = ()
@@ -1702,9 +1702,9 @@ _typed_vcat(::Type{T}, V::AbstractVecOrTuple{AbstractVector}) where T =
 
 function _typed_vcat!(a::AbstractVector{T}, V::AbstractVecOrTuple{AbstractVector}) where T
     pos = 1
-    for k=1:Int(length(V))::Int
+    for k=1:_Int(length(V))::Int
         Vk = V[k]
-        p1 = pos + Int(length(Vk))::Int - 1
+        p1 = pos + _Int(length(Vk))::Int - 1
         a[pos:p1] = Vk
         pos = p1+1
     end

base/abstractarraymath.jl

@@ -91,7 +91,7 @@ function _dropdims(A::AbstractArray, dims::Dims)
     ax = _foldoneto((ds, d) -> d in dims ? ds : (ds..., axes(A,d)), (), Val(ndims(A)))
     reshape(A, ax::typeof(_sub(axes(A), dims)))
 end
-_dropdims(A::AbstractArray, dim::Integer) = _dropdims(A, (Int(dim),))
+_dropdims(A::AbstractArray, dim::Integer) = _dropdims(A, (_Int(dim),))
 
 
 """
@@ -153,7 +153,7 @@ function _insertdims(A::AbstractArray{T, N}, dims::NTuple{M, Int}) where {T, N,
     new_shape = inds[1]
     return reshape(A, new_shape)
 end
-_insertdims(A::AbstractArray, dim::Integer) = _insertdims(A, (Int(dim),))
+_insertdims(A::AbstractArray, dim::Integer) = _insertdims(A, (_Int(dim),))
 
 
 

base/abstractset.jl

@@ -101,7 +101,7 @@ max_values(::Type{Bool}) = 2
 max_values(::Type{Nothing}) = 1
 
 function union!(s::AbstractSet{T}, itr) where T
-    haslength(itr) && sizehint!(s, length(s) + Int(length(itr))::Int; shrink = false)
+    haslength(itr) && sizehint!(s, length(s) + _Int(length(itr)); shrink = false)
     for x in itr
         push!(s, x)
         length(s) == max_values(T) && break

base/array.jl

@@ -185,7 +185,7 @@ function vect(X...)
     return T[X...]
 end
 
-size(a::Array, d::Integer) = size(a, Int(d)::Int)
+size(a::Array, d::Integer) = size(a, _Int(d))
 function size(a::Array, d::Int)
     d < 1 && error("arraysize: dimension out of range")
     sz = getfield(a, :size)
@@ -672,7 +672,7 @@ _similar_for(c::AbstractArray, ::Type{T}, itr, ::HasShape, axs) where {T} =
 
 # make a collection appropriate for collecting `itr::Generator`
 _array_for(::Type{T}, ::SizeUnknown, ::Nothing) where {T} = Vector{T}(undef, 0)
-_array_for(::Type{T}, ::HasLength, len::Integer) where {T} = Vector{T}(undef, Int(len))
+_array_for(::Type{T}, ::HasLength, len::Integer) where {T} = Vector{T}(undef, _Int(len))
 _array_for(::Type{T}, ::HasShape{N}, axs) where {T,N} = similar(Array{T,N}, axs)
 
 # used by syntax lowering for simple typed comprehensions
@@ -1112,7 +1112,7 @@ end
 
 function _growbeg!(a::Vector, delta::Integer)
     @_noub_meta
-    delta = Int(delta)
+    delta = _Int(delta)
     delta == 0 && return # avoid attempting to index off the end
     delta >= 0 || throw(ArgumentError("grow requires delta >= 0"))
     ref = a.ref
@@ -1167,7 +1167,7 @@ end
 
 function _growend!(a::Vector, delta::Integer)
     @_noub_meta
-    delta = Int(delta)
+    delta = _Int(delta)
     delta >= 0 || throw(ArgumentError("grow requires delta >= 0"))
     ref = a.ref
     mem = ref.mem
@@ -1185,8 +1185,8 @@ end
 
 function _growat!(a::Vector, i::Integer, delta::Integer)
     @_terminates_globally_noub_meta
-    delta = Int(delta)
-    i = Int(i)
+    delta = _Int(delta)
+    i = _Int(i)
     i == 1 && return _growbeg!(a, delta)
     len = length(a)
     i == len + 1 && return _growend!(a, delta)
@@ -1230,7 +1230,7 @@ end
 
 # efficiently delete part of an array
 function _deletebeg!(a::Vector, delta::Integer)
-    delta = Int(delta)
+    delta = _Int(delta)
     len = length(a)
     0 <= delta <= len || throw(ArgumentError("_deletebeg! requires delta in 0:length(a)"))
     for i in 1:delta
@@ -1245,7 +1245,7 @@ function _deletebeg!(a::Vector, delta::Integer)
     return
 end
 function _deleteend!(a::Vector, delta::Integer)
-    delta = Int(delta)
+    delta = _Int(delta)
     len = length(a)
     0 <= delta <= len || throw(ArgumentError("_deleteend! requires delta in 0:length(a)"))
     newlen = len - delta
@@ -1256,7 +1256,7 @@ function _deleteend!(a::Vector, delta::Integer)
     return
 end
 function _deleteat!(a::Vector, i::Integer, delta::Integer)
-    i = Int(i)
+    i = _Int(i)
     len = length(a)
     0 <= delta || throw(ArgumentError("_deleteat! requires delta >= 0"))
     1 <= i <= len || throw(BoundsError(a, i))
@@ -1372,7 +1372,7 @@ function append! end
 
 function append!(a::Vector{T}, items::Union{AbstractVector{<:T},Tuple}) where T
     items isa Tuple && (items = map(x -> convert(T, x), items))
-    n = Int(length(items))::Int
+    n = _Int(length(items))
     _growend!(a, n)
     copyto!(a, length(a)-n+1, items, firstindex(items), n)
     return a
@@ -1383,7 +1383,7 @@ push!(a::AbstractVector, iter...) = append!(a, iter)
 append!(a::AbstractVector, iter...) = (foreach(v -> append!(a, v), iter); a)
 
 function _append!(a::AbstractVector, ::Union{HasLength,HasShape}, iter)
-    n = Int(length(iter))::Int
+    n = _Int(length(iter))
     i = lastindex(a)
     sizehint!(a, length(a) + n; shrink=false)
     for item in iter
@@ -1446,7 +1446,7 @@ prepend!(a::AbstractVector, iter...) = (for v = reverse(iter); prepend!(a, v); e
 function _prepend!(a::Vector, ::Union{HasLength,HasShape}, iter)
     @_terminates_locally_meta
     require_one_based_indexing(a)
-    n = Int(length(iter))::Int
+    n = _Int(length(iter))
     sizehint!(a, length(a) + n; first=true, shrink=false)
     n = 0
     for item in iter
@@ -1497,7 +1497,7 @@ julia> a[1:6]
 ```
 """
 function resize!(a::Vector, nl_::Integer)
-    nl = Int(nl_)::Int
+    nl = _Int(nl_)
     l = length(a)
     if nl > l
         _growend!(a, nl-l)
@@ -1551,7 +1551,7 @@ function sizehint!(a::Vector, sz::Integer; first::Bool=false, shrink::Bool=true)
     ref = a.ref
     mem = ref.mem
     memlen = length(mem)
-    sz = max(Int(sz), len)
+    sz = max(_Int(sz), len)
     inc = sz - len
     if sz <= memlen
         # if we don't save at least 1/8th memlen then its not worth it to shrink
@@ -2185,7 +2185,7 @@ julia> reverse(A, 3, 5)
 ```
 """
 function reverse(A::AbstractVector, start::Integer, stop::Integer=lastindex(A))
-    s, n = Int(start), Int(stop)
+    s, n = _Int(start), _Int(stop)
     B = similar(A)
     for i = firstindex(A):s-1
         B[i] = A[i]
@@ -2249,7 +2249,7 @@ julia> A
 ```
 """
 function reverse!(v::AbstractVector, start::Integer, stop::Integer=lastindex(v))
-    s, n = Int(start), Int(stop)
+    s, n = _Int(start), _Int(stop)
     if n > s # non-empty and non-trivial
         liv = LinearIndices(v)
         if !(first(liv) ≤ s ≤ last(liv))
@@ -3196,12 +3196,12 @@ end
     $(Expr(:new, :(Array{T, N}), :ref, :dims))
 end
 @eval @propagate_inbounds function wrap(::Type{Array}, m::MemoryRef{T}, l::Integer) where {T}
-    dims = (Int(l),)
+    dims = (_Int(l),)
     ref = _wrap(m, dims)
     $(Expr(:new, :(Array{T, 1}), :ref, :dims))
 end
 @eval @propagate_inbounds function wrap(::Type{Array}, m::Memory{T}, l::Integer) where {T}
-    dims = (Int(l),)
+    dims = (_Int(l),)
     ref = _wrap(memoryref(m), (l,))
     $(Expr(:new, :(Array{T, 1}), :ref, :dims))
 end

base/arraymath.jl

@@ -69,7 +69,7 @@ Like [`reverse`](@ref), but operates in-place in `A`.
 """
 reverse!(A::AbstractArray; dims=:) = _reverse!(A, dims)
 _reverse!(A::AbstractArray{<:Any,N}, ::Colon) where {N} = _reverse!(A, ntuple(identity, Val{N}()))
-_reverse!(A, dim::Integer) = _reverse!(A, (Int(dim),))
+_reverse!(A, dim::Integer) = _reverse!(A, (_Int(dim),))
 _reverse!(A, dims::NTuple{M,Integer}) where {M} = _reverse!(A, Int.(dims))
 function _reverse!(A::AbstractArray{<:Any,N}, dims::NTuple{M,Int}) where {N,M}
     dims === () && return A # nothing to reverse

base/arrayshow.jl

@@ -172,7 +172,7 @@ function print_matrix(io::IO, X::AbstractVecOrMat,
 end
 
 function _print_matrix(io, @nospecialize(X::AbstractVecOrMat), pre, sep, post, hdots, vdots, ddots, hmod, vmod, rowsA, colsA)
-    hmod, vmod = Int(hmod)::Int, Int(vmod)::Int
+    hmod, vmod = _Int(hmod), _Int(vmod)
     ncols, idxlast = length(colsA), last(colsA)
     if !(get(io, :limit, false)::Bool)
         screenheight = screenwidth = typemax(Int)

base/binaryplatforms.jl

@@ -8,6 +8,7 @@ export AbstractPlatform, Platform, HostPlatform, platform_dlext, tags, arch, os,
        detect_libstdcxx_version, detect_cxxstring_abi, call_abi, wordsize, triplet,
        select_platform, platforms_match, platform_name
 import .Libc.Libdl
+using .._ConstructingFunctions
 
 ### Submodule with information about CPU features
 include("cpuid.jl")
@@ -116,7 +117,7 @@ function Platform(arch::String, os::String;
                   validate_strict::Bool = false,
                   compare_strategies::Dict{String,<:Function} = Dict{String,Function}(),
                   kwargs...)
-    tags = Dict{String,Any}(String(tag)::String=>tagvalue(value) for (tag, value) in kwargs)
+    tags = Dict{String,Any}(_String(tag)=>tagvalue(value) for (tag, value) in kwargs)
     return Platform(arch, os, tags; validate_strict, compare_strategies)
 end
 
@@ -740,7 +741,7 @@ function Base.parse(::Type{Platform}, triplet::String; validate_strict::Bool = f
             if isempty(tag_fields)
                 return Pair{String,String}[]
             end
-            return map(v -> String(v[1]) => String(v[2]), split.(tag_fields, "+"))
+            return map(v -> _String(v[1]) => _String(v[2]), split.(tag_fields, "+"))
         end
         merge!(tags, Dict(split_tags(m["tags"])))