From 2297623aad4c249bccae3fe363ada31e308131ac Mon Sep 17 00:00:00 2001
From: kaizhangNV <149626564+kaizhangNV@users.noreply.github.com>
Date: Tue, 5 Mar 2024 12:55:50 +0800
Subject: Implement short-circuit logic operator (#3635)

* Implement short-circuit logic operator

Implement short-circuit evaluation for logic && and ||
operator.

The short-circuit behavior is only used when the operands
involved are scalar and the parent function is non-differentiable.

In implementation, we define a new class 'LogicOperatorShortCircuitExpr'
derived from 'OperatorExpr'. In the visitInvoke() call, we will create
a new expression object 'LogicOperatorShortCircuitExpr' if the
expression is logic && or ||. So that we can generate new IR code in the
new visit function 'visitLogicOperatorShortCircuitExpr' to implement the
short-circuit behavior.

Add new test to test the short-circuit behavior.

* Fix an compile issue occurred in Falcon test

Previously, we early return when at least one of the operands of
"&&" or "||" is vector in convertToLogicOperatorExpr call. However,
in that case the arguments involved in the expression have already been
type checked. When it falls-back to 'visitInvokeExpr', it will check
the arguments again, and some unexpected behavior could occur
which could in turn cause some internal error.

So we add a check in the 'visitInvokeExpr' to avoid double type checking
of arguments.

* Update glsl subgroup test to not use short-circuit

Since the short-circuit evaluation could cause the threads
diverging in subgroup intrinsics. So change the test to not
using "&&" to chain those subgroup intrinsics together. Instead,
using "&" to chain them together because those test functions have
the return value as bool.

* Disable short-circuit in few situations

Disable short-circuit in following situations:
1. generic parameter list
2. static const varible initialization

* Use a flag to indicate the enablement of short-circuit

Instead of using a struct to indicate the state of the outer
environment of current expression, use a simple bool flag to
indicate whether or not apply the short-circuit to current
expression because there few situations where we will disable
short-circuiting and in those circumstances, there is no nested.

Therefore, a flag is good enough to indicate the case.

* Disable short-circuit in index expression

Also fix the build issue. (A cleanup for the last change.)

* check both 'static' and 'const' modifiers

Previously we only check HLSLStaticModifier to decide whether or
not using short-circuit, but we really should check both 'static'
and 'const' modifiers together, because we only want to disable
the short circuit for init expression for 'static const' variable.

* relax the restriction of short-circuit for index expression

Disable the short-circuit for index expression only when declare
an array.

* Simplify the logic by creating subVisitor

Simplify the logic by create a sub expression visitor so
that we don't need to introduce extra recursion.

* Call convertToLogicOperatorExpr after args check

Change to call convertToLogicOperatorExpr after arguments
check in visitInvokeExpr such that we don't have to check
whether the arguments checked to avoid the double checking
issue.
---
 tests/compute/logic-short-circuit-evaluation.slang |  28 +++
 ...gic-short-circuit-evaluation.slang.expected.txt |  16 ++
 .../shader-subgroup-arithmetic_Exclusive.slang     | 192 ++++++++++-----------
 .../shader-subgroup-arithmetic_Inclusive.slang     | 192 ++++++++++-----------
 .../shader-subgroup-arithmetic_None.slang          | 192 ++++++++++-----------
 .../shader-subgroup/shader-subgroup-ballot.slang   | 132 +++++++-------
 .../shader-subgroup-clustered.slang                | 192 ++++++++++-----------
 .../shader-subgroup/shader-subgroup-quad.slang     | 130 +++++++-------
 .../shader-subgroup-shuffle-relative.slang         | 114 ++++++------
 .../shader-subgroup/shader-subgroup-shuffle.slang  | 122 ++++++-------
 .../shader-subgroup/shader-subgroup-vote.slang     | 112 ++++++------
 11 files changed, 733 insertions(+), 689 deletions(-)
 create mode 100644 tests/compute/logic-short-circuit-evaluation.slang
 create mode 100644 tests/compute/logic-short-circuit-evaluation.slang.expected.txt

(limited to 'tests')

diff --git a/tests/compute/logic-short-circuit-evaluation.slang b/tests/compute/logic-short-circuit-evaluation.slang
new file mode 100644
index 000000000..585a04770
--- /dev/null
+++ b/tests/compute/logic-short-circuit-evaluation.slang
@@ -0,0 +1,28 @@
+//TEST(compute):COMPARE_COMPUTE:-dx12 -compute -shaderobj 
+//TEST(compute):COMPARE_COMPUTE:-vk -compute  -shaderobj
+//TEST(compute):COMPARE_COMPUTE_EX:-cuda -compute -shaderobj
+//TEST(compute):COMPARE_COMPUTE_EX:-cpu -compute -compile-arg -O3 -shaderobj
+//TEST(compute):COMPARE_COMPUTE_EX:-slang -compute -shaderobj
+
+// Test doing vector comparisons 
+
+//TEST_INPUT:ubuffer(data=[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0], stride=4):out,name=outputBuffer
+RWStructuredBuffer<int> outputBuffer;
+
+bool assignFunc(int index)
+{
+    outputBuffer[index] = 1;
+    return true;
+}
+
+[numthreads(16, 1, 1)]
+void computeMain(int3 dispatchThreadID : SV_DispatchThreadID)
+{
+    int index = dispatchThreadID.x;
+
+    // Only the first 4 elements will be 1
+    (index < 4) && assignFunc(index);
+
+    // Only the last 4 elements will be 1.
+    (index < 12) || assignFunc(index);
+}
diff --git a/tests/compute/logic-short-circuit-evaluation.slang.expected.txt b/tests/compute/logic-short-circuit-evaluation.slang.expected.txt
new file mode 100644
index 000000000..945f08f2c
--- /dev/null
+++ b/tests/compute/logic-short-circuit-evaluation.slang.expected.txt
@@ -0,0 +1,16 @@
+1
+1
+1
+1
+0
+0
+0
+0
+0
+0
+0
+0
+1
+1
+1
+1
diff --git a/tests/glsl-intrinsic/shader-subgroup/shader-subgroup-arithmetic_Exclusive.slang b/tests/glsl-intrinsic/shader-subgroup/shader-subgroup-arithmetic_Exclusive.slang
index 7bfc4d886..ad4dd1535 100644
--- a/tests/glsl-intrinsic/shader-subgroup/shader-subgroup-arithmetic_Exclusive.slang
+++ b/tests/glsl-intrinsic/shader-subgroup/shader-subgroup-arithmetic_Exclusive.slang
@@ -31,9 +31,9 @@ __generic<T : __BuiltinLogicalType>
 bool test1Logical() {
     return true
 #if defined(TEST_when_logical_operators_are_implemented)
-        && subgroupExclusiveAnd(T(1)) == T(1)
-        && subgroupExclusiveOr(T(1)) == T(1)
-        && subgroupExclusiveXor(T(1)) == T(1)
+        & subgroupExclusiveAnd(T(1)) == T(1)
+        & subgroupExclusiveOr(T(1)) == T(1)
+        & subgroupExclusiveXor(T(1)) == T(1)
 #endif // #if defined(TEST_when_logical_operators_are_implemented)
         ;
 }
@@ -44,61 +44,61 @@ bool testVLogical() {
 
     return true
 #if defined(TEST_when_logical_operators_are_implemented)
-        && subgroupExclusiveAnd(gvec(T(1))) == gvec(T(1))
-        && subgroupExclusiveOr(gvec(T(1))) == gvec(T(1))
-        && subgroupExclusiveXor(gvec(T(1))) == gvec(T(1))
+        & subgroupExclusiveAnd(gvec(T(1))) == gvec(T(1))
+        & subgroupExclusiveOr(gvec(T(1))) == gvec(T(1))
+        & subgroupExclusiveXor(gvec(T(1))) == gvec(T(1))
 #endif // #if defined(TEST_when_logical_operators_are_implemented)
         ;
 }
 
 bool testLogical() {
     return true
-        && test1Logical<int>()
-        && testVLogical<int, 2>()
-        && testVLogical<int, 3>()
-        && testVLogical<int, 4>()
-        && test1Logical<int8_t>()
-        && testVLogical<int8_t, 2>()
-        && testVLogical<int8_t, 3>()
-        && testVLogical<int8_t, 4>()
-        && test1Logical<int16_t>()
-        && testVLogical<int16_t, 2>()
-        && testVLogical<int16_t, 3>()
-        && testVLogical<int16_t, 4>()
-        && test1Logical<int64_t>()
-        && testVLogical<int64_t, 2>()
-        && testVLogical<int64_t, 3>()
-        && testVLogical<int64_t, 4>()
-        && test1Logical<uint>()
-        && testVLogical<uint, 2>()
-        && testVLogical<uint, 3>()
-        && testVLogical<uint, 4>()
-        && test1Logical<uint8_t>()
-        && testVLogical<uint8_t, 2>()
-        && testVLogical<uint8_t, 3>()
-        && testVLogical<uint8_t, 4>()
-        && test1Logical<uint16_t>()
-        && testVLogical<uint16_t, 2>()
-        && testVLogical<uint16_t, 3>()
-        && testVLogical<uint16_t, 4>()
-        && test1Logical<uint64_t>()
-        && testVLogical<uint64_t, 2>()
-        && testVLogical<uint64_t, 3>()
-        && testVLogical<uint64_t, 4>()
-        && test1Logical<bool>()
-        && testVLogical<bool, 2>()
-        && testVLogical<bool, 3>()
-        && testVLogical<bool, 4>()
+        & test1Logical<int>()
+        & testVLogical<int, 2>()
+        & testVLogical<int, 3>()
+        & testVLogical<int, 4>()
+        & test1Logical<int8_t>()
+        & testVLogical<int8_t, 2>()
+        & testVLogical<int8_t, 3>()
+        & testVLogical<int8_t, 4>()
+        & test1Logical<int16_t>()
+        & testVLogical<int16_t, 2>()
+        & testVLogical<int16_t, 3>()
+        & testVLogical<int16_t, 4>()
+        & test1Logical<int64_t>()
+        & testVLogical<int64_t, 2>()
+        & testVLogical<int64_t, 3>()
+        & testVLogical<int64_t, 4>()
+        & test1Logical<uint>()
+        & testVLogical<uint, 2>()
+        & testVLogical<uint, 3>()
+        & testVLogical<uint, 4>()
+        & test1Logical<uint8_t>()
+        & testVLogical<uint8_t, 2>()
+        & testVLogical<uint8_t, 3>()
+        & testVLogical<uint8_t, 4>()
+        & test1Logical<uint16_t>()
+        & testVLogical<uint16_t, 2>()
+        & testVLogical<uint16_t, 3>()
+        & testVLogical<uint16_t, 4>()
+        & test1Logical<uint64_t>()
+        & testVLogical<uint64_t, 2>()
+        & testVLogical<uint64_t, 3>()
+        & testVLogical<uint64_t, 4>()
+        & test1Logical<bool>()
+        & testVLogical<bool, 2>()
+        & testVLogical<bool, 3>()
+        & testVLogical<bool, 4>()
         ;
 }
 
 __generic<T : __BuiltinArithmeticType>
 bool test1Arithmetic() {
     return true
-        && subgroupExclusiveAdd(T(1)) == T(3)
-        && subgroupExclusiveMul(T(1)) == T(1)
-        && subgroupExclusiveMin(T(1)) == T(1)
-        && subgroupExclusiveMax(T(1)) == T(1)
+        & subgroupExclusiveAdd(T(1)) == T(3)
+        & subgroupExclusiveMul(T(1)) == T(1)
+        & subgroupExclusiveMin(T(1)) == T(1)
+        & subgroupExclusiveMax(T(1)) == T(1)
         ;
 }
 __generic<T : __BuiltinArithmeticType, let N : int>
@@ -106,59 +106,59 @@ bool testVArithmetic() {
     typealias gvec = vector<T, N>;
 
     return true
-        && subgroupExclusiveAdd(gvec(T(1))) == gvec(T(3))
-        && subgroupExclusiveMul(gvec(T(1))) == gvec(T(1))
-        && subgroupExclusiveMin(gvec(T(1))) == gvec(T(1))
-        && subgroupExclusiveMax(gvec(T(1))) == gvec(T(1))
+        & subgroupExclusiveAdd(gvec(T(1))) == gvec(T(3))
+        & subgroupExclusiveMul(gvec(T(1))) == gvec(T(1))
+        & subgroupExclusiveMin(gvec(T(1))) == gvec(T(1))
+        & subgroupExclusiveMax(gvec(T(1))) == gvec(T(1))
         ;
 }
 
 bool testArithmetic() {
     return true
-        && test1Arithmetic<float>()
-        && testVArithmetic<float, 2>()
-        && testVArithmetic<float, 3>()
-        && testVArithmetic<float, 4>()
-        && test1Arithmetic<double>() // WARNING: intel GPU's lack FP64 support
-        && testVArithmetic<double, 2>()
-        && testVArithmetic<double, 3>()
-        && testVArithmetic<double, 4>()
-        && test1Arithmetic<half>()
-        && testVArithmetic<half, 2>()
-        && testVArithmetic<half, 3>()
-        && testVArithmetic<half, 4>()
-        && test1Arithmetic<int>()
-        && testVArithmetic<int, 2>()
-        && testVArithmetic<int, 3>()
-        && testVArithmetic<int, 4>()
-        && test1Arithmetic<int8_t>() 
-        && testVArithmetic<int8_t, 2>()
-        && testVArithmetic<int8_t, 3>()
-        && testVArithmetic<int8_t, 4>()
-        && test1Arithmetic<int16_t>() 
-        && testVArithmetic<int16_t, 2>()
-        && testVArithmetic<int16_t, 3>()
-        && testVArithmetic<int16_t, 4>()
-        && test1Arithmetic<int64_t>() 
-        && testVArithmetic<int64_t, 2>()
-        && testVArithmetic<int64_t, 3>()
-        && testVArithmetic<int64_t, 4>()
-        && test1Arithmetic<uint>()
-        && testVArithmetic<uint, 2>()
-        && testVArithmetic<uint, 3>()
-        && testVArithmetic<uint, 4>()
-        && test1Arithmetic<uint8_t>() 
-        && testVArithmetic<uint8_t, 2>()
-        && testVArithmetic<uint8_t, 3>()
-        && testVArithmetic<uint8_t, 4>()
-        && test1Arithmetic<uint16_t>() 
-        && testVArithmetic<uint16_t, 2>()
-        && testVArithmetic<uint16_t, 3>()
-        && testVArithmetic<uint16_t, 4>()
-        && test1Arithmetic<uint64_t>() 
-        && testVArithmetic<uint64_t, 2>()
-        && testVArithmetic<uint64_t, 3>()
-        && testVArithmetic<uint64_t, 4>()
+        & test1Arithmetic<float>()
+        & testVArithmetic<float, 2>()
+        & testVArithmetic<float, 3>()
+        & testVArithmetic<float, 4>()
+        & test1Arithmetic<double>() // WARNING: intel GPU's lack FP64 support
+        & testVArithmetic<double, 2>()
+        & testVArithmetic<double, 3>()
+        & testVArithmetic<double, 4>()
+        & test1Arithmetic<half>()
+        & testVArithmetic<half, 2>()
+        & testVArithmetic<half, 3>()
+        & testVArithmetic<half, 4>()
+        & test1Arithmetic<int>()
+        & testVArithmetic<int, 2>()
+        & testVArithmetic<int, 3>()
+        & testVArithmetic<int, 4>()
+        & test1Arithmetic<int8_t>() 
+        & testVArithmetic<int8_t, 2>()
+        & testVArithmetic<int8_t, 3>()
+        & testVArithmetic<int8_t, 4>()
+        & test1Arithmetic<int16_t>() 
+        & testVArithmetic<int16_t, 2>()
+        & testVArithmetic<int16_t, 3>()
+        & testVArithmetic<int16_t, 4>()
+        & test1Arithmetic<int64_t>() 
+        & testVArithmetic<int64_t, 2>()
+        & testVArithmetic<int64_t, 3>()
+        & testVArithmetic<int64_t, 4>()
+        & test1Arithmetic<uint>()
+        & testVArithmetic<uint, 2>()
+        & testVArithmetic<uint, 3>()
+        & testVArithmetic<uint, 4>()
+        & test1Arithmetic<uint8_t>() 
+        & testVArithmetic<uint8_t, 2>()
+        & testVArithmetic<uint8_t, 3>()
+        & testVArithmetic<uint8_t, 4>()
+        & test1Arithmetic<uint16_t>() 
+        & testVArithmetic<uint16_t, 2>()
+        & testVArithmetic<uint16_t, 3>()
+        & testVArithmetic<uint16_t, 4>()
+        & test1Arithmetic<uint64_t>() 
+        & testVArithmetic<uint64_t, 2>()
+        & testVArithmetic<uint64_t, 3>()
+        & testVArithmetic<uint64_t, 4>()
         ;
 }
 
@@ -166,11 +166,11 @@ void computeMain()
 {
 
     bool res0 = true
-            && testLogical()
+            & testLogical()
             ;
     
     bool res1 = true
-            && testArithmetic()
+            & testArithmetic()
             ;
 
     if (gl_LocalInvocationID.x == 3) {
diff --git a/tests/glsl-intrinsic/shader-subgroup/shader-subgroup-arithmetic_Inclusive.slang b/tests/glsl-intrinsic/shader-subgroup/shader-subgroup-arithmetic_Inclusive.slang
index 09c6bdbdf..4d6dd9c2f 100644
--- a/tests/glsl-intrinsic/shader-subgroup/shader-subgroup-arithmetic_Inclusive.slang
+++ b/tests/glsl-intrinsic/shader-subgroup/shader-subgroup-arithmetic_Inclusive.slang
@@ -31,9 +31,9 @@ __generic<T : __BuiltinLogicalType>
 bool test1Logical() {
     return true
 #if defined(TEST_when_logical_operators_are_implemented)
-        && subgroupInclusiveAnd(T(1)) == T(1)
-        && subgroupInclusiveOr(T(1)) == T(1)
-        && subgroupInclusiveXor(T(1)) == T(0)
+        & subgroupInclusiveAnd(T(1)) == T(1)
+        & subgroupInclusiveOr(T(1)) == T(1)
+        & subgroupInclusiveXor(T(1)) == T(0)
 #endif // #if defined(TEST_when_logical_operators_are_implemented)
         ;
 }
@@ -44,61 +44,61 @@ bool testVLogical() {
 
     return true
 #if defined(TEST_when_logical_operators_are_implemented)
-        && subgroupInclusiveAnd(gvec(T(1))) == gvec(T(1))
-        && subgroupInclusiveOr(gvec(T(1))) == gvec(T(1))
-        && subgroupInclusiveXor(gvec(T(1))) == gvec(T(0))
+        & subgroupInclusiveAnd(gvec(T(1))) == gvec(T(1))
+        & subgroupInclusiveOr(gvec(T(1))) == gvec(T(1))
+        & subgroupInclusiveXor(gvec(T(1))) == gvec(T(0))
 #endif // #if defined(TEST_when_logical_operators_are_implemented)
         ;
 }
 
 bool testLogical() {
     return true
-        && test1Logical<int>()
-        && testVLogical<int, 2>()
-        && testVLogical<int, 3>()
-        && testVLogical<int, 4>()
-        && test1Logical<int8_t>()
-        && testVLogical<int8_t, 2>()
-        && testVLogical<int8_t, 3>()
-        && testVLogical<int8_t, 4>()
-        && test1Logical<int16_t>()
-        && testVLogical<int16_t, 2>()
-        && testVLogical<int16_t, 3>()
-        && testVLogical<int16_t, 4>()
-        && test1Logical<int64_t>()
-        && testVLogical<int64_t, 2>()
-        && testVLogical<int64_t, 3>()
-        && testVLogical<int64_t, 4>()
-        && test1Logical<uint>()
-        && testVLogical<uint, 2>()
-        && testVLogical<uint, 3>()
-        && testVLogical<uint, 4>()
-        && test1Logical<uint8_t>()
-        && testVLogical<uint8_t, 2>()
-        && testVLogical<uint8_t, 3>()
-        && testVLogical<uint8_t, 4>()
-        && test1Logical<uint16_t>()
-        && testVLogical<uint16_t, 2>()
-        && testVLogical<uint16_t, 3>()
-        && testVLogical<uint16_t, 4>()
-        && test1Logical<uint64_t>()
-        && testVLogical<uint64_t, 2>()
-        && testVLogical<uint64_t, 3>()
-        && testVLogical<uint64_t, 4>()
-        && test1Logical<bool>()
-        && testVLogical<bool, 2>()
-        && testVLogical<bool, 3>()
-        && testVLogical<bool, 4>()
+        & test1Logical<int>()
+        & testVLogical<int, 2>()
+        & testVLogical<int, 3>()
+        & testVLogical<int, 4>()
+        & test1Logical<int8_t>()
+        & testVLogical<int8_t, 2>()
+        & testVLogical<int8_t, 3>()
+        & testVLogical<int8_t, 4>()
+        & test1Logical<int16_t>()
+        & testVLogical<int16_t, 2>()
+        & testVLogical<int16_t, 3>()
+        & testVLogical<int16_t, 4>()
+        & test1Logical<int64_t>()
+        & testVLogical<int64_t, 2>()
+        & testVLogical<int64_t, 3>()
+        & testVLogical<int64_t, 4>()
+        & test1Logical<uint>()
+        & testVLogical<uint, 2>()
+        & testVLogical<uint, 3>()
+        & testVLogical<uint, 4>()
+        & test1Logical<uint8_t>()
+        & testVLogical<uint8_t, 2>()
+        & testVLogical<uint8_t, 3>()
+        & testVLogical<uint8_t, 4>()
+        & test1Logical<uint16_t>()
+        & testVLogical<uint16_t, 2>()
+        & testVLogical<uint16_t, 3>()
+        & testVLogical<uint16_t, 4>()
+        & test1Logical<uint64_t>()
+        & testVLogical<uint64_t, 2>()
+        & testVLogical<uint64_t, 3>()
+        & testVLogical<uint64_t, 4>()
+        & test1Logical<bool>()
+        & testVLogical<bool, 2>()
+        & testVLogical<bool, 3>()
+        & testVLogical<bool, 4>()
         ;
 }
 
 __generic<T : __BuiltinArithmeticType>
 bool test1Arithmetic() {
     return true
-        && subgroupInclusiveAdd(T(1)) == T(4)
-        && subgroupInclusiveMul(T(1)) == T(1)
-        && subgroupInclusiveMin(T(1)) == T(1)
-        && subgroupInclusiveMax(T(1)) == T(1)
+        & subgroupInclusiveAdd(T(1)) == T(4)
+        & subgroupInclusiveMul(T(1)) == T(1)
+        & subgroupInclusiveMin(T(1)) == T(1)
+        & subgroupInclusiveMax(T(1)) == T(1)
         ;
 }
 __generic<T : __BuiltinArithmeticType, let N : int>
@@ -106,59 +106,59 @@ bool testVArithmetic() {
     typealias gvec = vector<T, N>;
 
     return true
-        && subgroupInclusiveAdd(gvec(T(1))) == gvec(T(4)) 
-        && subgroupInclusiveMul(gvec(T(1))) == gvec(T(1))
-        && subgroupInclusiveMin(gvec(T(1))) == gvec(T(1))
-        && subgroupInclusiveMax(gvec(T(1))) == gvec(T(1))
+        & subgroupInclusiveAdd(gvec(T(1))) == gvec(T(4)) 
+        & subgroupInclusiveMul(gvec(T(1))) == gvec(T(1))
+        & subgroupInclusiveMin(gvec(T(1))) == gvec(T(1))
+        & subgroupInclusiveMax(gvec(T(1))) == gvec(T(1))
         ;
 }
 
 bool testArithmetic() {
     return true
-        && test1Arithmetic<float>()
-        && testVArithmetic<float, 2>()
-        && testVArithmetic<float, 3>()
-        && testVArithmetic<float, 4>()
-        && test1Arithmetic<double>() // WARNING: intel GPU's lack FP64 support
-        && testVArithmetic<double, 2>()
-        && testVArithmetic<double, 3>()
-        && testVArithmetic<double, 4>()
-        && test1Arithmetic<half>()
-        && testVArithmetic<half, 2>()
-        && testVArithmetic<half, 3>()
-        && testVArithmetic<half, 4>()
-        && test1Arithmetic<int>()
-        && testVArithmetic<int, 2>()
-        && testVArithmetic<int, 3>()
-        && testVArithmetic<int, 4>()
-        && test1Arithmetic<int8_t>() 
-        && testVArithmetic<int8_t, 2>()
-        && testVArithmetic<int8_t, 3>()
-        && testVArithmetic<int8_t, 4>()
-        && test1Arithmetic<int16_t>() 
-        && testVArithmetic<int16_t, 2>()
-        && testVArithmetic<int16_t, 3>()
-        && testVArithmetic<int16_t, 4>()
-        && test1Arithmetic<int64_t>() 
-        && testVArithmetic<int64_t, 2>()
-        && testVArithmetic<int64_t, 3>()
-        && testVArithmetic<int64_t, 4>()
-        && test1Arithmetic<uint>()
-        && testVArithmetic<uint, 2>()
-        && testVArithmetic<uint, 3>()
-        && testVArithmetic<uint, 4>()
-        && test1Arithmetic<uint8_t>() 
-        && testVArithmetic<uint8_t, 2>()
-        && testVArithmetic<uint8_t, 3>()
-        && testVArithmetic<uint8_t, 4>()
-        && test1Arithmetic<uint16_t>() 
-        && testVArithmetic<uint16_t, 2>()
-        && testVArithmetic<uint16_t, 3>()
-        && testVArithmetic<uint16_t, 4>()
-        && test1Arithmetic<uint64_t>() 
-        && testVArithmetic<uint64_t, 2>()
-        && testVArithmetic<uint64_t, 3>()
-        && testVArithmetic<uint64_t, 4>()
+        & test1Arithmetic<float>()
+        & testVArithmetic<float, 2>()
+        & testVArithmetic<float, 3>()
+        & testVArithmetic<float, 4>()
+        & test1Arithmetic<double>() // WARNING: intel GPU's lack FP64 support
+        & testVArithmetic<double, 2>()
+        & testVArithmetic<double, 3>()
+        & testVArithmetic<double, 4>()
+        & test1Arithmetic<half>()
+        & testVArithmetic<half, 2>()
+        & testVArithmetic<half, 3>()
+        & testVArithmetic<half, 4>()
+        & test1Arithmetic<int>()
+        & testVArithmetic<int, 2>()
+        & testVArithmetic<int, 3>()
+        & testVArithmetic<int, 4>()
+        & test1Arithmetic<int8_t>() 
+        & testVArithmetic<int8_t, 2>()
+        & testVArithmetic<int8_t, 3>()
+        & testVArithmetic<int8_t, 4>()
+        & test1Arithmetic<int16_t>() 
+        & testVArithmetic<int16_t, 2>()
+        & testVArithmetic<int16_t, 3>()
+        & testVArithmetic<int16_t, 4>()
+        & test1Arithmetic<int64_t>() 
+        & testVArithmetic<int64_t, 2>()
+        & testVArithmetic<int64_t, 3>()
+        & testVArithmetic<int64_t, 4>()
+        & test1Arithmetic<uint>()
+        & testVArithmetic<uint, 2>()
+        & testVArithmetic<uint, 3>()
+        & testVArithmetic<uint, 4>()
+        & test1Arithmetic<uint8_t>() 
+        & testVArithmetic<uint8_t, 2>()
+        & testVArithmetic<uint8_t, 3>()
+        & testVArithmetic<uint8_t, 4>()
+        & test1Arithmetic<uint16_t>() 
+        & testVArithmetic<uint16_t, 2>()
+        & testVArithmetic<uint16_t, 3>()
+        & testVArithmetic<uint16_t, 4>()
+        & test1Arithmetic<uint64_t>() 
+        & testVArithmetic<uint64_t, 2>()
+        & testVArithmetic<uint64_t, 3>()
+        & testVArithmetic<uint64_t, 4>()
         ;
 }
 
@@ -166,11 +166,11 @@ void computeMain()
 {
 
     bool res0 = true
-            && testLogical()
+            & testLogical()
             ;
     
     bool res1 = true
-            && testArithmetic()
+            & testArithmetic()
             ;
 
     if (gl_LocalInvocationID.x == 3) {
diff --git a/tests/glsl-intrinsic/shader-subgroup/shader-subgroup-arithmetic_None.slang b/tests/glsl-intrinsic/shader-subgroup/shader-subgroup-arithmetic_None.slang
index 5300e6796..a1718bc9b 100644
--- a/tests/glsl-intrinsic/shader-subgroup/shader-subgroup-arithmetic_None.slang
+++ b/tests/glsl-intrinsic/shader-subgroup/shader-subgroup-arithmetic_None.slang
@@ -31,9 +31,9 @@ __generic<T : __BuiltinLogicalType>
 bool test1Logical() {
     return true
 #if defined(TEST_when_logical_operators_are_implemented)
-        && subgroupAnd(T(1)) == T(1)
-        && subgroupOr(T(1)) == T(1)
-        && subgroupXor(T(1)) == T(0) 
+        & subgroupAnd(T(1)) == T(1)
+        & subgroupOr(T(1)) == T(1)
+        & subgroupXor(T(1)) == T(0) 
 #endif // #if defined(TEST_when_logical_operators_are_implemented)
         ;
 }
@@ -44,61 +44,61 @@ bool testVLogical() {
 
     return true
 #if defined(TEST_when_logical_operators_are_implemented)
-        && subgroupAnd(gvec(T(1))) == gvec(T(1))
-        && subgroupOr(gvec(T(1))) == gvec(T(1))
-        && subgroupXor(gvec(T(1))) == gvec(T(0))
+        & subgroupAnd(gvec(T(1))) == gvec(T(1))
+        & subgroupOr(gvec(T(1))) == gvec(T(1))
+        & subgroupXor(gvec(T(1))) == gvec(T(0))
 #endif // #if defined(TEST_when_logical_operators_are_implemented)
         ;
 }
 
 bool testLogical() {
     return true
-        && test1Logical<int>()
-        && testVLogical<int, 2>()
-        && testVLogical<int, 3>()
-        && testVLogical<int, 4>()
-        && test1Logical<int8_t>()
-        && testVLogical<int8_t, 2>()
-        && testVLogical<int8_t, 3>()
-        && testVLogical<int8_t, 4>()
-        && test1Logical<int16_t>()
-        && testVLogical<int16_t, 2>()
-        && testVLogical<int16_t, 3>()
-        && testVLogical<int16_t, 4>()
-        && test1Logical<int64_t>()
-        && testVLogical<int64_t, 2>()
-        && testVLogical<int64_t, 3>()
-        && testVLogical<int64_t, 4>()
-        && test1Logical<uint>()
-        && testVLogical<uint, 2>()
-        && testVLogical<uint, 3>()
-        && testVLogical<uint, 4>()
-        && test1Logical<uint8_t>()
-        && testVLogical<uint8_t, 2>()
-        && testVLogical<uint8_t, 3>()
-        && testVLogical<uint8_t, 4>()
-        && test1Logical<uint16_t>()
-        && testVLogical<uint16_t, 2>()
-        && testVLogical<uint16_t, 3>()
-        && testVLogical<uint16_t, 4>()
-        && test1Logical<uint64_t>()
-        && testVLogical<uint64_t, 2>()
-        && testVLogical<uint64_t, 3>()
-        && testVLogical<uint64_t, 4>()
-        && test1Logical<bool>()
-        && testVLogical<bool, 2>()
-        && testVLogical<bool, 3>()
-        && testVLogical<bool, 4>()
+        & test1Logical<int>()
+        & testVLogical<int, 2>()
+        & testVLogical<int, 3>()
+        & testVLogical<int, 4>()
+        & test1Logical<int8_t>()
+        & testVLogical<int8_t, 2>()
+        & testVLogical<int8_t, 3>()
+        & testVLogical<int8_t, 4>()
+        & test1Logical<int16_t>()
+        & testVLogical<int16_t, 2>()
+        & testVLogical<int16_t, 3>()
+        & testVLogical<int16_t, 4>()
+        & test1Logical<int64_t>()
+        & testVLogical<int64_t, 2>()
+        & testVLogical<int64_t, 3>()
+        & testVLogical<int64_t, 4>()
+        & test1Logical<uint>()
+        & testVLogical<uint, 2>()
+        & testVLogical<uint, 3>()
+        & testVLogical<uint, 4>()
+        & test1Logical<uint8_t>()
+        & testVLogical<uint8_t, 2>()
+        & testVLogical<uint8_t, 3>()
+        & testVLogical<uint8_t, 4>()
+        & test1Logical<uint16_t>()
+        & testVLogical<uint16_t, 2>()
+        & testVLogical<uint16_t, 3>()
+        & testVLogical<uint16_t, 4>()
+        & test1Logical<uint64_t>()
+        & testVLogical<uint64_t, 2>()
+        & testVLogical<uint64_t, 3>()
+        & testVLogical<uint64_t, 4>()
+        & test1Logical<bool>()
+        & testVLogical<bool, 2>()
+        & testVLogical<bool, 3>()
+        & testVLogical<bool, 4>()
         ;
 }
 
 __generic<T : __BuiltinArithmeticType>
 bool test1Arithmetic() {
     return true
-        && subgroupAdd(T(1)) == T(local_size_x_v) // 32
-        && subgroupMul(T(1)) == T(1)
-        && subgroupMin(T(1)) == T(1)
-        && subgroupMax(T(1)) == T(1)
+        & subgroupAdd(T(1)) == T(local_size_x_v) // 32
+        & subgroupMul(T(1)) == T(1)
+        & subgroupMin(T(1)) == T(1)
+        & subgroupMax(T(1)) == T(1)
         ;
 }
 __generic<T : __BuiltinArithmeticType, let N : int>
@@ -106,59 +106,59 @@ bool testVArithmetic() {
     typealias gvec = vector<T, N>;
 
     return true
-        && subgroupAdd(gvec(T(1))) == gvec(T(local_size_x_v)) // 32
-        && subgroupMul(gvec(T(1))) == gvec(T(1))
-        && subgroupMin(gvec(T(1))) == gvec(T(1))
-        && subgroupMax(gvec(T(1))) == gvec(T(1))
+        & subgroupAdd(gvec(T(1))) == gvec(T(local_size_x_v)) // 32
+        & subgroupMul(gvec(T(1))) == gvec(T(1))
+        & subgroupMin(gvec(T(1))) == gvec(T(1))
+        & subgroupMax(gvec(T(1))) == gvec(T(1))
         ;
 }
 
 bool testArithmetic() {
     return true
-        && test1Arithmetic<float>()
-        && testVArithmetic<float, 2>()
-        && testVArithmetic<float, 3>()
-        && testVArithmetic<float, 4>()
-        && test1Arithmetic<double>() // WARNING: intel GPU's lack FP64 support
-        && testVArithmetic<double, 2>()
-        && testVArithmetic<double, 3>()
-        && testVArithmetic<double, 4>()
-        && test1Arithmetic<half>()
-        && testVArithmetic<half, 2>()
-        && testVArithmetic<half, 3>()
-        && testVArithmetic<half, 4>()
-        && test1Arithmetic<int>()
-        && testVArithmetic<int, 2>()
-        && testVArithmetic<int, 3>()
-        && testVArithmetic<int, 4>()
-        && test1Arithmetic<int8_t>() 
-        && testVArithmetic<int8_t, 2>()
-        && testVArithmetic<int8_t, 3>()
-        && testVArithmetic<int8_t, 4>()
-        && test1Arithmetic<int16_t>() 
-        && testVArithmetic<int16_t, 2>()
-        && testVArithmetic<int16_t, 3>()
-        && testVArithmetic<int16_t, 4>()
-        && test1Arithmetic<int64_t>() 
-        && testVArithmetic<int64_t, 2>()
-        && testVArithmetic<int64_t, 3>()
-        && testVArithmetic<int64_t, 4>()
-        && test1Arithmetic<uint>()
-        && testVArithmetic<uint, 2>()
-        && testVArithmetic<uint, 3>()
-        && testVArithmetic<uint, 4>()
-        && test1Arithmetic<uint8_t>() 
-        && testVArithmetic<uint8_t, 2>()
-        && testVArithmetic<uint8_t, 3>()
-        && testVArithmetic<uint8_t, 4>()
-        && test1Arithmetic<uint16_t>() 
-        && testVArithmetic<uint16_t, 2>()
-        && testVArithmetic<uint16_t, 3>()
-        && testVArithmetic<uint16_t, 4>()
-        && test1Arithmetic<uint64_t>() 
-        && testVArithmetic<uint64_t, 2>()
-        && testVArithmetic<uint64_t, 3>()
-        && testVArithmetic<uint64_t, 4>()
+        & test1Arithmetic<float>()
+        & testVArithmetic<float, 2>()
+        & testVArithmetic<float, 3>()
+        & testVArithmetic<float, 4>()
+        & test1Arithmetic<double>() // WARNING: intel GPU's lack FP64 support
+        & testVArithmetic<double, 2>()
+        & testVArithmetic<double, 3>()
+        & testVArithmetic<double, 4>()
+        & test1Arithmetic<half>()
+        & testVArithmetic<half, 2>()
+        & testVArithmetic<half, 3>()
+        & testVArithmetic<half, 4>()
+        & test1Arithmetic<int>()
+        & testVArithmetic<int, 2>()
+        & testVArithmetic<int, 3>()
+        & testVArithmetic<int, 4>()
+        & test1Arithmetic<int8_t>() 
+        & testVArithmetic<int8_t, 2>()
+        & testVArithmetic<int8_t, 3>()
+        & testVArithmetic<int8_t, 4>()
+        & test1Arithmetic<int16_t>() 
+        & testVArithmetic<int16_t, 2>()
+        & testVArithmetic<int16_t, 3>()
+        & testVArithmetic<int16_t, 4>()
+        & test1Arithmetic<int64_t>() 
+        & testVArithmetic<int64_t, 2>()
+        & testVArithmetic<int64_t, 3>()
+        & testVArithmetic<int64_t, 4>()
+        & test1Arithmetic<uint>()
+        & testVArithmetic<uint, 2>()
+        & testVArithmetic<uint, 3>()
+        & testVArithmetic<uint, 4>()
+        & test1Arithmetic<uint8_t>() 
+        & testVArithmetic<uint8_t, 2>()
+        & testVArithmetic<uint8_t, 3>()
+        & testVArithmetic<uint8_t, 4>()
+        & test1Arithmetic<uint16_t>() 
+        & testVArithmetic<uint16_t, 2>()
+        & testVArithmetic<uint16_t, 3>()
+        & testVArithmetic<uint16_t, 4>()
+        & test1Arithmetic<uint64_t>() 
+        & testVArithmetic<uint64_t, 2>()
+        & testVArithmetic<uint64_t, 3>()
+        & testVArithmetic<uint64_t, 4>()
         ;
 }
 
@@ -166,11 +166,11 @@ void computeMain()
 {
 
     bool res0 = true
-            && testLogical()
+            & testLogical()
             ;
     
     bool res1 = true
-            && testArithmetic()
+            & testArithmetic()
             ;
 
     if (gl_LocalInvocationID.x == 3) {
diff --git a/tests/glsl-intrinsic/shader-subgroup/shader-subgroup-ballot.slang b/tests/glsl-intrinsic/shader-subgroup/shader-subgroup-ballot.slang
index 8bbd60689..d6947d2d4 100644
--- a/tests/glsl-intrinsic/shader-subgroup/shader-subgroup-ballot.slang
+++ b/tests/glsl-intrinsic/shader-subgroup/shader-subgroup-ballot.slang
@@ -25,8 +25,8 @@ layout(local_size_x = 32) in;
 __generic<T : __BuiltinLogicalType>
 bool test1BroadcastX() {
     return true
-        && subgroupBroadcast(T(1), 0) == T(1)
-        && subgroupBroadcastFirst(T(1)) == T(1)
+        & subgroupBroadcast(T(1), 0) == T(1)
+        & subgroupBroadcastFirst(T(1)) == T(1)
         ;
 }
 __generic<T : __BuiltinLogicalType, let N : int>
@@ -34,16 +34,16 @@ bool testVBroadcastX() {
     typealias gvec = vector<T, N>;
 
     return true
-        && subgroupBroadcast(gvec(T(1)), 0) == gvec(T(1))
-        && subgroupBroadcastFirst(gvec(T(1))) == gvec(T(1))
+        & subgroupBroadcast(gvec(T(1)), 0) == gvec(T(1))
+        & subgroupBroadcastFirst(gvec(T(1))) == gvec(T(1))
         ;
 }
 
 __generic<T : __BuiltinFloatingPointType>
 bool test1BroadcastX() {
     return true
-        && subgroupBroadcast(T(1), 0) == T(1)
-        && subgroupBroadcastFirst(T(1)) == T(1)
+        & subgroupBroadcast(T(1), 0) == T(1)
+        & subgroupBroadcastFirst(T(1)) == T(1)
         ;
 }
 __generic<T : __BuiltinFloatingPointType, let N : int>
@@ -51,85 +51,85 @@ bool testVBroadcastX() {
     typealias gvec = vector<T, N>;
 
     return true
-        && subgroupBroadcast(gvec(T(1)), 0) == gvec(T(1))
-        && subgroupBroadcastFirst(gvec(T(1))) == gvec(T(1))
+        & subgroupBroadcast(gvec(T(1)), 0) == gvec(T(1))
+        & subgroupBroadcastFirst(gvec(T(1))) == gvec(T(1))
         ;
 }
 bool testBroadcastX() {
     return true
-        && test1BroadcastX<float>()
-        && testVBroadcastX<float, 2>()
-        && testVBroadcastX<float, 3>()
-        && testVBroadcastX<float, 4>()
-        && test1BroadcastX<double>() // WARNING: intel GPU's lack FP64 support
-        && testVBroadcastX<double, 2>()
-        && testVBroadcastX<double, 3>()
-        && testVBroadcastX<double, 4>()
-        && test1BroadcastX<half>() 
-        && testVBroadcastX<half, 2>()
-        && testVBroadcastX<half, 3>()
-        && testVBroadcastX<half, 4>()
-        && test1BroadcastX<int>()
-        && testVBroadcastX<int, 2>()
-        && testVBroadcastX<int, 3>()
-        && testVBroadcastX<int, 4>()
-        && test1BroadcastX<int8_t>() 
-        && testVBroadcastX<int8_t, 2>()
-        && testVBroadcastX<int8_t, 3>()
-        && testVBroadcastX<int8_t, 4>()
-        && test1BroadcastX<int16_t>() 
-        && testVBroadcastX<int16_t, 2>()
-        && testVBroadcastX<int16_t, 3>()
-        && testVBroadcastX<int16_t, 4>()
-        && test1BroadcastX<int64_t>() 
-        && testVBroadcastX<int64_t, 2>()
-        && testVBroadcastX<int64_t, 3>()
-        && testVBroadcastX<int64_t, 4>()
-        && test1BroadcastX<uint>()
-        && testVBroadcastX<uint, 2>()
-        && testVBroadcastX<uint, 3>()
-        && testVBroadcastX<uint, 4>()
-        && test1BroadcastX<uint8_t>() 
-        && testVBroadcastX<uint8_t, 2>()
-        && testVBroadcastX<uint8_t, 3>()
-        && testVBroadcastX<uint8_t, 4>()
-        && test1BroadcastX<uint16_t>() 
-        && testVBroadcastX<uint16_t, 2>()
-        && testVBroadcastX<uint16_t, 3>()
-        && testVBroadcastX<uint16_t, 4>()
-        && test1BroadcastX<uint64_t>() 
-        && testVBroadcastX<uint64_t, 2>()
-        && testVBroadcastX<uint64_t, 3>()
-        && testVBroadcastX<uint64_t, 4>()
-        && test1BroadcastX<bool>()
-        && testVBroadcastX<bool, 2>()
-        && testVBroadcastX<bool, 3>()
-        && testVBroadcastX<bool, 4>()
+        & test1BroadcastX<float>()
+        & testVBroadcastX<float, 2>()
+        & testVBroadcastX<float, 3>()
+        & testVBroadcastX<float, 4>()
+        & test1BroadcastX<double>() // WARNING: intel GPU's lack FP64 support
+        & testVBroadcastX<double, 2>()
+        & testVBroadcastX<double, 3>()
+        & testVBroadcastX<double, 4>()
+        & test1BroadcastX<half>() 
+        & testVBroadcastX<half, 2>()
+        & testVBroadcastX<half, 3>()
+        & testVBroadcastX<half, 4>()
+        & test1BroadcastX<int>()
+        & testVBroadcastX<int, 2>()
+        & testVBroadcastX<int, 3>()
+        & testVBroadcastX<int, 4>()
+        & test1BroadcastX<int8_t>() 
+        & testVBroadcastX<int8_t, 2>()
+        & testVBroadcastX<int8_t, 3>()
+        & testVBroadcastX<int8_t, 4>()
+        & test1BroadcastX<int16_t>() 
+        & testVBroadcastX<int16_t, 2>()
+        & testVBroadcastX<int16_t, 3>()
+        & testVBroadcastX<int16_t, 4>()
+        & test1BroadcastX<int64_t>() 
+        & testVBroadcastX<int64_t, 2>()
+        & testVBroadcastX<int64_t, 3>()
+        & testVBroadcastX<int64_t, 4>()
+        & test1BroadcastX<uint>()
+        & testVBroadcastX<uint, 2>()
+        & testVBroadcastX<uint, 3>()
+        & testVBroadcastX<uint, 4>()
+        & test1BroadcastX<uint8_t>() 
+        & testVBroadcastX<uint8_t, 2>()
+        & testVBroadcastX<uint8_t, 3>()
+        & testVBroadcastX<uint8_t, 4>()
+        & test1BroadcastX<uint16_t>() 
+        & testVBroadcastX<uint16_t, 2>()
+        & testVBroadcastX<uint16_t, 3>()
+        & testVBroadcastX<uint16_t, 4>()
+        & test1BroadcastX<uint64_t>() 
+        & testVBroadcastX<uint64_t, 2>()
+        & testVBroadcastX<uint64_t, 3>()
+        & testVBroadcastX<uint64_t, 4>()
+        & test1BroadcastX<bool>()
+        & testVBroadcastX<bool, 2>()
+        & testVBroadcastX<bool, 3>()
+        & testVBroadcastX<bool, 4>()
         ;
 }
 
 bool testBallot() {
     return true 
-        && (subgroupBallot(true).x == 0xFFFFFFFF)
-        && (subgroupInverseBallot(uvec4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF)) == true)
-        && (subgroupBallotBitExtract(uvec4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF), 0) == true)
-        && (subgroupBallotBitCount(uvec4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF)) == 32)
-        && (subgroupBallotInclusiveBitCount(uvec4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF)) != 0)
+        & (subgroupBallot(true).x == 0xFFFFFFFF)
+        & (subgroupInverseBallot(uvec4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF)) == true)
+        & (subgroupBallotBitExtract(uvec4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF), 0) == true)
+        & (subgroupBallotBitCount(uvec4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF)) == 32)
+        & (subgroupBallotInclusiveBitCount(uvec4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF)) != 0)
 #ifdef TEST_when_glsl_subgroupBallotExclusiveBitCount_is_not_bugged
