Support bitwise xor operator for type parameters.

nevkontakte · nevkontakte · commit af59ead94c75 · 2023-11-04T15:47:58.000Z
diff --git a/compiler/expressions.go b/compiler/expressions.go
@@ -700,6 +700,8 @@ func (fc *funcContext) translateBinaryExpr(e *ast.BinaryExpr) *expression {
 			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)
+		case token.XOR:
+			return fc.formatExpr("%s.xor(%e, %e)", fc.typeName(t), e.X, e.Y)
 		}
 	}
 
diff --git a/compiler/prelude/types.js b/compiler/prelude/types.js
@@ -427,6 +427,7 @@ var $newType = (size, kind, string, named, pkg, exported, constructor) => {
             typ.rem = $irem;
             typ.and = (x, y) => (x & y);
             typ.or = (x, y) => (x | y);
+            typ.xor = (x, y) => $truncateNumber(x ^ y, typ);
             break;
         case $kindUint8:
         case $kindUint16:
@@ -437,6 +438,7 @@ var $newType = (size, kind, string, named, pkg, exported, constructor) => {
             typ.rem = $irem;
             typ.and = (x, y) => (x & y) >>> 0;
             typ.or = (x, y) => (x | y) >>> 0;
+            typ.xor = (x, y) => $truncateNumber(x ^ y, typ);
             break;
         case $kindUint:
         case $kindUint32:
@@ -448,6 +450,7 @@ var $newType = (size, kind, string, named, pkg, exported, constructor) => {
             typ.rem = $irem;
             typ.and = (x, y) => (x & y) >>> 0;
             typ.or = (x, y) => (x | y) >>> 0;
+            typ.xor = (x, y) => $truncateNumber(x ^ y, typ);
             break;
         case $kindInt:
         case $kindInt32:
@@ -458,6 +461,7 @@ var $newType = (size, kind, string, named, pkg, exported, constructor) => {
             typ.rem = $irem;
             typ.and = (x, y) => (x & y);
             typ.or = (x, y) => (x | y);
+            typ.xor = (x, y) => $truncateNumber(x ^ y, typ);
             break;
         case $kindInt64:
         case $kindUint64:
@@ -468,6 +472,7 @@ var $newType = (size, kind, string, named, pkg, exported, constructor) => {
             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);
+            typ.xor = (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
@@ -300,3 +300,37 @@ func TestBitwiseOr(t *testing.T) {
 		t.Run(test.String(), test.Run)
 	}
 }
+
+func xor[T constraints.Integer](x, y T) T {
+	return x ^ y
+}
+
+func xorTC[T constraints.Integer](x, y, want T) *testCase[T] {
+	return &testCase[T]{
+		op:     xor[T],
+		opName: token.XOR,
+		x:      x,
+		y:      y,
+		want:   want,
+	}
+}
+
+func TestBitwiseXor(t *testing.T) {
+	tests := []testCaseI{
+		xorTC[int](0x0011, 0x0101, 0x0110),
+		xorTC[uint](0x0011, 0x0101, 0x0110),
+		xorTC[uintptr](0x0011, 0x0101, 0x0110),
+		xorTC[int8](0x11, 0x01, 0x10),
+		xorTC[int16](0x0011, 0x0101, 0x0110),
+		xorTC[int32](0x0011, 0x0101, 0x0110),
+		xorTC[uint8](0x11, 0x01, 0x10),
+		xorTC[uint16](0x0011, 0x0101, 0x0110),
+		xorTC[uint32](0x0011, 0x0101, 0x0110),
+		xorTC[int64](0x0000001100000011, 0x0000010100000101, 0x0000011000000110),
+		xorTC[uint64](0x0000001100000011, 0x0000010100000101, 0x0000011000000110),
+	}
+
+	for _, test := range tests {
+		t.Run(test.String(), test.Run)
+	}
+}

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