[naga] Disallow logical operators && and || on vectors

CHANGELOG.md

@@ -229,6 +229,7 @@ By @wumpf in [#7144](https://github.com/gfx-rs/wgpu/pull/7144)
 - Allow WGSL const declarations to have abstract types. By @jamienicol in [#7055](https://github.com/gfx-rs/wgpu/pull/7055) and [#7222](https://github.com/gfx-rs/wgpu/pull/7222).
 - Allows override-sized arrays to resolve to the same size without causing the type arena to panic. By @KentSlaney in [#7082](https://github.com/gfx-rs/wgpu/pull/7082).
 - Allow abstract types to be used for WGSL switch statement selector and case selector expressions. By @jamienicol in [#7250](https://github.com/gfx-rs/wgpu/pull/7250).
+- The `&&` and `||` operators are no longer allowed on vectors. By @andyleiserson in [#7368](https://github.com/gfx-rs/wgpu/pull/7368).
 
 #### General
 

naga/src/proc/constant_evaluator.rs

@@ -2102,10 +2102,13 @@ impl<'a> ConstantEvaluator<'a> {
             | BinaryOperator::And
             | BinaryOperator::ExclusiveOr
             | BinaryOperator::InclusiveOr
-            | BinaryOperator::LogicalAnd
-            | BinaryOperator::LogicalOr
             | BinaryOperator::ShiftLeft
             | BinaryOperator::ShiftRight => left_ty,
+
+            BinaryOperator::LogicalAnd | BinaryOperator::LogicalOr => {
+                // Not supported on vectors
+                return Err(ConstantEvaluatorError::InvalidBinaryOpArgs);
+            }
         };
 
         let components = components

naga/src/proc/typifier.rs

@@ -583,9 +583,8 @@ impl<'a> ResolveContext<'a> {
                 | crate::BinaryOperator::Less
                 | crate::BinaryOperator::LessEqual
                 | crate::BinaryOperator::Greater
-                | crate::BinaryOperator::GreaterEqual
-                | crate::BinaryOperator::LogicalAnd
-                | crate::BinaryOperator::LogicalOr => {
+                | crate::BinaryOperator::GreaterEqual => {
+                    // These accept scalars or vectors.
                     let scalar = crate::Scalar::BOOL;
                     let inner = match *past(left)?.inner_with(types) {
                         Ti::Scalar { .. } => Ti::Scalar(scalar),
@@ -598,6 +597,18 @@ impl<'a> ResolveContext<'a> {
                     };
                     TypeResolution::Value(inner)
                 }
+                crate::BinaryOperator::LogicalAnd | crate::BinaryOperator::LogicalOr => {
+                    // These accept scalars only.
+                    let bool = Ti::Scalar(crate::Scalar::BOOL);
+                    let ty = past(left)?.inner_with(types);
+                    if *ty == bool {
+                        TypeResolution::Value(bool)
+                    } else {
+                        return Err(ResolveError::IncompatibleOperands(format!(
+                            "{op:?}({ty:?}, _)"
+                        )));
+                    }
+                }
                 crate::BinaryOperator::And
                 | crate::BinaryOperator::ExclusiveOr
                 | crate::BinaryOperator::InclusiveOr

naga/tests/wgsl_errors.rs

@@ -2837,3 +2837,48 @@ fn reject_utf8_bom() {
 "#,
     );
 }
+
+#[test]
+fn vector_logical_ops() {
+    // Const context
+    check(
+        "const and = vec2(true, false) && vec2(false, false);",
+        r###"error: Cannot apply the binary op to the arguments
+  ┌─ wgsl:1:13
+  │
+1 │ const and = vec2(true, false) && vec2(false, false);
+  │             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ see msg
+
+"###,
+    );
+
+    check(
+        "const or = vec2(true, false) || vec2(false, false);",
+        r###"error: Cannot apply the binary op to the arguments
+  ┌─ wgsl:1:12
+  │
+1 │ const or = vec2(true, false) || vec2(false, false);
+  │            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ see msg
+
+"###,
+    );
+
+    // Runtime context
+    check(
+        "fn foo(a: vec2<bool>, b: vec2<bool>) {
+            let y = a && b;
+        }",
+        r#"error: Incompatible operands: LogicalAnd(Vector { size: Bi, scalar: Scalar { kind: Bool, width: 1 } }, _)
+
+"#,
+    );
+
+    check(
+        "fn foo(a: vec2<bool>, b: vec2<bool>) {
+            let y = a || b;
+        }",
+        r#"error: Incompatible operands: LogicalOr(Vector { size: Bi, scalar: Scalar { kind: Bool, width: 1 } }, _)
+
+"#,
+    );
+}