move growend_internal! and growbeg_internal! out to proper functions (#58211)

@gbaraldi has told me that this leads to a better calling convention
(and is clearer to read)

Author: oscardssmith

base/array.jl

@@ -1066,6 +1066,41 @@ end
 
 array_new_memory(mem::Memory, newlen::Int) = typeof(mem)(undef, newlen) # when implemented, this should attempt to first expand mem
 
+function _growbeg_internal!(a::Vector, delta::Int, len::Int)
+    @_terminates_locally_meta
+    ref = a.ref
+    mem = ref.mem
+    offset = memoryrefoffset(ref)
+    newlen = len + delta
+    memlen = length(mem)
+    if offset + len - 1 > memlen || offset < 1
+        throw(ConcurrencyViolationError("Vector has invalid state. Don't modify internal fields incorrectly, or resize without correct locks"))
+    end
+    # since we will allocate the array in the middle of the memory we need at least 2*delta extra space
+    # the +1 is because I didn't want to have an off by 1 error.
+    newmemlen = max(overallocation(len), len + 2 * delta + 1)
+    newoffset = div(newmemlen - newlen, 2) + 1
+    # If there is extra data after the end of the array we can use that space so long as there is enough
+    # space at the end that there won't be quadratic behavior with a mix of growth from both ends.
+    # Specifically, we want to ensure that we will only do this operation once before
+    # increasing the size of the array, and that we leave enough space at both the beginning and the end.
+    if newoffset + newlen < memlen
+        newoffset = div(memlen - newlen, 2) + 1
+        newmem = mem
+        unsafe_copyto!(newmem, newoffset + delta, mem, offset, len)
+        for j in offset:newoffset+delta-1
+            @inbounds _unsetindex!(mem, j)
+        end
+    else
+        newmem = array_new_memory(mem, newmemlen)
+        unsafe_copyto!(newmem, newoffset + delta, mem, offset, len)
+    end
+    if ref !== a.ref
+        throw(ConcurrencyViolationError("Vector can not be resized concurrently"))
+    end
+    setfield!(a, :ref, @inbounds memoryref(newmem, newoffset))
+end
+
 function _growbeg!(a::Vector, delta::Integer)
     @_noub_meta
     delta = Int(delta)
@@ -1081,40 +1116,46 @@ function _growbeg!(a::Vector, delta::Integer)
     if delta <= offset - 1
         setfield!(a, :ref, @inbounds memoryref(ref, 1 - delta))
     else
-        @noinline (function()
-        @_terminates_locally_meta
-        memlen = length(mem)
-        if offset + len - 1 > memlen || offset < 1
-            throw(ConcurrencyViolationError("Vector has invalid state. Don't modify internal fields incorrectly, or resize without correct locks"))
-        end
-        # since we will allocate the array in the middle of the memory we need at least 2*delta extra space
-        # the +1 is because I didn't want to have an off by 1 error.
-        newmemlen = max(overallocation(len), len + 2 * delta + 1)
-        newoffset = div(newmemlen - newlen, 2) + 1
-        # If there is extra data after the end of the array we can use that space so long as there is enough
-        # space at the end that there won't be quadratic behavior with a mix of growth from both ends.
-        # Specifically, we want to ensure that we will only do this operation once before
-        # increasing the size of the array, and that we leave enough space at both the beginning and the end.
-        if newoffset + newlen < memlen
-            newoffset = div(memlen - newlen, 2) + 1
-            newmem = mem
-            unsafe_copyto!(newmem, newoffset + delta, mem, offset, len)
-            for j in offset:newoffset+delta-1
-                @inbounds _unsetindex!(mem, j)
-            end
-        else
-            newmem = array_new_memory(mem, newmemlen)
-            unsafe_copyto!(newmem, newoffset + delta, mem, offset, len)
-        end
-        if ref !== a.ref
-            @noinline throw(ConcurrencyViolationError("Vector can not be resized concurrently"))
-        end
-        setfield!(a, :ref, @inbounds memoryref(newmem, newoffset))
-        end)()
+        @noinline _growbeg_internal!(a, delta, len)
     end
     return
 end
 
+function _growend_internal!(a::Vector, delta::Int, len::Int)
+    ref = a.ref
+    mem = ref.mem
+    memlen = length(mem)
+    newlen = len + delta
+    offset = memoryrefoffset(ref)
+    newmemlen = offset + newlen - 1
+    if offset + len - 1 > memlen || offset < 1
+        throw(ConcurrencyViolationError("Vector has invalid state. Don't modify internal fields incorrectly, or resize without correct locks"))
+    end
+
+    if offset - 1 > div(5 * newlen, 4)
+        # If the offset is far enough that we can copy without resizing
+        # while maintaining proportional spacing on both ends of the array
+        # note that this branch prevents infinite growth when doing combinations
+        # of push! and popfirst! (i.e. when using a Vector as a queue)
+        newmem = mem
+        newoffset = div(newlen, 8) + 1
+    else
+        # grow either by our computed overallocation factor
+        # or exactly the requested size, whichever is larger
+        # TODO we should possibly increase the offset if the current offset is nonzero.
+        newmemlen2 = max(overallocation(memlen), newmemlen)
+        newmem = array_new_memory(mem, newmemlen2)
+        newoffset = offset
+    end
+    newref = @inbounds memoryref(newmem, newoffset)
+    unsafe_copyto!(newref, ref, len)
+    if ref !== a.ref
+        @noinline throw(ConcurrencyViolationError("Vector can not be resized concurrently"))
+    end
+    setfield!(a, :ref, newref)
+return
+end
+
 function _growend!(a::Vector, delta::Integer)
     @_noub_meta
     delta = Int(delta)
@@ -1128,33 +1169,7 @@ function _growend!(a::Vector, delta::Integer)
     setfield!(a, :size, (newlen,))
     newmemlen = offset + newlen - 1
     if memlen < newmemlen
-        @noinline (function()
-        if offset + len - 1 > memlen || offset < 1
-            throw(ConcurrencyViolationError("Vector has invalid state. Don't modify internal fields incorrectly, or resize without correct locks"))
-        end
-
-        if offset - 1 > div(5 * newlen, 4)
-            # If the offset is far enough that we can copy without resizing
-            # while maintaining proportional spacing on both ends of the array
-            # note that this branch prevents infinite growth when doing combinations
-            # of push! and popfirst! (i.e. when using a Vector as a queue)
-            newmem = mem
-            newoffset = div(newlen, 8) + 1
-        else
-            # grow either by our computed overallocation factor
-            # or exactly the requested size, whichever is larger
-            # TODO we should possibly increase the offset if the current offset is nonzero.
-            newmemlen2 = max(overallocation(memlen), newmemlen)
-            newmem = array_new_memory(mem, newmemlen2)
-            newoffset = offset
-        end
-        newref = @inbounds memoryref(newmem, newoffset)
-        unsafe_copyto!(newref, ref, len)
-        if ref !== a.ref
-            @noinline throw(ConcurrencyViolationError("Vector can not be resized concurrently"))
-        end
-        setfield!(a, :ref, newref)
-        end)()
+        @noinline _growend_internal!(a, delta, len)
     end
     return
 end