WIP: constant evaluation for select

Author: ErichDonGubler

naga/src/proc/constant_evaluator.rs

@@ -563,6 +563,8 @@ pub enum ConstantEvaluatorError {
     RuntimeExpr,
     #[error("Unexpected override-expression")]
     OverrideExpr,
+    #[error("Expected boolean expression for condition argument of `select`")]
+    SelectConditionNotABool,
 }
 
 impl<'a> ConstantEvaluator<'a> {
@@ -904,9 +906,46 @@ impl<'a> ConstantEvaluator<'a> {
                     )),
                 }
             }
-            Expression::Select { .. } => Err(ConstantEvaluatorError::NotImplemented(
-                "select built-in function".into(),
-            )),
+            Expression::Select {
+                reject,
+                accept,
+                condition,
+            } => {
+                std::eprintln!("lolwat");
+                let val_arg = |this: &mut Self, expr| {
+                    let expr = this.check_and_get(expr)?;
+                    this.eval_zero_value_and_splat(expr, span)
+                };
+
+                let reject = val_arg(self, reject)?;
+                let Some(reject_scalar) = (match std::dbg!(&self.expressions[reject]) {
+                    &Expression::Literal(lit) => Some(lit.scalar()),
+                    &Expression::Compose { ty, .. } => std::dbg!(&self.types[ty].inner)
+                        .vector_size_and_scalar()
+                        .map(|(_size, scalar)| scalar),
+                    _ => None,
+                }) else {
+                    return Err(ConstantEvaluatorError::InvalidMathArg);
+                };
+
+                let reject = self.cast(reject, std::dbg!(reject_scalar), span)?;
+                let accept = {
+                    let accept = val_arg(self, accept)?;
+                    self.cast(accept, reject_scalar, span)?
+                };
+                let condition = self.check_and_get(condition)?;
+                let condition = match &self.expressions[condition] {
+                    &Expression::Literal(Literal::Bool(bool)) => bool,
+                    _ => return Err(ConstantEvaluatorError::SelectConditionNotABool),
+                };
+                component_wise_scalar!(self, span, [reject, accept], |reject, accept| {
+                    if condition {
+                        Ok([accept])
+                    } else {
+                        Ok([reject])
+                    }
+                })
+            }
             Expression::Relational { fun, argument } => {
                 let argument = self.check_and_get(argument)?;
                 self.relational(fun, argument, span)