Implement len() builtin for type parameters.

nevkontakte · nevkontakte · commit ad18f2c2ea9d · 2023-11-04T21:59:29.000Z
Similar to make(), each relevant type constructor has a $len() method
that takes an unwrapped type value and returns its length. Whenever
len() is called with a type param, the compiler emits a call to
`Type.$len(value)`.

Unlike make(), I kept compile-time specializations of len(), since they
are much more likely to be called in performance-critical path and would
be cheaper than a call to `T.$len()`.
diff --git a/compiler/expressions.go b/compiler/expressions.go
@@ -1072,6 +1072,8 @@ func (fc *funcContext) translateBuiltin(name string, sig *types.Signature, args
 			return fc.formatExpr("(%e ? %e.size : 0)", args[0], args[0])
 		case *types.Chan:
 			return fc.formatExpr("%e.$buffer.length", args[0])
+		case *types.Interface: // *types.TypeParam has interface as underlying type.
+			return fc.formatExpr("%s.$len(%e)", fc.typeName(fc.pkgCtx.TypeOf(args[0])), args[0])
 		// length of array is constant
 		default:
 			panic(fmt.Sprintf("Unhandled len type: %T\n", argType))
diff --git a/compiler/prelude/types.js b/compiler/prelude/types.js
@@ -93,6 +93,7 @@ var $newType = (size, kind, string, named, pkg, exported, constructor) => {
             typ.wrapped = true;
             typ.wrap = (v) => new typ(v);
             typ.keyFor = x => { return "$" + x; };
+            typ.$len = (v) => v.length;
             break;
 
         case $kindFloat32:
@@ -163,6 +164,7 @@ var $newType = (size, kind, string, named, pkg, exported, constructor) => {
                 typ.ptr.init(typ);
                 Object.defineProperty(typ.ptr.nil, "nilCheck", { get: $throwNilPointerError });
             };
+            typ.$len = (v) => typ.len;
             break;
 
         case $kindChan:
@@ -176,6 +178,7 @@ var $newType = (size, kind, string, named, pkg, exported, constructor) => {
                 typ.recvOnly = recvOnly;
             };
             typ.$make = (bufsize) => new $Chan(typ.elem, bufsize ? bufsize : 0);
+            typ.$len = (v) => v.$buffer.length;
             break;
 
         case $kindFunc:
@@ -216,6 +219,7 @@ var $newType = (size, kind, string, named, pkg, exported, constructor) => {
                 if (size < 0 || size > 2147483647) { $throwRuntimeError("makemap: size out of range"); }
                 return new $global.Map();
             };
+            typ.$len = (v) => v ? v.size : 0;
             break;
 
         case $kindPtr:
@@ -236,6 +240,7 @@ var $newType = (size, kind, string, named, pkg, exported, constructor) => {
                 }
                 typ.nil = new typ($throwNilPointerError, $throwNilPointerError);
             };
+            typ.$len = (v) => typ.elem.$len(typ.wrapped ? v : v.$get());
             break;
 
         case $kindSlice:
@@ -257,6 +262,7 @@ var $newType = (size, kind, string, named, pkg, exported, constructor) => {
                 typ.nil = new typ([]);
             };
             typ.$make = (size, capacity) => $makeSlice(typ, size, capacity);
+            typ.$len = (v) => v.$length;
             break;
 
         case $kindStruct:
diff --git a/tests/typeparams/builtins_test.go b/tests/typeparams/builtins_test.go
@@ -81,3 +81,46 @@ func TestMake(t *testing.T) {
 		}
 	})
 }
+
+func _len[T []int | *[3]int | map[int]int | chan int | string](x T) int {
+	return len(x)
+}
+
+func TestLen(t *testing.T) {
+	ch := make(chan int, 2)
+	ch <- 1
+
+	tests := []struct {
+		desc string
+		got  int
+		want int
+	}{{
+		desc: "string",
+		got:  _len("abcd"),
+		want: 4,
+	}, {
+		desc: "[]int",
+		got:  _len([]int{1, 2, 3}),
+		want: 3,
+	}, {
+		desc: "[3]int",
+		got:  _len(&[3]int{1}),
+		want: 3,
+	}, {
+		desc: "map[int]int",
+		got:  _len(map[int]int{1: 1, 2: 2}),
+		want: 2,
+	}, {
+		desc: "chan int",
+		got:  _len(ch),
+		want: 1,
+	}}
+
+	for _, test := range tests {
+		t.Run(test.desc, func(t *testing.T) {
+			if test.got != test.want {
+				t.Errorf("Got: len() = %d. Want: %d.", test.got, test.want)
+			}
+		})
+	}
+}
