Support multiplication operator for type params.

nevkontakte · nevkontakte · commit 98523b44997a · 2023-11-04T15:47:58.000Z
diff --git a/compiler/expressions.go b/compiler/expressions.go
@@ -690,6 +690,8 @@ func (fc *funcContext) translateBinaryExpr(e *ast.BinaryExpr) *expression {
 			return fc.formatExpr("%s.add(%e, %e)", fc.typeName(t), e.X, e.Y)
 		case token.SUB:
 			return fc.formatExpr("%s.sub(%e, %e)", fc.typeName(t), e.X, e.Y)
+		case token.MUL:
+			return fc.formatExpr("%s.mul(%e, %e)", fc.typeName(t), e.X, e.Y)
 		}
 	}
 
diff --git a/compiler/prelude/types.js b/compiler/prelude/types.js
@@ -418,29 +418,40 @@ var $newType = (size, kind, string, named, pkg, exported, constructor) => {
     // This methods will be called when the exact type is not known at code generation time, for
     // example, when operands are type parameters.
     switch (kind) {
-        case $kindInt:
         case $kindInt8:
         case $kindInt16:
-        case $kindInt32:
         case $kindUint:
         case $kindUint8:
         case $kindUint16:
-        case $kindUint32:
-        case $kindUintptr:
         case $kindFloat32:
         case $kindFloat64:
             typ.add = (x, y) => $truncateNumber(x + y, typ);
             typ.sub = (x, y) => $truncateNumber(x - y, typ);
+            typ.mul = (x, y) => $truncateNumber(x * y, typ);
+            break;
+        case $kindUint32:
+        case $kindUintptr:
+            typ.add = (x, y) => $truncateNumber(x + y, typ);
+            typ.sub = (x, y) => $truncateNumber(x - y, typ);
+            typ.mul = (x, y) => $imul(x, y) >>> 0;
+            break;
+        case $kindInt:
+        case $kindInt32:
+            typ.add = (x, y) => $truncateNumber(x + y, typ);
+            typ.sub = (x, y) => $truncateNumber(x - y, typ);
+            typ.mul = (x, y) => $imul(x, y);
             break;
         case $kindInt64:
         case $kindUint64:
             typ.add = (x, y) => new typ(x.$high + y.$high, x.$low + y.$low);
             typ.sub = (x, y) => new typ(x.$high - y.$high, x.$low - y.$low);
+            typ.mul = (x, y) => $mul64(x, y);
             break;
         case $kindComplex64:
         case $kindComplex128:
             typ.add = (x, y) => new typ(x.$real + y.$real, x.$imag + y.$imag);
             typ.sub = (x, y) => new typ(x.$real - y.$real, x.$imag - y.$imag);
+            typ.mul = (x, y) => new typ(x.$real * y.$real - x.$imag * y.$imag, x.$real * y.$imag + x.$imag * y.$real);
             break;
         case $kindString:
             typ.add = (x, y) => x + y;
diff --git a/tests/typeparams/arithmetics_test.go b/tests/typeparams/arithmetics_test.go
@@ -120,3 +120,47 @@ func TestSubtract(t *testing.T) {
 		t.Run(test.String(), test.Run)
 	}
 }
+
+type muiltipliable interface {
+	constraints.Integer | constraints.Float | constraints.Complex
+}
+
+func mul[T muiltipliable](x, y T) T {
+	return x * y
+}
+
+func mulTC[T muiltipliable](x, y, want T) *testCase[T] {
+	return &testCase[T]{
+		op:     mul[T],
+		opName: token.MUL,
+		x:      x,
+		y:      y,
+		want:   want,
+	}
+}
+
+func TestMul(t *testing.T) {
+	tests := []testCaseI{
+		mulTC[int](2, 3, 6),
+		mulTC[uint](2, 3, 6),
+		mulTC[uintptr](2, 3, 6),
+		mulTC[int8](2, 3, 6),
+		mulTC[int16](2, 3, 6),
+		mulTC[int32](2, 3, 6),
+		mulTC[uint8](2, 3, 6),
+		mulTC[uint16](2, 3, 6),
+		mulTC[uint32](2, 3, 6),
+		mulTC[int8](127, 3, 125),  // Overflow.
+		mulTC[uint8](250, 3, 238), // Overflow.
+		mulTC[float32](2.5, 1.4, 3.5),
+		mulTC[float64](2.5, 1.4, 3.5),
+		mulTC[int64](0x0000003200000001, 0x0000000100000002, 0x0000006500000002),
+		mulTC[uint64](0x0000003200000001, 0x0000000100000002, 0x0000006500000002),
+		mulTC[complex64](1+2i, 3+4i, -5+10i),
+		mulTC[complex128](1+2i, 3+4i, -5+10i),
+	}
+
+	for _, test := range tests {
+		t.Run(test.String(), test.Run)
+	}
+}

Original file line number	Diff line number	Diff line change
`@@ -690,6 +690,8 @@ func (fc funcContext) translateBinaryExpr(e ast.BinaryExpr) *expression {`
`690`	`690`	`return fc.formatExpr("%s.add(%e, %e)", fc.typeName(t), e.X, e.Y)`
`691`	`691`	`case token.SUB:`
`692`	`692`	`return fc.formatExpr("%s.sub(%e, %e)", fc.typeName(t), e.X, e.Y)`
	`693`	`+ case token.MUL:`
	`694`	`+ return fc.formatExpr("%s.mul(%e, %e)", fc.typeName(t), e.X, e.Y)`
`693`	`695`	`}`
`694`	`696`	`}`
`695`	`697`