Support bitwise or operator for type params.

nevkontakte · nevkontakte · commit c6df48a7c668 · 2023-11-04T15:47:58.000Z
diff --git a/compiler/expressions.go b/compiler/expressions.go
@@ -698,6 +698,8 @@ func (fc *funcContext) translateBinaryExpr(e *ast.BinaryExpr) *expression {
 			return fc.formatExpr("%s.rem(%e, %e)", fc.typeName(t), e.X, e.Y)
 		case token.AND:
 			return fc.formatExpr("%s.and(%e, %e)", fc.typeName(t), e.X, e.Y)
+		case token.OR:
+			return fc.formatExpr("%s.or(%e, %e)", fc.typeName(t), e.X, e.Y)
 		}
 	}
 
diff --git a/compiler/prelude/types.js b/compiler/prelude/types.js
@@ -426,6 +426,7 @@ var $newType = (size, kind, string, named, pkg, exported, constructor) => {
             typ.div = (x, y) => $idiv(x, y) >> 0;
             typ.rem = $irem;
             typ.and = (x, y) => (x & y);
+            typ.or = (x, y) => (x | y);
             break;
         case $kindUint8:
         case $kindUint16:
@@ -435,6 +436,7 @@ var $newType = (size, kind, string, named, pkg, exported, constructor) => {
             typ.div = (x, y) => $idiv(x, y) >>> 0;
             typ.rem = $irem;
             typ.and = (x, y) => (x & y) >>> 0;
+            typ.or = (x, y) => (x | y) >>> 0;
             break;
         case $kindUint:
         case $kindUint32:
@@ -445,6 +447,7 @@ var $newType = (size, kind, string, named, pkg, exported, constructor) => {
             typ.div = (x, y) => $idiv(x, y) >>> 0;
             typ.rem = $irem;
             typ.and = (x, y) => (x & y) >>> 0;
+            typ.or = (x, y) => (x | y) >>> 0;
             break;
         case $kindInt:
         case $kindInt32:
@@ -454,6 +457,7 @@ var $newType = (size, kind, string, named, pkg, exported, constructor) => {
             typ.div = (x, y) => $idiv(x, y) >> 0;
             typ.rem = $irem;
             typ.and = (x, y) => (x & y);
+            typ.or = (x, y) => (x | y);
             break;
         case $kindInt64:
         case $kindUint64:
@@ -463,6 +467,7 @@ var $newType = (size, kind, string, named, pkg, exported, constructor) => {
             typ.div = (x, y) => $div64(x, y, false);
             typ.rem = (x, y) => $div64(x, y, true);
             typ.and = (x, y) => new typ(x.$high & y.$high, (x.$low & y.$low) >>> 0);
+            typ.or = (x, y) => new typ(x.$high | y.$high, (x.$low | y.$low) >>> 0);
             break;
         case $kindFloat32:
         case $kindFloat64:
diff --git a/tests/typeparams/arithmetics_test.go b/tests/typeparams/arithmetics_test.go
@@ -266,3 +266,37 @@ func TestBitwiseAnd(t *testing.T) {
 		t.Run(test.String(), test.Run)
 	}
 }
+
+func or[T constraints.Integer](x, y T) T {
+	return x | y
+}
+
+func orTC[T constraints.Integer](x, y, want T) *testCase[T] {
+	return &testCase[T]{
+		op:     or[T],
+		opName: token.OR,
+		x:      x,
+		y:      y,
+		want:   want,
+	}
+}
+
+func TestBitwiseOr(t *testing.T) {
+	tests := []testCaseI{
+		orTC[int](0x0011, 0x0101, 0x0111),
+		orTC[uint](0x0011, 0x0101, 0x0111),
+		orTC[uintptr](0x0011, 0x0101, 0x0111),
+		orTC[int8](0x11, 0x01, 0x11),
+		orTC[int16](0x0011, 0x0101, 0x0111),
+		orTC[int32](0x0011, 0x0101, 0x0111),
+		orTC[uint8](0x11, 0x01, 0x11),
+		orTC[uint16](0x0011, 0x0101, 0x0111),
+		orTC[uint32](0x0011, 0x0101, 0x0111),
+		orTC[int64](0x0000001100000011, 0x0000010100000101, 0x0000011100000111),
+		orTC[uint64](0x0000001100000011, 0x0000010100000101, 0x0000011100000111),
+	}
+
+	for _, test := range tests {
+		t.Run(test.String(), test.Run)
+	}
+}

Original file line number	Diff line number	Diff line change
`@@ -698,6 +698,8 @@ func (fc funcContext) translateBinaryExpr(e ast.BinaryExpr) *expression {`
`698`	`698`	`return fc.formatExpr("%s.rem(%e, %e)", fc.typeName(t), e.X, e.Y)`
`699`	`699`	`case token.AND:`
`700`	`700`	`return fc.formatExpr("%s.and(%e, %e)", fc.typeName(t), e.X, e.Y)`
	`701`	`+ case token.OR:`
	`702`	`+ return fc.formatExpr("%s.or(%e, %e)", fc.typeName(t), e.X, e.Y)`
`701`	`703`	`}`
`702`	`704`	`}`
`703`	`705`