Revert "implement Memory{T} as a new backend for Array{T} (JuliaLang#51319)"

This reverts commit 909bcea.

Author: Drvi

base/Base.jl

@@ -6,19 +6,10 @@ using Core.Intrinsics, Core.IR
 
 # to start, we're going to use a very simple definition of `include`
 # that doesn't require any function (except what we can get from the `Core` top-module)
-# start this big so that we don't have to resize before we have defined how to grow an array
-const _included_files = Array{Tuple{Module,String},1}(Core.undef, 400)
-setfield!(_included_files, :size, (1,))
+const _included_files = Array{Tuple{Module,String},1}(Core.undef, 1)
 function include(mod::Module, path::String)
-    len = getfield(_included_files.size, 1)
-    memlen = _included_files.ref.mem.length
-    lenp1 = Core.add_int(len, 1)
-    if len === memlen # by the time this is true we hopefully will have defined _growend!
-        _growend!(_included_files, UInt(1))
-    else
-        setfield!(_included_files, :size, (lenp1,))
-    end
-    Core.memoryrefset!(Core.memoryref(_included_files.ref, lenp1), (mod, ccall(:jl_prepend_cwd, Any, (Any,), path)), :not_atomic, true)
+    ccall(:jl_array_grow_end, Cvoid, (Any, UInt), _included_files, UInt(1))
+    Core.arrayset(true, _included_files, (mod, ccall(:jl_prepend_cwd, Any, (Any,), path)), arraylen(_included_files))
     Core.println(path)
     ccall(:jl_uv_flush, Nothing, (Ptr{Nothing},), Core.io_pointer(Core.stdout))
     Core.include(mod, path)
@@ -40,7 +31,6 @@ macro noinline() Expr(:meta, :noinline) end
 getproperty(x::Module, f::Symbol) = (@inline; getglobal(x, f))
 getproperty(x::Type, f::Symbol) = (@inline; getfield(x, f))
 setproperty!(x::Type, f::Symbol, v) = error("setfield! fields of Types should not be changed")
-setproperty!(x::Array, f::Symbol, v) = error("setfield! fields of Array should not be changed")
 getproperty(x::Tuple, f::Int) = (@inline; getfield(x, f))
 setproperty!(x::Tuple, f::Int, v) = setfield!(x, f, v) # to get a decent error
 
@@ -202,22 +192,23 @@ include("strings/lazy.jl")
 
 # array structures
 include("indices.jl")
-include("genericmemory.jl")
 include("array.jl")
 include("abstractarray.jl")
 include("subarray.jl")
 include("views.jl")
 include("baseext.jl")
 
-include("c.jl")
 include("ntuple.jl")
+
 include("abstractdict.jl")
 include("iddict.jl")
 include("idset.jl")
+
 include("iterators.jl")
 using .Iterators: zip, enumerate, only
 using .Iterators: Flatten, Filter, product  # for generators
 using .Iterators: Stateful    # compat (was formerly used in reinterpretarray.jl)
+
 include("namedtuple.jl")
 
 # For OS specific stuff
@@ -233,17 +224,6 @@ function strcat(x::String, y::String)
 end
 include(strcat((length(Core.ARGS)>=2 ? Core.ARGS[2] : ""), "build_h.jl"))     # include($BUILDROOT/base/build_h.jl)
 include(strcat((length(Core.ARGS)>=2 ? Core.ARGS[2] : ""), "version_git.jl")) # include($BUILDROOT/base/version_git.jl)
-# Initialize DL_LOAD_PATH as early as possible.  We are defining things here in
-# a slightly more verbose fashion than usual, because we're running so early.
-const DL_LOAD_PATH = String[]
-let os = ccall(:jl_get_UNAME, Any, ())
-    if os === :Darwin || os === :Apple
-        if Base.DARWIN_FRAMEWORK
-            push!(DL_LOAD_PATH, "@loader_path/Frameworks")
-        end
-        push!(DL_LOAD_PATH, "@loader_path")
-    end
-end
 
 # numeric operations
 include("hashing.jl")
@@ -291,24 +271,24 @@ include("set.jl")
 
 # Strings
 include("char.jl")
-function array_new_memory(mem::Memory{UInt8}, newlen::Int)
-    # add an optimization to array_new_memory for StringVector
-    if (@assume_effects :total @ccall jl_genericmemory_owner(mem::Any,)::Any) isa String
-        # If data is in a String, keep it that way.
-        # When implemented, this could use jl_gc_expand_string(oldstr, newlen) as an optimization
-        str = _string_n(newlen)
-        return (@assume_effects :total !:consistent @ccall jl_string_to_genericmemory(str::Any,)::Memory{UInt8})
-    else
-        # TODO: when implemented, this should use a memory growing call
-        return typeof(mem)(undef, newlen)
-    end
-end
 include("strings/basic.jl")
 include("strings/string.jl")
 include("strings/substring.jl")
-include("strings/cstring.jl")
+
+# Initialize DL_LOAD_PATH as early as possible.  We are defining things here in
+# a slightly more verbose fashion than usual, because we're running so early.
+const DL_LOAD_PATH = String[]
+let os = ccall(:jl_get_UNAME, Any, ())
+    if os === :Darwin || os === :Apple
+        if Base.DARWIN_FRAMEWORK
+            push!(DL_LOAD_PATH, "@loader_path/Frameworks")
+        end
+        push!(DL_LOAD_PATH, "@loader_path")
+    end
+end
 
 include("osutils.jl")
+include("c.jl")
 
 # Core I/O
 include("io.jl")

base/abstractarray.jl

@@ -268,8 +268,8 @@ julia> ndims(A)
 3
 ```
 """
-ndims(::AbstractArray{T,N}) where {T,N} = N::Int
-ndims(::Type{<:AbstractArray{<:Any,N}}) where {N} = N::Int
+ndims(::AbstractArray{T,N}) where {T,N} = N
+ndims(::Type{<:AbstractArray{<:Any,N}}) where {N} = N
 ndims(::Type{Union{}}, slurp...) = throw(ArgumentError("Union{} does not have elements"))
 
 """
@@ -731,6 +731,8 @@ end
 checkbounds_indices(::Type{Bool}, IA::Tuple, ::Tuple{}) = (@inline; all(x->length(x)==1, IA))
 checkbounds_indices(::Type{Bool}, ::Tuple{}, ::Tuple{}) = true
 
+throw_boundserror(A, I) = (@noinline; throw(BoundsError(A, I)))
+
 # check along a single dimension
 """
     checkindex(Bool, inds::AbstractUnitRange, index)
@@ -1449,8 +1451,6 @@ function _setindex!(::IndexCartesian, A::AbstractArray, v, I::Vararg{Int,M}) whe
     r
 end
 
-_unsetindex!(A::AbstractArray, i::Integer) = _unsetindex!(A, to_index(i))
-
 """
     parent(A)
 
@@ -1556,8 +1556,7 @@ 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) = (B = ccall(:jl_genericmemory_owner, Any, (Any,), A); (UInt(pointer(B isa typeof(A) ? B : A)),))
-dataids(A::Array) = dataids(A.ref.mem)
+dataids(A::Array) = (UInt(pointer(A)),)
 dataids(::AbstractRange) = ()
 dataids(x) = ()