Support builtin make() for type parameters.

nevkontakte · nevkontakte · commit 73df10d14f6c · 2023-11-04T21:59:00.000Z
Slice, channel and map types' constructors now have a .make() method
that implements the builtin for the corresponding type. The compiler
simply calls the builtin without a need to introspect the type.
diff --git a/compiler/expressions.go b/compiler/expressions.go
@@ -1049,26 +1049,16 @@ func (fc *funcContext) translateBuiltin(name string, sig *types.Signature, args
 			return fc.formatExpr("$newDataPointer(%e, %s)", fc.zeroValue(t.Elem()), fc.typeName(t))
 		}
 	case "make":
-		switch argType := fc.pkgCtx.TypeOf(args[0]).Underlying().(type) {
-		case *types.Slice:
-			t := fc.typeName(fc.pkgCtx.TypeOf(args[0]))
-			if len(args) == 3 {
-				return fc.formatExpr("$makeSlice(%s, %f, %f)", t, args[1], args[2])
-			}
-			return fc.formatExpr("$makeSlice(%s, %f)", t, args[1])
-		case *types.Map:
-			if len(args) == 2 && fc.pkgCtx.Types[args[1]].Value == nil {
-				return fc.formatExpr(`((%1f < 0 || %1f > 2147483647) ? $throwRuntimeError("makemap: size out of range") : new $global.Map())`, args[1])
-			}
-			return fc.formatExpr("new $global.Map()")
-		case *types.Chan:
-			length := "0"
-			if len(args) == 2 {
-				length = fc.formatExpr("%f", args[1]).String()
-			}
-			return fc.formatExpr("new $Chan(%s, %s)", fc.typeName(fc.pkgCtx.TypeOf(args[0]).Underlying().(*types.Chan).Elem()), length)
+		typeName := fc.typeName(fc.pkgCtx.TypeOf(args[0]))
+		switch len(args) {
+		case 1:
+			return fc.formatExpr("%s.$make()", typeName)
+		case 2:
+			return fc.formatExpr("%s.$make(%f)", typeName, args[1])
+		case 3:
+			return fc.formatExpr("%s.$make(%f, %f)", typeName, args[1], args[2])
 		default:
-			panic(fmt.Sprintf("Unhandled make type: %T\n", argType))
+			panic(fmt.Errorf("builtin make(): invalid number of arguments: %d", len(args)))
 		}
 	case "len":
 		switch argType := fc.pkgCtx.TypeOf(args[0]).Underlying().(type) {
diff --git a/compiler/prelude/types.js b/compiler/prelude/types.js
@@ -175,6 +175,7 @@ var $newType = (size, kind, string, named, pkg, exported, constructor) => {
                 typ.sendOnly = sendOnly;
                 typ.recvOnly = recvOnly;
             };
+            typ.$make = (bufsize) => new $Chan(typ.elem, bufsize ? bufsize : 0);
             break;
 
         case $kindFunc:
@@ -210,6 +211,11 @@ var $newType = (size, kind, string, named, pkg, exported, constructor) => {
                 typ.elem = elem;
                 typ.comparable = false;
             };
+            typ.$make = (size) => {
+                if (size === undefined) { size = 0; }
+                if (size < 0 || size > 2147483647) { $throwRuntimeError("makemap: size out of range"); }
+                return new $global.Map();
+            };
             break;
 
         case $kindPtr:
@@ -250,6 +256,7 @@ var $newType = (size, kind, string, named, pkg, exported, constructor) => {
                 typ.nativeArray = $nativeArray(elem.kind);
                 typ.nil = new typ([]);
             };
+            typ.$make = (size, capacity) => $makeSlice(typ, size, capacity);
             break;
 
         case $kindStruct:
diff --git a/tests/typeparams/builtins_test.go b/tests/typeparams/builtins_test.go
@@ -0,0 +1,83 @@
+package typeparams_test
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestMake(t *testing.T) {
+	t.Run("slice", func(t *testing.T) {
+		tests := []struct {
+			slice   []int
+			wantStr string
+			wantLen int
+			wantCap int
+		}{{
+			slice:   make([]int, 1),
+			wantStr: "[]int{0}",
+			wantLen: 1,
+			wantCap: 1,
+		}, {
+			slice:   make([]int, 1, 2),
+			wantStr: "[]int{0}",
+			wantLen: 1,
+			wantCap: 2,
+		}}
+
+		for i, test := range tests {
+			t.Run(fmt.Sprint(i), func(t *testing.T) {
+				if got := fmt.Sprintf("%#v", test.slice); got != test.wantStr {
+					t.Errorf("Got: fmt.Sprint(%v) = %q. Want: %q.", test.slice, got, test.wantStr)
+				}
+				if got := len(test.slice); got != test.wantLen {
+					t.Errorf("Got: len(%v) = %d. Want: %d.", test.slice, got, test.wantLen)
+				}
+				if got := cap(test.slice); got != test.wantCap {
+					t.Errorf("Got: cap(%v) = %d. Want: %d.", test.slice, got, test.wantCap)
+				}
+			})
+		}
+	})
+
+	t.Run("map", func(t *testing.T) {
+		tests := []map[int]int{
+			make(map[int]int),
+			make(map[int]int, 1),
+		}
+
+		for i, test := range tests {
+			t.Run(fmt.Sprint(i), func(t *testing.T) {
+				want := "map[int]int{}"
+				got := fmt.Sprintf("%#v", test)
+				if want != got {
+					t.Errorf("Got: fmt.Sprint(%v) = %q. Want: %q.", test, got, want)
+				}
+			})
+		}
+	})
+
+	t.Run("chan", func(t *testing.T) {
+		tests := []struct {
+			ch      chan int
+			wantCap int
+		}{{
+			ch:      make(chan int),
+			wantCap: 0,
+		}, {
+			ch:      make(chan int, 1),
+			wantCap: 1,
+		}}
+
+		for i, test := range tests {
+			t.Run(fmt.Sprint(i), func(t *testing.T) {
+				wantStr := "chan int"
+				if got := fmt.Sprintf("%T", test.ch); got != wantStr {
+					t.Errorf("Got: fmt.Sprint(%v) = %q. Want: %q.", test.ch, got, wantStr)
+				}
+				if got := cap(test.ch); got != test.wantCap {
+					t.Errorf("Got: cap(%v) = %d. Want: %d.", test.ch, got, test.wantCap)
+				}
+			})
+		}
+	})
+}
