Adding unsafe.Slice

Author: grantnelson-wf

compiler/expressions.go

@@ -1071,6 +1071,10 @@ func (fc *funcContext) translateBuiltin(name string, sig *types.Signature, args
 	case "Offsetof":
 		sel, _ := fc.selectionOf(astutil.RemoveParens(args[0]).(*ast.SelectorExpr))
 		return fc.formatExpr("%d", typesutil.OffsetOf(sizes32, sel))
+	case "Slice":
+		ptrType := fc.typeOf(args[0]).Underlying().(*types.Pointer)
+		sliceType := types.NewSlice(ptrType.Elem())
+		return fc.formatExpr("$unsafeSlice(%e, %e, %s)", args[0], args[1], fc.typeName(sliceType))
 	case "SliceData":
 		t := fc.typeOf(args[0]).Underlying().(*types.Slice)
 		return fc.formatExpr(`$sliceData(%e, %s)`, args[0], fc.typeName(t))

compiler/prelude/prelude.js

@@ -620,6 +620,20 @@ var $typeOf = x => {
     return typeof (x);
 };
 
+var $unsafeSlice = (ptr, len, typ) => {
+    if (ptr === typ.nil || ptr.$isNil) {
+        if (len > 0) {
+            $throwRuntimeError("unsafe.Slice: ptr is nil and len is not zero");
+        }
+        return typ.nil;
+    }
+    var s = new typ(ptr.$target);
+    s.$offset = ptr.$index;
+    s.$length = len;
+    s.$capacity = len;
+    return s;
+};
+
 var $sliceData = (slice, typ) => {
     if (slice === typ.nil) {
         return $ptrType(typ.elem).nil;

compiler/prelude/types.js

@@ -656,10 +656,22 @@ var $indexPtr = (array, index, constructor) => {
         // Pointers of different primitive types are non-comparable and stored in different caches.
         var typeCache = cache[array.name] = cache[array.name] || {};
         var cacheIdx = array.BYTES_PER_ELEMENT * index + array.byteOffset;
-        return typeCache[cacheIdx] || (typeCache[cacheIdx] = new constructor(() => { return array[index]; }, v => { array[index] = v; }));
+        var ptr = typeCache[cacheIdx];
+        if (!ptr) {
+            ptr = new constructor(() => { return array[index]; }, v => { array[index] = v; }, array);
+            ptr.$index = index;
+            typeCache[cacheIdx] = ptr;
+        }
+        return ptr;
     } else {
         array.$ptr = array.$ptr || {};
-        return array.$ptr[index] || (array.$ptr[index] = new constructor(() => { return array[index]; }, v => { array[index] = v; }));
+        var ptr = array.$ptr[index];
+        if (!ptr) {
+            ptr = new constructor(() => { return array[index]; }, v => { array[index] = v; }, array);
+            ptr.$index = index;
+            array.$ptr[index] = ptr;
+        }
+        return ptr;
     }
 };