Made changes per suggestions and help

grantnelson-wf · grantnelson-wf · commit 165ce970489e · 2024-07-02T14:07:55.000-06:00
diff --git a/compiler/natives/src/reflect/reflect.go b/compiler/natives/src/reflect/reflect.go
@@ -1339,9 +1339,7 @@ func (v Value) grow(n int) {
 	cap := s.Get(`$capacity`).Int()
 	if len+n > cap {
 		ns := js.Global.Call("$growSlice", s, len+n)
-		s.Set(`$capacity`, ns.Get(`$capacity`))
-		s.Set(`$array`, ns.Get(`$array`))
-		s.Set(`$offset`, ns.Get(`$offset`))
+		js.InternalObject(v.ptr).Call("$set", ns)
 	}
 }
 
diff --git a/compiler/prelude/prelude.js b/compiler/prelude/prelude.js
@@ -428,55 +428,75 @@ var $appendSlice = (slice, toAppend) => {
     return $internalAppend(slice, toAppend.$array, toAppend.$offset, toAppend.$length);
 };
 
+// Internal helper function for appending to a slice.
+// The given slice will not be modified.
+//
+// If no values are being appended, the original slice will be returned.
+// Otherwise, a new slice will be created with the appended values.
+//
+// If the underlying array has enough capacity, it will be used.
+// Otherwise, a new array will be allocated with enough capacity to hold
+// the new values and the original array will not be modified.
 var $internalAppend = (slice, array, offset, length) => {
     if (length === 0) {
         return slice;
     }
 
-    var newLength = slice.$length + length;
-    slice = $growSlice(slice, newLength);
+    let newLength = slice.$length + length;
+    let newSlice = $growSlice(slice, newLength);
     
-    var newArray = slice.$array;
-    $copyArray(newArray, array, slice.$offset + slice.$length, offset, length, slice.constructor.elem);
-
-    var newSlice = new slice.constructor(newArray);
-    newSlice.$offset = slice.$offset;
+    let newArray = newSlice.$array;
+    $copyArray(newArray, array, newSlice.$offset + newSlice.$length, offset, length, newSlice.constructor.elem);
+   
     newSlice.$length = newLength;
-    newSlice.$capacity = slice.$capacity;
     return newSlice;
 };
 
+// Calculates the new capacity for a slice that is expected to grow to at least
+// the given minCapacity. This follows the Go runtime's growth strategy.
+// The oldCapacity is the current capacity of the slice that is being grown.
 const $calculateNewCapacity = (minCapacity, oldCapacity) => {
     return Math.max(minCapacity, oldCapacity < 1024 ? oldCapacity * 2 : Math.floor(oldCapacity * 5 / 4));
 };
 
+// Potentially grows the slice to have a capacity of at least minCapacity.
+//
+// A new slice will always be returned, even if the given slice had the required capacity.
+// If the slice didn't have enough capacity, the new slice will have a
+// new array created for it with the required minimum capacity.
+//
+// This takes the place of the growSlice function in the reflect package.
 var $growSlice = (slice, minCapacity) => {
-    const oldCapacity = slice.$capacity;
-    if (minCapacity <= oldCapacity) {
-        return slice
-    }
-     
-    const newCapacity = $calculateNewCapacity(minCapacity, oldCapacity);
-    
-    let newArray;
-    if (slice.$array.constructor === Array) {
-        newArray = slice.$array.slice( slice.$offset,  slice.$offset + slice.$length);
-        newArray.length = newCapacity;
-        let zero = slice.constructor.elem.zero;
-        for (let i = slice.$length; i < newCapacity; i++) {
-            newArray[i] = zero();
+    let array = slice.$array;
+    let offset = slice.$offset;
+    const length = slice.$length;
+    let capacity = slice.$capacity;
+
+    if (minCapacity > capacity) {
+        capacity = $calculateNewCapacity(minCapacity, capacity);
+        
+        let newArray;
+        if (array.constructor === Array) {
+            newArray = array.slice(offset, offset + length);
+            newArray.length = capacity;
+            const zero = slice.constructor.elem.zero;
+            for (let i = slice.$length; i < capacity; i++) {
+                newArray[i] = zero();
+            }
+        } else {
+            newArray = new array.constructor(capacity);
+            newArray.set(array.subarray(offset, offset + length));
         }
-    } else {
-        newArray = new slice.$array.constructor(newCapacity);
-        newArray.set(slice.$array.subarray( slice.$offset,  slice.$offset + slice.$length));
+
+        array = newArray;
+        offset = 0;
     }
 
-    const oldLength = slice.$length;
-    slice = new slice.constructor(newArray);
-    slice.$offset = 0;
-    slice.$length = oldLength;
-    slice.$capacity = newCapacity;
-    return slice;
+    let newSlice = new slice.constructor(array);
+    newSlice.$offset = offset;
+    newSlice.$length = length;
+    newSlice.$capacity = capacity;
+    return newSlice;
 };
 
 var $equal = (a, b, type) => {

Original file line number	Diff line number	Diff line change
`@@ -1339,9 +1339,7 @@ func (v Value) grow(n int) {`
`1339`	`1339`	cap := s.Get(`$capacity`).Int()
`1340`	`1340`	`if len+n > cap {`
`1341`	`1341`	`ns := js.Global.Call("$growSlice", s, len+n)`
`1342`		- s.Set(`$capacity`, ns.Get(`$capacity`))
`1343`		- s.Set(`$array`, ns.Get(`$array`))
`1344`		- s.Set(`$offset`, ns.Get(`$offset`))
	`1342`	`+ js.InternalObject(v.ptr).Call("$set", ns)`
`1345`	`1343`	`}`
`1346`	`1344`	`}`
`1347`	`1345`