Support "bit clear" (aka "and not") bitwise operator for type params.

nevkontakte · nevkontakte · commit f4c090459131 · 2023-11-04T15:47:58.000Z
diff --git a/compiler/expressions.go b/compiler/expressions.go
@@ -702,6 +702,8 @@ func (fc *funcContext) translateBinaryExpr(e *ast.BinaryExpr) *expression {
 			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)
+		case token.AND_NOT:
+			return fc.formatExpr("%s.andNot(%e, %e)", fc.typeName(t), e.X, e.Y)
 		}
 	}
 
diff --git a/compiler/prelude/types.js b/compiler/prelude/types.js
@@ -428,6 +428,7 @@ var $newType = (size, kind, string, named, pkg, exported, constructor) => {
             typ.and = (x, y) => (x & y);
             typ.or = (x, y) => (x | y);
             typ.xor = (x, y) => $truncateNumber(x ^ y, typ);
+            typ.andNot = (x, y) => $truncateNumber(x & ~y, typ);
             break;
         case $kindUint8:
         case $kindUint16:
@@ -439,6 +440,7 @@ var $newType = (size, kind, string, named, pkg, exported, constructor) => {
             typ.and = (x, y) => (x & y) >>> 0;
             typ.or = (x, y) => (x | y) >>> 0;
             typ.xor = (x, y) => $truncateNumber(x ^ y, typ);
+            typ.andNot = (x, y) => $truncateNumber(x & ~y, typ);
             break;
         case $kindUint:
         case $kindUint32:
@@ -451,6 +453,7 @@ var $newType = (size, kind, string, named, pkg, exported, constructor) => {
             typ.and = (x, y) => (x & y) >>> 0;
             typ.or = (x, y) => (x | y) >>> 0;
             typ.xor = (x, y) => $truncateNumber(x ^ y, typ);
+            typ.andNot = (x, y) => $truncateNumber(x & ~y, typ);
             break;
         case $kindInt:
         case $kindInt32:
@@ -462,6 +465,7 @@ var $newType = (size, kind, string, named, pkg, exported, constructor) => {
             typ.and = (x, y) => (x & y);
             typ.or = (x, y) => (x | y);
             typ.xor = (x, y) => $truncateNumber(x ^ y, typ);
+            typ.andNot = (x, y) => $truncateNumber(x & ~y, typ);
             break;
         case $kindInt64:
         case $kindUint64:
@@ -473,6 +477,7 @@ var $newType = (size, kind, string, named, pkg, exported, constructor) => {
             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);
+            typ.andNot = (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
@@ -334,3 +334,37 @@ func TestBitwiseXor(t *testing.T) {
 		t.Run(test.String(), test.Run)
 	}
 }
+
+func andNot[T constraints.Integer](x, y T) T {
+	return x &^ y
+}
+
+func andNotTC[T constraints.Integer](x, y, want T) *testCase[T] {
+	return &testCase[T]{
+		op:     andNot[T],
+		opName: token.AND_NOT,
+		x:      x,
+		y:      y,
+		want:   want,
+	}
+}
+
+func TestBitwiseAndNot(t *testing.T) {
+	tests := []testCaseI{
+		andNotTC[int](0x0011, 0x0101, 0x0010),
+		andNotTC[uint](0x0011, 0x0101, 0x0010),
+		andNotTC[uintptr](0x0011, 0x0101, 0x0010),
+		andNotTC[int8](0x11, 0x01, 0x10),
+		andNotTC[int16](0x0011, 0x0101, 0x0010),
+		andNotTC[int32](0x0011, 0x0101, 0x0010),
+		andNotTC[uint8](0x11, 0x01, 0x10),
+		andNotTC[uint16](0x0011, 0x0101, 0x0010),
+		andNotTC[uint32](0x0011, 0x0101, 0x0010),
+		andNotTC[int64](0x0000001100000011, 0x0000010100000101, 0x0000001000000010),
+		andNotTC[uint64](0x0000001100000011, 0x0000010100000101, 0x0000001000000010),
+	}
+
+	for _, test := range tests {
+		t.Run(test.String(), test.Run)
+	}
+}

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