From fd5c4db606fee104f6e4c152e43e60e642645052 Mon Sep 17 00:00:00 2001
From: teoxoy <28601907+teoxoy@users.noreply.github.com>
Date: Thu, 14 Mar 2024 18:01:00 +0100
Subject: [PATCH] refactor `try_eval_and_append` body

---
 naga/src/proc/constant_evaluator.rs | 74 +++++++++++++++++------------
 1 file changed, 44 insertions(+), 30 deletions(-)

diff --git a/naga/src/proc/constant_evaluator.rs b/naga/src/proc/constant_evaluator.rs
index 532f364532..f1f01e5855 100644
--- a/naga/src/proc/constant_evaluator.rs
+++ b/naga/src/proc/constant_evaluator.rs
@@ -258,6 +258,17 @@ enum Behavior<'a> {
     Glsl(GlslRestrictions<'a>),
 }
 
+impl Behavior<'_> {
+    /// Returns `true` if the inner WGSL/GLSL restrictions are runtime restrictions.
+    const fn has_runtime_restrictions(&self) -> bool {
+        matches!(
+            self,
+            &Behavior::Wgsl(WgslRestrictions::Runtime(_))
+                | &Behavior::Glsl(GlslRestrictions::Runtime(_))
+        )
+    }
+}
+
 /// A context for evaluating constant expressions.
 ///
 /// A `ConstantEvaluator` points at an expression arena to which it can append
@@ -699,37 +710,40 @@ impl<'a> ConstantEvaluator<'a> {
         expr: Expression,
         span: Span,
     ) -> Result<Handle<Expression>, ConstantEvaluatorError> {
-        match (
-            &self.behavior,
-            self.expression_kind_tracker.type_of_with_expr(&expr),
-        ) {
-            // avoid errors on unimplemented functionality if possible
-            (
-                &Behavior::Wgsl(WgslRestrictions::Runtime(_))
-                | &Behavior::Glsl(GlslRestrictions::Runtime(_)),
-                ExpressionKind::Const,
-            ) => match self.try_eval_and_append_impl(&expr, span) {
-                Err(
-                    ConstantEvaluatorError::NotImplemented(_)
-                    | ConstantEvaluatorError::InvalidBinaryOpArgs,
-                ) => Ok(self.append_expr(expr, span, ExpressionKind::Runtime)),
-                res => res,
-            },
-            (_, ExpressionKind::Const) => self.try_eval_and_append_impl(&expr, span),
-            (&Behavior::Wgsl(WgslRestrictions::Const), ExpressionKind::Override) => {
-                Err(ConstantEvaluatorError::OverrideExpr)
+        match self.expression_kind_tracker.type_of_with_expr(&expr) {
+            ExpressionKind::Const => {
+                let eval_result = self.try_eval_and_append_impl(&expr, span);
+                // avoid errors on unimplemented functionality if possible
+                if self.behavior.has_runtime_restrictions()
+                    && matches!(
+                        eval_result,
+                        Err(ConstantEvaluatorError::NotImplemented(_)
+                            | ConstantEvaluatorError::InvalidBinaryOpArgs,)
+                    )
+                {
+                    Ok(self.append_expr(expr, span, ExpressionKind::Runtime))
+                } else {
+                    eval_result
+                }
+            }
+            ExpressionKind::Override => match self.behavior {
+                Behavior::Wgsl(WgslRestrictions::Override | WgslRestrictions::Runtime(_)) => {
+                    Ok(self.append_expr(expr, span, ExpressionKind::Override))
+                }
+                Behavior::Wgsl(WgslRestrictions::Const) => {
+                    Err(ConstantEvaluatorError::OverrideExpr)
+                }
+                Behavior::Glsl(_) => {
+                    unreachable!()
+                }
+            },
+            ExpressionKind::Runtime => {
+                if self.behavior.has_runtime_restrictions() {
+                    Ok(self.append_expr(expr, span, ExpressionKind::Runtime))
+                } else {
+                    Err(ConstantEvaluatorError::RuntimeExpr)
+                }
             }
-            (
-                &Behavior::Wgsl(WgslRestrictions::Override | WgslRestrictions::Runtime(_)),
-                ExpressionKind::Override,
-            ) => Ok(self.append_expr(expr, span, ExpressionKind::Override)),
-            (&Behavior::Glsl(_), ExpressionKind::Override) => unreachable!(),
-            (
-                &Behavior::Wgsl(WgslRestrictions::Runtime(_))
-                | &Behavior::Glsl(GlslRestrictions::Runtime(_)),
-                ExpressionKind::Runtime,
-            ) => Ok(self.append_expr(expr, span, ExpressionKind::Runtime)),
-            (_, ExpressionKind::Runtime) => Err(ConstantEvaluatorError::RuntimeExpr),
         }
     }