refactor(naga): use crate::proc in naga::valid::expression

Author: ErichDonGubler

naga/src/valid/expression.rs

@@ -2,6 +2,7 @@ use super::{compose::validate_compose, FunctionInfo, ModuleInfo, ShaderStages, T
 use crate::arena::UniqueArena;
 use crate::{
     arena::Handle,
+    proc,
     proc::OverloadSet as _,
     proc::{IndexableLengthError, ResolveError},
 };
@@ -198,9 +199,9 @@ impl super::Validator {
     pub(super) fn validate_const_expression(
         &self,
         handle: Handle<crate::Expression>,
-        gctx: crate::proc::GlobalCtx,
+        gctx: proc::GlobalCtx,
         mod_info: &ModuleInfo,
-        global_expr_kind: &crate::proc::ExpressionKindTracker,
+        global_expr_kind: &proc::ExpressionKindTracker,
     ) -> Result<(), ConstExpressionError> {
         use crate::Expression as E;
 
@@ -243,7 +244,7 @@ impl super::Validator {
         module: &crate::Module,
         info: &FunctionInfo,
         mod_info: &ModuleInfo,
-        expr_kind: &crate::proc::ExpressionKindTracker,
+        expr_kind: &proc::ExpressionKindTracker,
     ) -> Result<ShaderStages, ExpressionError> {
         use crate::{Expression as E, Scalar as Sc, ScalarKind as Sk, TypeInner as Ti};
 
@@ -293,16 +294,16 @@ impl super::Validator {
                         }?;
                         // If we know both the length and the index, we can do the
                         // bounds check now.
-                        if let crate::proc::IndexableLength::Known(known_length) = length {
+                        if let proc::IndexableLength::Known(known_length) = length {
                             if value >= known_length {
                                 return Err(ExpressionError::IndexOutOfBounds(base, value));
                             }
                         }
                     }
-                    Err(crate::proc::U32EvalError::Negative) => {
+                    Err(proc::U32EvalError::Negative) => {
                         return Err(ExpressionError::NegativeIndex(base))
                     }
-                    Err(crate::proc::U32EvalError::NonConst) => {}
+                    Err(proc::U32EvalError::NonConst) => {}
                 }
 
                 ShaderStages::all()