-        && (subgroupBallotExclusiveBitCount(uvec4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF)) != 0)
+        & (subgroupBallotExclusiveBitCount(uvec4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF)) != 0)
 #endif
-        && (subgroupBallotFindLSB(uvec4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF)) == 0)
-        && (subgroupBallotFindMSB(uvec4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF)) == 31)
+        & (subgroupBallotFindLSB(uvec4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF)) == 0)
+        & (subgroupBallotFindMSB(uvec4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF)) == 31)
         ;
 }
 
 void computeMain()
 {
     outputBuffer.data[0] = true
-        && testBroadcastX()
+        & testBroadcastX()
         ;
     outputBuffer.data[1] = true
-        && testBallot()
+        & testBallot()
         ;
 
     // CHECK_GLSL: void main(
diff --git a/tests/glsl-intrinsic/shader-subgroup/shader-subgroup-clustered.slang b/tests/glsl-intrinsic/shader-subgroup/shader-subgroup-clustered.slang
index 9e9b089d2..c40421aa1 100644
--- a/tests/glsl-intrinsic/shader-subgroup/shader-subgroup-clustered.slang
+++ b/tests/glsl-intrinsic/shader-subgroup/shader-subgroup-clustered.slang
@@ -23,9 +23,9 @@ layout(local_size_x = 32) in;
 __generic<T : __BuiltinLogicalType>
 bool test1Logical() {
     return true
-        && subgroupClusteredAnd(T(1), 1) == T(1)
-        && subgroupClusteredOr(T(1), 1) == T(1)
-        && subgroupClusteredXor(T(1), 1) == T(1)
+        & subgroupClusteredAnd(T(1), 1) == T(1)
+        & subgroupClusteredOr(T(1), 1) == T(1)
+        & subgroupClusteredXor(T(1), 1) == T(1)
         ;
 }
 
@@ -34,60 +34,60 @@ bool testVLogical() {
     typealias gvec = vector<T, N>;
 
     return true
-        && subgroupClusteredAnd(gvec(T(1)), 1) == gvec(T(1))
-        && subgroupClusteredOr(gvec(T(1)), 1) == gvec(T(1))
-        && subgroupClusteredXor(gvec(T(1)), 1) == gvec(T(1))   
+        & subgroupClusteredAnd(gvec(T(1)), 1) == gvec(T(1))
+        & subgroupClusteredOr(gvec(T(1)), 1) == gvec(T(1))
+        & subgroupClusteredXor(gvec(T(1)), 1) == gvec(T(1))   
         ;     
 }
 
 bool testLogical() {
     return true
-        && test1Logical<int>()
-        && testVLogical<int, 2>()
-        && testVLogical<int, 3>()
-        && testVLogical<int, 4>()
-        && test1Logical<int8_t>()
-        && testVLogical<int8_t, 2>()
-        && testVLogical<int8_t, 3>()
-        && testVLogical<int8_t, 4>()
-        && test1Logical<int16_t>()
-        && testVLogical<int16_t, 2>()
-        && testVLogical<int16_t, 3>()
-        && testVLogical<int16_t, 4>()
-        && test1Logical<int64_t>()
-        && testVLogical<int64_t, 2>()
-        && testVLogical<int64_t, 3>()
-        && testVLogical<int64_t, 4>()
-        && test1Logical<uint>()
-        && testVLogical<uint, 2>()
-        && testVLogical<uint, 3>()
-        && testVLogical<uint, 4>()
-        && test1Logical<uint8_t>()
-        && testVLogical<uint8_t, 2>()
-        && testVLogical<uint8_t, 3>()
-        && testVLogical<uint8_t, 4>()
-        && test1Logical<uint16_t>()
-        && testVLogical<uint16_t, 2>()
-        && testVLogical<uint16_t, 3>()
-        && testVLogical<uint16_t, 4>()
-        && test1Logical<uint64_t>()
-        && testVLogical<uint64_t, 2>()
-        && testVLogical<uint64_t, 3>()
-        && testVLogical<uint64_t, 4>()
-        && test1Logical<bool>()
-        && testVLogical<bool, 2>()
-        && testVLogical<bool, 3>()
-        && testVLogical<bool, 4>()
+        & test1Logical<int>()
+        & testVLogical<int, 2>()
+        & testVLogical<int, 3>()
+        & testVLogical<int, 4>()
+        & test1Logical<int8_t>()
+        & testVLogical<int8_t, 2>()
+        & testVLogical<int8_t, 3>()
+        & testVLogical<int8_t, 4>()
+        & test1Logical<int16_t>()
+        & testVLogical<int16_t, 2>()
+        & testVLogical<int16_t, 3>()
+        & testVLogical<int16_t, 4>()
+        & test1Logical<int64_t>()
+        & testVLogical<int64_t, 2>()
+        & testVLogical<int64_t, 3>()
+        & testVLogical<int64_t, 4>()
+        & test1Logical<uint>()
+        & testVLogical<uint, 2>()
+        & testVLogical<uint, 3>()
+        & testVLogical<uint, 4>()
+        & test1Logical<uint8_t>()
+        & testVLogical<uint8_t, 2>()
+        & testVLogical<uint8_t, 3>()
+        & testVLogical<uint8_t, 4>()
+        & test1Logical<uint16_t>()
+        & testVLogical<uint16_t, 2>()
+        & testVLogical<uint16_t, 3>()
+        & testVLogical<uint16_t, 4>()
+        & test1Logical<uint64_t>()
+        & testVLogical<uint64_t, 2>()
+        & testVLogical<uint64_t, 3>()
+        & testVLogical<uint64_t, 4>()
+        & test1Logical<bool>()
+        & testVLogical<bool, 2>()
+        & testVLogical<bool, 3>()
+        & testVLogical<bool, 4>()
         ;
 }
 
 __generic<T : __BuiltinArithmeticType>
 bool test1Arithmetic() {
     return true
-        && subgroupClusteredAdd(T(1), 1) == T(1)
-        && subgroupClusteredMul(T(1), 1) == T(1)
-        && subgroupClusteredMin(T(1), 1) == T(1)
-        && subgroupClusteredMax(T(1), 1) == T(1)
+        & subgroupClusteredAdd(T(1), 1) == T(1)
+        & subgroupClusteredMul(T(1), 1) == T(1)
+        & subgroupClusteredMin(T(1), 1) == T(1)
+        & subgroupClusteredMax(T(1), 1) == T(1)
         ;
 }
 
@@ -96,69 +96,69 @@ bool testVArithmetic() {
     typealias gvec = vector<T, N>;
 
     return true
-        && subgroupClusteredAdd(gvec(T(1)), 1) == gvec(T(1))
-        && subgroupClusteredMul(gvec(T(1)), 1) == gvec(T(1))
-        && subgroupClusteredMin(gvec(T(1)), 1) == gvec(T(1))
-        && subgroupClusteredMax(gvec(T(1)), 1) == gvec(T(1))
+        & subgroupClusteredAdd(gvec(T(1)), 1) == gvec(T(1))
+        & subgroupClusteredMul(gvec(T(1)), 1) == gvec(T(1))
+        & subgroupClusteredMin(gvec(T(1)), 1) == gvec(T(1))
+        & subgroupClusteredMax(gvec(T(1)), 1) == gvec(T(1))
         ;
 }
 
 bool testArithmetic() {
     return true
-        && test1Arithmetic<float>()
-        && testVArithmetic<float, 2>()
-        && testVArithmetic<float, 3>()
-        && testVArithmetic<float, 4>()
-        && test1Arithmetic<double>() // WARNING: intel GPU's lack FP64 support
-        && testVArithmetic<double, 2>() 
-        && testVArithmetic<double, 3>()
-        && testVArithmetic<double, 4>()
-        && test1Arithmetic<half>() 
-        && testVArithmetic<half, 2>()
-        && testVArithmetic<half, 3>()
-        && testVArithmetic<half, 4>()
-        && test1Arithmetic<int>()
-        && testVArithmetic<int, 2>()
-        && testVArithmetic<int, 3>()
-        && testVArithmetic<int, 4>()
-        && test1Arithmetic<int8_t>() 
-        && testVArithmetic<int8_t, 2>()
-        && testVArithmetic<int8_t, 3>()
-        && testVArithmetic<int8_t, 4>()
-        && test1Arithmetic<int16_t>() 
-        && testVArithmetic<int16_t, 2>()
-        && testVArithmetic<int16_t, 3>()
-        && testVArithmetic<int16_t, 4>()
-        && test1Arithmetic<int64_t>() 
-        && testVArithmetic<int64_t, 2>()
-        && testVArithmetic<int64_t, 3>()
-        && testVArithmetic<int64_t, 4>()
-        && test1Arithmetic<uint>()
-        && testVArithmetic<uint, 2>()
-        && testVArithmetic<uint, 3>()
-        && testVArithmetic<uint, 4>()
-        && test1Arithmetic<uint8_t>() 
-        && testVArithmetic<uint8_t, 2>()
-        && testVArithmetic<uint8_t, 3>()
-        && testVArithmetic<uint8_t, 4>()
-        && test1Arithmetic<uint16_t>() 
-        && testVArithmetic<uint16_t, 2>()
-        && testVArithmetic<uint16_t, 3>()
-        && testVArithmetic<uint16_t, 4>()
-        && test1Arithmetic<uint64_t>() 
-        && testVArithmetic<uint64_t, 2>()
-        && testVArithmetic<uint64_t, 3>()
-        && testVArithmetic<uint64_t, 4>()
+        & test1Arithmetic<float>()
+        & testVArithmetic<float, 2>()
+        & testVArithmetic<float, 3>()
+        & testVArithmetic<float, 4>()
+        & test1Arithmetic<double>() // WARNING: intel GPU's lack FP64 support
+        & testVArithmetic<double, 2>() 
+        & testVArithmetic<double, 3>()
+        & testVArithmetic<double, 4>()
+        & test1Arithmetic<half>() 
+        & testVArithmetic<half, 2>()
+        & testVArithmetic<half, 3>()
+        & testVArithmetic<half, 4>()
+        & test1Arithmetic<int>()
+        & testVArithmetic<int, 2>()
+        & testVArithmetic<int, 3>()
+        & testVArithmetic<int, 4>()
+        & test1Arithmetic<int8_t>() 
+        & testVArithmetic<int8_t, 2>()
+        & testVArithmetic<int8_t, 3>()
+        & testVArithmetic<int8_t, 4>()
+        & test1Arithmetic<int16_t>() 
+        & testVArithmetic<int16_t, 2>()
+        & testVArithmetic<int16_t, 3>()
+        & testVArithmetic<int16_t, 4>()
+        & test1Arithmetic<int64_t>() 
+        & testVArithmetic<int64_t, 2>()
+        & testVArithmetic<int64_t, 3>()
+        & testVArithmetic<int64_t, 4>()
+        & test1Arithmetic<uint>()
+        & testVArithmetic<uint, 2>()
+        & testVArithmetic<uint, 3>()
+        & testVArithmetic<uint, 4>()
+        & test1Arithmetic<uint8_t>() 
+        & testVArithmetic<uint8_t, 2>()
+        & testVArithmetic<uint8_t, 3>()
+        & testVArithmetic<uint8_t, 4>()
+        & test1Arithmetic<uint16_t>() 
+        & testVArithmetic<uint16_t, 2>()
+        & testVArithmetic<uint16_t, 3>()
+        & testVArithmetic<uint16_t, 4>()
+        & test1Arithmetic<uint64_t>() 
+        & testVArithmetic<uint64_t, 2>()
+        & testVArithmetic<uint64_t, 3>()
+        & testVArithmetic<uint64_t, 4>()
         ;
 }
 
 void computeMain()
 {
     outputBuffer.data[0] = true
-        && testLogical()
+        & testLogical()
         ;
     outputBuffer.data[1] = true
-        && testArithmetic()
+        & testArithmetic()
         ;
 
     // CHECK_GLSL: void main(
diff --git a/tests/glsl-intrinsic/shader-subgroup/shader-subgroup-quad.slang b/tests/glsl-intrinsic/shader-subgroup/shader-subgroup-quad.slang
index 5ed6398b2..3465f1b26 100644
--- a/tests/glsl-intrinsic/shader-subgroup/shader-subgroup-quad.slang
+++ b/tests/glsl-intrinsic/shader-subgroup/shader-subgroup-quad.slang
@@ -22,10 +22,10 @@ layout(local_size_x = 4) in;
 __generic<T : __BuiltinLogicalType>
 bool test1QuadX() {
     return true
-        && subgroupQuadSwapHorizontal(T(2)) == T(2)
-        && subgroupQuadSwapVertical(T(2)) == T(2)
-        && subgroupQuadSwapDiagonal(T(3)) == T(3)
-        && subgroupQuadBroadcast(T(1), 1) == T(1)
+        & subgroupQuadSwapHorizontal(T(2)) == T(2)
+        & subgroupQuadSwapVertical(T(2)) == T(2)
+        & subgroupQuadSwapDiagonal(T(3)) == T(3)
+        & subgroupQuadBroadcast(T(1), 1) == T(1)
         ;
 }
 __generic<T : __BuiltinLogicalType, let N : int>
@@ -33,20 +33,20 @@ bool testVQuadX() {
     typealias gvec = vector<T, N>;
 
     return true
-        && subgroupQuadSwapHorizontal(gvec(T(2))) == gvec(T(2))
-        && subgroupQuadSwapVertical(gvec(T(2))) == gvec(T(2))
-        && subgroupQuadSwapDiagonal(gvec(T(3))) == gvec(T(3))
-        && subgroupQuadBroadcast(gvec(T(1)), 1) == gvec(T(1))
+        & subgroupQuadSwapHorizontal(gvec(T(2))) == gvec(T(2))
+        & subgroupQuadSwapVertical(gvec(T(2))) == gvec(T(2))
+        & subgroupQuadSwapDiagonal(gvec(T(3))) == gvec(T(3))
+        & subgroupQuadBroadcast(gvec(T(1)), 1) == gvec(T(1))
         ;
 }
 
 __generic<T : __BuiltinFloatingPointType>
 bool test1QuadX() {
     return true
-        && subgroupQuadSwapHorizontal(T(2)) == T(2)
-        && subgroupQuadSwapVertical(T(2)) == T(2)
-        && subgroupQuadSwapDiagonal(T(3)) == T(3)
-        && subgroupQuadBroadcast(T(1), 1) == T(1)
+        & subgroupQuadSwapHorizontal(T(2)) == T(2)
+        & subgroupQuadSwapVertical(T(2)) == T(2)
+        & subgroupQuadSwapDiagonal(T(3)) == T(3)
+        & subgroupQuadBroadcast(T(1), 1) == T(1)
         ;
 }
 __generic<T : __BuiltinFloatingPointType, let N : int>
@@ -54,62 +54,62 @@ bool testVQuadX() {
     typealias gvec = vector<T, N>;
 
     return true
-        && subgroupQuadSwapHorizontal(gvec(T(2))) == gvec(T(2))
-        && subgroupQuadSwapVertical(gvec(T(2))) == gvec(T(2))
-        && subgroupQuadSwapDiagonal(gvec(T(3))) == gvec(T(3))
-        && subgroupQuadBroadcast(gvec(T(1)), 1) == gvec(T(1))
+        & subgroupQuadSwapHorizontal(gvec(T(2))) == gvec(T(2))
+        & subgroupQuadSwapVertical(gvec(T(2))) == gvec(T(2))
+        & subgroupQuadSwapDiagonal(gvec(T(3))) == gvec(T(3))
+        & subgroupQuadBroadcast(gvec(T(1)), 1) == gvec(T(1))
         ;
 }
 bool testQuadSwapX() {
     return true
-        && test1QuadX<float>()
-        && testVQuadX<float, 2>()
-        && testVQuadX<float, 3>()
-        && testVQuadX<float, 4>()
-        && test1QuadX<double>() // WARNING: intel GPU's lack FP64 support
-        && testVQuadX<double, 2>()
-        && testVQuadX<double, 3>()
-        && testVQuadX<double, 4>()
-        && test1QuadX<half>() 
-        && testVQuadX<half, 2>()
-        && testVQuadX<half, 3>()
-        && testVQuadX<half, 4>()
-        && test1QuadX<int>()
-        && testVQuadX<int, 2>()
-        && testVQuadX<int, 3>()
-        && testVQuadX<int, 4>()
-        && test1QuadX<int8_t>() 
-        && testVQuadX<int8_t, 2>()
-        && testVQuadX<int8_t, 3>()
-        && testVQuadX<int8_t, 4>()
-        && test1QuadX<int16_t>() 
-        && testVQuadX<int16_t, 2>()
-        && testVQuadX<int16_t, 3>()
-        && testVQuadX<int16_t, 4>()
-        && test1QuadX<int64_t>() 
-        && testVQuadX<int64_t, 2>()
-        && testVQuadX<int64_t, 3>()
-        && testVQuadX<int64_t, 4>()
-        && test1QuadX<uint>()
-        && testVQuadX<uint, 2>()
-        && testVQuadX<uint, 3>()
-        && testVQuadX<uint, 4>()
-        && test1QuadX<uint8_t>() 
-        && testVQuadX<uint8_t, 2>()
-        && testVQuadX<uint8_t, 3>()
-        && testVQuadX<uint8_t, 4>()
-        && test1QuadX<uint16_t>() 
-        && testVQuadX<uint16_t, 2>()
-        && testVQuadX<uint16_t, 3>()
-        && testVQuadX<uint16_t, 4>()
-        && test1QuadX<uint64_t>() 
-        && testVQuadX<uint64_t, 2>()
-        && testVQuadX<uint64_t, 3>()
-        && testVQuadX<uint64_t, 4>()
-        && test1QuadX<bool>()
-        && testVQuadX<bool, 2>()
-        && testVQuadX<bool, 3>()
-        && testVQuadX<bool, 4>()
+        & test1QuadX<float>()
+        & testVQuadX<float, 2>()
+        & testVQuadX<float, 3>()
+        & testVQuadX<float, 4>()
+        & test1QuadX<double>() // WARNING: intel GPU's lack FP64 support
+        & testVQuadX<double, 2>()
+        & testVQuadX<double, 3>()
+        & testVQuadX<double, 4>()
+        & test1QuadX<half>() 
+        & testVQuadX<half, 2>()
+        & testVQuadX<half, 3>()
+        & testVQuadX<half, 4>()
+        & test1QuadX<int>()
+        & testVQuadX<int, 2>()
+        & testVQuadX<int, 3>()
+        & testVQuadX<int, 4>()
+        & test1QuadX<int8_t>() 
+        & testVQuadX<int8_t, 2>()
+        & testVQuadX<int8_t, 3>()
+        & testVQuadX<int8_t, 4>()
+        & test1QuadX<int16_t>() 
+        & testVQuadX<int16_t, 2>()
+        & testVQuadX<int16_t, 3>()
+        & testVQuadX<int16_t, 4>()
+        & test1QuadX<int64_t>() 
+        & testVQuadX<int64_t, 2>()
+        & testVQuadX<int64_t, 3>()
+        & testVQuadX<int64_t, 4>()
+        & test1QuadX<uint>()
+        & testVQuadX<uint, 2>()
+        & testVQuadX<uint, 3>()
+        & testVQuadX<uint, 4>()
+        & test1QuadX<uint8_t>() 
+        & testVQuadX<uint8_t, 2>()
+        & testVQuadX<uint8_t, 3>()
+        & testVQuadX<uint8_t, 4>()
+        & test1QuadX<uint16_t>() 
+        & testVQuadX<uint16_t, 2>()
+        & testVQuadX<uint16_t, 3>()
+        & testVQuadX<uint16_t, 4>()
+        & test1QuadX<uint64_t>() 
+        & testVQuadX<uint64_t, 2>()
+        & testVQuadX<uint64_t, 3>()
+        & testVQuadX<uint64_t, 4>()
+        & test1QuadX<bool>()
+        & testVQuadX<bool, 2>()
+        & testVQuadX<bool, 3>()
+        & testVQuadX<bool, 4>()
         ;
 }
 
@@ -117,7 +117,7 @@ void computeMain()
 {
 
     outputBuffer.data[0] = true
-        && testQuadSwapX()
+        & testQuadSwapX()
         ;
 
     // CHECK_GLSL: void main(
diff --git a/tests/glsl-intrinsic/shader-subgroup/shader-subgroup-shuffle-relative.slang b/tests/glsl-intrinsic/shader-subgroup/shader-subgroup-shuffle-relative.slang
index 0e187c568..ea4331dbe 100644
--- a/tests/glsl-intrinsic/shader-subgroup/shader-subgroup-shuffle-relative.slang
+++ b/tests/glsl-intrinsic/shader-subgroup/shader-subgroup-shuffle-relative.slang
@@ -23,8 +23,8 @@ layout(local_size_x = 32) in;
 __generic<T : __BuiltinLogicalType>
 bool test1ShuffleX() {
     return true
-        && subgroupShuffleUp(T(1), 1) == T(1)
-        && subgroupShuffleDown(T(1), 1) == T(1)
+        & subgroupShuffleUp(T(1), 1) == T(1)
+        & subgroupShuffleDown(T(1), 1) == T(1)
         ;
 }
 __generic<T : __BuiltinLogicalType, let N : int>
@@ -32,16 +32,16 @@ bool testVShuffleX() {
     typealias gvec = vector<T, N>;
 
     return true
-        && subgroupShuffleUp(gvec(T(1)), 1) == gvec(T(1))
-        && subgroupShuffleDown(gvec(T(1)), 1) == gvec(T(1))
+        & subgroupShuffleUp(gvec(T(1)), 1) == gvec(T(1))
+        & subgroupShuffleDown(gvec(T(1)), 1) == gvec(T(1))
         ;
 }
 
 __generic<T : __BuiltinFloatingPointType>
 bool test1ShuffleX() {
     return true
-        && subgroupShuffleUp(T(1), 1) == T(1)
-        && subgroupShuffleDown(T(1), 1) == T(1)
+        & subgroupShuffleUp(T(1), 1) == T(1)
+        & subgroupShuffleDown(T(1), 1) == T(1)
         ;
 }
 __generic<T : __BuiltinFloatingPointType, let N : int>
@@ -49,67 +49,67 @@ bool testVShuffleX() {
     typealias gvec = vector<T, N>;
 
     return true
-        && subgroupShuffleUp(gvec(T(1)), 1) == gvec(T(1))
-        && subgroupShuffleDown(gvec(T(1)), 1) == gvec(T(1))
+        & subgroupShuffleUp(gvec(T(1)), 1) == gvec(T(1))
+        & subgroupShuffleDown(gvec(T(1)), 1) == gvec(T(1))
         ;
 }
 bool testShuffleX() {
     return true
-        && test1ShuffleX<float>()
-        && testVShuffleX<float, 2>()
-        && testVShuffleX<float, 3>()
-        && testVShuffleX<float, 4>()
-        && test1ShuffleX<double>() // WARNING: intel GPU's lack FP64 support
-        && testVShuffleX<double, 2>()
-        && testVShuffleX<double, 3>()
-        && testVShuffleX<double, 4>()
-        && test1ShuffleX<half>() 
-        && testVShuffleX<half, 2>()
-        && testVShuffleX<half, 3>()
-        && testVShuffleX<half, 4>()
-        && test1ShuffleX<int>()
-        && testVShuffleX<int, 2>()
-        && testVShuffleX<int, 3>()
-        && testVShuffleX<int, 4>()
-        && test1ShuffleX<int8_t>() 
-        && testVShuffleX<int8_t, 2>()
-        && testVShuffleX<int8_t, 3>()
-        && testVShuffleX<int8_t, 4>()
-        && test1ShuffleX<int16_t>() 
-        && testVShuffleX<int16_t, 2>()
-        && testVShuffleX<int16_t, 3>()
-        && testVShuffleX<int16_t, 4>()
-        && test1ShuffleX<int64_t>() 
-        && testVShuffleX<int64_t, 2>()
-        && testVShuffleX<int64_t, 3>()
-        && testVShuffleX<int64_t, 4>()
-        && test1ShuffleX<uint>()
-        && testVShuffleX<uint, 2>()
-        && testVShuffleX<uint, 3>()
-        && testVShuffleX<uint, 4>()
-        && test1ShuffleX<uint8_t>() 
-        && testVShuffleX<uint8_t, 2>()
-        && testVShuffleX<uint8_t, 3>()
-        && testVShuffleX<uint8_t, 4>()
-        && test1ShuffleX<uint16_t>() 
-        && testVShuffleX<uint16_t, 2>()
-        && testVShuffleX<uint16_t, 3>()
-        && testVShuffleX<uint16_t, 4>()
-        && test1ShuffleX<uint64_t>() 
-        && testVShuffleX<uint64_t, 2>()
-        && testVShuffleX<uint64_t, 3>()
-        && testVShuffleX<uint64_t, 4>()
-        && test1ShuffleX<bool>()
-        && testVShuffleX<bool, 2>()
-        && testVShuffleX<bool, 3>()
-        && testVShuffleX<bool, 4>()
+        & test1ShuffleX<float>()
+        & testVShuffleX<float, 2>()
+        & testVShuffleX<float, 3>()
+        & testVShuffleX<float, 4>()
+        & test1ShuffleX<double>() // WARNING: intel GPU's lack FP64 support
+        & testVShuffleX<double, 2>()
+        & testVShuffleX<double, 3>()
+        & testVShuffleX<double, 4>()
+        & test1ShuffleX<half>() 
+        & testVShuffleX<half, 2>()
+        & testVShuffleX<half, 3>()
+        & testVShuffleX<half, 4>()
+        & test1ShuffleX<int>()
+        & testVShuffleX<int, 2>()
+        & testVShuffleX<int, 3>()
+        & testVShuffleX<int, 4>()
+        & test1ShuffleX<int8_t>() 
+        & testVShuffleX<int8_t, 2>()
+        & testVShuffleX<int8_t, 3>()
+        & testVShuffleX<int8_t, 4>()
+        & test1ShuffleX<int16_t>() 
+        & testVShuffleX<int16_t, 2>()
+        & testVShuffleX<int16_t, 3>()
+        & testVShuffleX<int16_t, 4>()
+        & test1ShuffleX<int64_t>() 
+        & testVShuffleX<int64_t, 2>()
+        & testVShuffleX<int64_t, 3>()
+        & testVShuffleX<int64_t, 4>()
+        & test1ShuffleX<uint>()
+        & testVShuffleX<uint, 2>()
+        & testVShuffleX<uint, 3>()
+        & testVShuffleX<uint, 4>()
+        & test1ShuffleX<uint8_t>() 
+        & testVShuffleX<uint8_t, 2>()
+        & testVShuffleX<uint8_t, 3>()
+        & testVShuffleX<uint8_t, 4>()
+        & test1ShuffleX<uint16_t>() 
+        & testVShuffleX<uint16_t, 2>()
+        & testVShuffleX<uint16_t, 3>()
+        & testVShuffleX<uint16_t, 4>()
+        & test1ShuffleX<uint64_t>() 
+        & testVShuffleX<uint64_t, 2>()
+        & testVShuffleX<uint64_t, 3>()
+        & testVShuffleX<uint64_t, 4>()
+        & test1ShuffleX<bool>()
+        & testVShuffleX<bool, 2>()
+        & testVShuffleX<bool, 3>()
+        & testVShuffleX<bool, 4>()
         ;
 }
 
 void computeMain()
 {
     outputBuffer.data[0] = true
-        && testShuffleX()
+        & testShuffleX()
         ;
 
     // CHECK_GLSL: void main(
diff --git a/tests/glsl-intrinsic/shader-subgroup/shader-subgroup-shuffle.slang b/tests/glsl-intrinsic/shader-subgroup/shader-subgroup-shuffle.slang
index 5dca1a588..ff3baf267 100644
--- a/tests/glsl-intrinsic/shader-subgroup/shader-subgroup-shuffle.slang
+++ b/tests/glsl-intrinsic/shader-subgroup/shader-subgroup-shuffle.slang
@@ -31,9 +31,9 @@ layout(local_size_x = 32) in;
 __generic<T : __BuiltinLogicalType>
 bool test1ShuffleX() {
     return true
-        && subgroupShuffle(T(1), 1) == T(1)
+        & subgroupShuffle(T(1), 1) == T(1)
 #ifdef TEST_when_subgroupShuffleXor_is_implemented
-        && subgroupShuffleXor(T(1), 1) == T(1)
+        & subgroupShuffleXor(T(1), 1) == T(1)
 #endif // #ifdef TEST_when_subgroupShuffleXor_is_implemented
         ;
 }
@@ -42,9 +42,9 @@ bool testVShuffleX() {
     typealias gvec = vector<T, N>;
 
     return true
-        && subgroupShuffle(gvec(T(1)), 1) == gvec(T(1))
+        & subgroupShuffle(gvec(T(1)), 1) == gvec(T(1))
 #ifdef TEST_when_subgroupShuffleXor_is_implemented
-        && subgroupShuffleXor(gvec(T(1)), 1) == gvec(T(1))
+        & subgroupShuffleXor(gvec(T(1)), 1) == gvec(T(1))
 #endif // #ifdef TEST_when_subgroupShuffleXor_is_implemented
         ;
 }
@@ -52,10 +52,10 @@ bool testVShuffleX() {
 __generic<T : __BuiltinFloatingPointType>
 bool test1ShuffleX() {
     return true
-        && subgroupShuffle(T(1), 1) == T(1)
-#if !defined(TARGET_CUDA) && !defined(TARGET_HLSL)
-        && subgroupShuffleXor(T(1), 1) == T(1)
-#endif // #if !defined(TARGET_CUDA) && !defined(TARGET_HLSL)
+        & subgroupShuffle(T(1), 1) == T(1)
+#if !defined(TARGET_CUDA) & !defined(TARGET_HLSL)
+        & subgroupShuffleXor(T(1), 1) == T(1)
+#endif // #if !defined(TARGET_CUDA) & !defined(TARGET_HLSL)
         ;
 }
 __generic<T : __BuiltinFloatingPointType, let N : int>
@@ -63,62 +63,62 @@ bool testVShuffleX() {
     typealias gvec = vector<T, N>;
 
     return true
-        && subgroupShuffle(gvec(T(1)), 1) == gvec(T(1))
-#if !defined(TARGET_CUDA) && !defined(TARGET_HLSL)
-        && subgroupShuffleXor(gvec(T(1)), 1) == gvec(T(1))
-#endif // #if !defined(TARGET_CUDA) && !defined(TARGET_HLSL)
+        & subgroupShuffle(gvec(T(1)), 1) == gvec(T(1))
+#if !defined(TARGET_CUDA) & !defined(TARGET_HLSL)
+        & subgroupShuffleXor(gvec(T(1)), 1) == gvec(T(1))
+#endif // #if !defined(TARGET_CUDA) & !defined(TARGET_HLSL)
         ;
 }
 bool testShuffleX() {
     return true
-        && test1ShuffleX<float>()
-        && testVShuffleX<float, 2>()
-        && testVShuffleX<float, 3>()
-        && testVShuffleX<float, 4>()
-        && test1ShuffleX<double>() // WARNING: intel GPU's lack FP64 support
-        && testVShuffleX<double, 2>()
-        && testVShuffleX<double, 3>()
-        && testVShuffleX<double, 4>()
-        && test1ShuffleX<half>() 
-        && testVShuffleX<half, 2>()
-        && testVShuffleX<half, 3>()
-        && testVShuffleX<half, 4>()
-        && test1ShuffleX<int>()
-        && testVShuffleX<int, 2>()
-        && testVShuffleX<int, 3>()
-        && testVShuffleX<int, 4>()
-        && test1ShuffleX<int8_t>() 
-        && testVShuffleX<int8_t, 2>()
-        && testVShuffleX<int8_t, 3>()
-        && testVShuffleX<int8_t, 4>()
-        && test1ShuffleX<int16_t>() 
-        && testVShuffleX<int16_t, 2>()
-        && testVShuffleX<int16_t, 3>()
-        && testVShuffleX<int16_t, 4>()
-        && test1ShuffleX<int64_t>() 
-        && testVShuffleX<int64_t, 2>()
-        && testVShuffleX<int64_t, 3>()
-        && testVShuffleX<int64_t, 4>()
-        && test1ShuffleX<uint>()
-        && testVShuffleX<uint, 2>()
-        && testVShuffleX<uint, 3>()
-        && testVShuffleX<uint, 4>()
-        && test1ShuffleX<uint8_t>() 
-        && testVShuffleX<uint8_t, 2>()
-        && testVShuffleX<uint8_t, 3>()
-        && testVShuffleX<uint8_t, 4>()
-        && test1ShuffleX<uint16_t>() 
-        && testVShuffleX<uint16_t, 2>()
-        && testVShuffleX<uint16_t, 3>()
-        && testVShuffleX<uint16_t, 4>()
-        && test1ShuffleX<uint64_t>() 
-        && testVShuffleX<uint64_t, 2>()
-        && testVShuffleX<uint64_t, 3>()
-        && testVShuffleX<uint64_t, 4>()
-        && test1ShuffleX<bool>()
-        && testVShuffleX<bool, 2>()
-        && testVShuffleX<bool, 3>()
-        && testVShuffleX<bool, 4>()
+        & test1ShuffleX<float>()
+        & testVShuffleX<float, 2>()
+        & testVShuffleX<float, 3>()
+        & testVShuffleX<float, 4>()
+        & test1ShuffleX<double>() // WARNING: intel GPU's lack FP64 support
+        & testVShuffleX<double, 2>()
+        & testVShuffleX<double, 3>()
+        & testVShuffleX<double, 4>()
+        & test1ShuffleX<half>() 
+        & testVShuffleX<half, 2>()
+        & testVShuffleX<half, 3>()
+        & testVShuffleX<half, 4>()
+        & test1ShuffleX<int>()
+        & testVShuffleX<int, 2>()
+        & testVShuffleX<int, 3>()
+        & testVShuffleX<int, 4>()
+        & test1ShuffleX<int8_t>() 
+        & testVShuffleX<int8_t, 2>()
+        & testVShuffleX<int8_t, 3>()
+        & testVShuffleX<int8_t, 4>()
+        & test1ShuffleX<int16_t>() 
+        & testVShuffleX<int16_t, 2>()
+        & testVShuffleX<int16_t, 3>()
+        & testVShuffleX<int16_t, 4>()
+        & test1ShuffleX<int64_t>() 
+        & testVShuffleX<int64_t, 2>()
+        & testVShuffleX<int64_t, 3>()
+        & testVShuffleX<int64_t, 4>()
+        & test1ShuffleX<uint>()
+        & testVShuffleX<uint, 2>()
+        & testVShuffleX<uint, 3>()
+        & testVShuffleX<uint, 4>()
+        & test1ShuffleX<uint8_t>() 
+        & testVShuffleX<uint8_t, 2>()
+        & testVShuffleX<uint8_t, 3>()
+        & testVShuffleX<uint8_t, 4>()
+        & test1ShuffleX<uint16_t>() 
+        & testVShuffleX<uint16_t, 2>()
+        & testVShuffleX<uint16_t, 3>()
+        & testVShuffleX<uint16_t, 4>()
+        & test1ShuffleX<uint64_t>() 
+        & testVShuffleX<uint64_t, 2>()
+        & testVShuffleX<uint64_t, 3>()
+        & testVShuffleX<uint64_t, 4>()
+        & test1ShuffleX<bool>()
+        & testVShuffleX<bool, 2>()
+        & testVShuffleX<bool, 3>()
+        & testVShuffleX<bool, 4>()
         ;
 }
 
@@ -127,7 +127,7 @@ void computeMain()
 {
 
     outputBuffer.data[0] = true
-        && testShuffleX()
+        & testShuffleX()
         ;
 
     // CHECK_GLSL: void main(
diff --git a/tests/glsl-intrinsic/shader-subgroup/shader-subgroup-vote.slang b/tests/glsl-intrinsic/shader-subgroup/shader-subgroup-vote.slang
index bcd4aeb56..3c700d6d8 100644
--- a/tests/glsl-intrinsic/shader-subgroup/shader-subgroup-vote.slang
+++ b/tests/glsl-intrinsic/shader-subgroup/shader-subgroup-vote.slang
@@ -28,8 +28,8 @@ layout(local_size_x = 32) in;
 __generic<T : __BuiltinLogicalType>
 bool test1AllEqual() {
     return true
-        && subgroupAllEqual(T(1)) == true
-        && subgroupAllEqual(T(gl_GlobalInvocationID.x)) == false
+        & subgroupAllEqual(T(1)) == true
+        & subgroupAllEqual(T(gl_GlobalInvocationID.x)) == false
         ;
 }
 __generic<T : __BuiltinLogicalType, let N : int>
@@ -37,16 +37,16 @@ bool testVAllEqual() {
     typealias gvec = vector<T, N>;
 
     return true
-        && subgroupAllEqual(gvec(T(1))) == true
-        && subgroupAllEqual(gvec(T(gl_GlobalInvocationID.x))) == false
+        & subgroupAllEqual(gvec(T(1))) == true
+        & subgroupAllEqual(gvec(T(gl_GlobalInvocationID.x))) == false
         ;
 }
 
 __generic<T : __BuiltinFloatingPointType>
 bool test1AllEqual() {
     return true
-        && subgroupAllEqual(T(1)) == true
-        && subgroupAllEqual(T(gl_GlobalInvocationID.x)) == false
+        & subgroupAllEqual(T(1)) == true
+        & subgroupAllEqual(T(gl_GlobalInvocationID.x)) == false
         ;
 }
 __generic<T : __BuiltinFloatingPointType, let N : int>
@@ -54,60 +54,60 @@ bool testVAllEqual() {
     typealias gvec = vector<T, N>;
 
     return true
-        && subgroupAllEqual(gvec(T(1))) == true
-        && subgroupAllEqual(gvec(T(gl_GlobalInvocationID.x))) == false
+        & subgroupAllEqual(gvec(T(1))) == true
+        & subgroupAllEqual(gvec(T(gl_GlobalInvocationID.x))) == false
         ;
 }
 bool testAllEqual() {
     return true
-        && test1AllEqual<float>()
-        && testVAllEqual<float, 2>()
-        && testVAllEqual<float, 3>()
-        && testVAllEqual<float, 4>()
-        && test1AllEqual<double>() // WARNING: intel GPU's lack FP64 support
-        && testVAllEqual<double, 2>()
-        && testVAllEqual<double, 3>()
-        && testVAllEqual<double, 4>()
-        && test1AllEqual<half>() 
-        && testVAllEqual<half, 2>()
-        && testVAllEqual<half, 3>()
-        && testVAllEqual<half, 4>()
-        && test1AllEqual<int>()
-        && testVAllEqual<int, 2>()
-        && testVAllEqual<int, 3>()
-        && testVAllEqual<int, 4>()
-        && test1AllEqual<int8_t>() 
-        && testVAllEqual<int8_t, 2>()
-        && testVAllEqual<int8_t, 3>()
-        && testVAllEqual<int8_t, 4>()
-        && test1AllEqual<int16_t>() 
-        && testVAllEqual<int16_t, 2>()
-        && testVAllEqual<int16_t, 3>()
-        && testVAllEqual<int16_t, 4>()
-        && test1AllEqual<int64_t>() 
-        && testVAllEqual<int64_t, 2>()
-        && testVAllEqual<int64_t, 3>()
-        && testVAllEqual<int64_t, 4>()
-        && test1AllEqual<uint>()
-        && testVAllEqual<uint, 2>()
-        && testVAllEqual<uint, 3>()
-        && testVAllEqual<uint, 4>()
-        && test1AllEqual<uint8_t>() 
-        && testVAllEqual<uint8_t, 2>()
-        && testVAllEqual<uint8_t, 3>()
-        && testVAllEqual<uint8_t, 4>()
-        && test1AllEqual<uint16_t>() 
-        && testVAllEqual<uint16_t, 2>()
-        && testVAllEqual<uint16_t, 3>()
-        && testVAllEqual<uint16_t, 4>()
-        && test1AllEqual<uint64_t>() 
-        && testVAllEqual<uint64_t, 2>()
-        && testVAllEqual<uint64_t, 3>()
-        && testVAllEqual<uint64_t, 4>()
-        && test1AllEqual<bool>()
-        && testVAllEqual<bool, 2>()
-        && testVAllEqual<bool, 3>()
-        && testVAllEqual<bool, 4>()
+        & test1AllEqual<float>()
+        & testVAllEqual<float, 2>()
+        & testVAllEqual<float, 3>()
+        & testVAllEqual<float, 4>()
+        & test1AllEqual<double>() // WARNING: intel GPU's lack FP64 support
+        & testVAllEqual<double, 2>()
+        & testVAllEqual<double, 3>()
+        & testVAllEqual<double, 4>()
+        & test1AllEqual<half>() 
+        & testVAllEqual<half, 2>()
+        & testVAllEqual<half, 3>()
+        & testVAllEqual<half, 4>()
+        & test1AllEqual<int>()
+        & testVAllEqual<int, 2>()
+        & testVAllEqual<int, 3>()
+        & testVAllEqual<int, 4>()
+        & test1AllEqual<int8_t>() 
+        & testVAllEqual<int8_t, 2>()
+        & testVAllEqual<int8_t, 3>()
+        & testVAllEqual<int8_t, 4>()
+        & test1AllEqual<int16_t>() 
+        & testVAllEqual<int16_t, 2>()
+        & testVAllEqual<int16_t, 3>()
+        & testVAllEqual<int16_t, 4>()
+        & test1AllEqual<int64_t>() 
+        & testVAllEqual<int64_t, 2>()
+        & testVAllEqual<int64_t, 3>()
+        & testVAllEqual<int64_t, 4>()
+        & test1AllEqual<uint>()
+        & testVAllEqual<uint, 2>()
+        & testVAllEqual<uint, 3>()
+        & testVAllEqual<uint, 4>()
+        & test1AllEqual<uint8_t>() 
+        & testVAllEqual<uint8_t, 2>()
+        & testVAllEqual<uint8_t, 3>()
+        & testVAllEqual<uint8_t, 4>()
+        & test1AllEqual<uint16_t>() 
+        & testVAllEqual<uint16_t, 2>()
+        & testVAllEqual<uint16_t, 3>()
+        & testVAllEqual<uint16_t, 4>()
+        & test1AllEqual<uint64_t>() 
+        & testVAllEqual<uint64_t, 2>()
+        & testVAllEqual<uint64_t, 3>()
+        & testVAllEqual<uint64_t, 4>()
+        & test1AllEqual<bool>()
+        & testVAllEqual<bool, 2>()
+        & testVAllEqual<bool, 3>()
+        & testVAllEqual<bool, 4>()
         ;
 }
 
-- 
cgit v1.2.3