add override field to ArraySize::Pending

gfx-rs · Dec 9, 2024 · bf89b36 · bf89b36
1 parent 922f735
commit bf89b36
Show file tree

Hide file tree

Showing 18 changed files with 34 additions and 27 deletions.
diff --git a/naga/src/back/glsl/mod.rs b/naga/src/back/glsl/mod.rs
@@ -978,7 +978,7 @@ impl<'a, W: Write> Writer<'a, W> {
             crate::ArraySize::Constant(size) => {
                 write!(self.out, "{size}")?;
             }
-            crate::ArraySize::Pending(_) => unreachable!(),
+            crate::ArraySize::Pending(..) => unreachable!(),
             crate::ArraySize::Dynamic => (),
         }
 

diff --git a/naga/src/back/hlsl/conv.rs b/naga/src/back/hlsl/conv.rs
@@ -68,7 +68,7 @@ impl crate::TypeInner {
                 let count = match size {
                     crate::ArraySize::Constant(size) => size.get(),
                     // A dynamically-sized array has to have at least one element
-                    crate::ArraySize::Pending(_) => unreachable!(),
+                    crate::ArraySize::Pending(..) => unreachable!(),
                     crate::ArraySize::Dynamic => 1,
                 };
                 let last_el_size = gctx.types[base].inner.size_hlsl(gctx);

diff --git a/naga/src/back/hlsl/writer.rs b/naga/src/back/hlsl/writer.rs
@@ -988,7 +988,7 @@ impl<'a, W: fmt::Write> super::Writer<'a, W> {
             crate::ArraySize::Constant(size) => {
                 write!(self.out, "{size}")?;
             }
-            crate::ArraySize::Pending(_) => unreachable!(),
+            crate::ArraySize::Pending(..) => unreachable!(),
             crate::ArraySize::Dynamic => unreachable!(),
         }
 

diff --git a/naga/src/back/msl/writer.rs b/naga/src/back/msl/writer.rs
@@ -3742,7 +3742,7 @@ impl<W: Write> Writer<W> {
                             )?;
                             writeln!(self.out, "}};")?;
                         }
-                        crate::ArraySize::Pending(_) => {
+                        crate::ArraySize::Pending(..) => {
                             unreachable!()
                         }
                         crate::ArraySize::Dynamic => {

diff --git a/naga/src/back/pipeline_constants.rs b/naga/src/back/pipeline_constants.rs
@@ -214,7 +214,7 @@ fn process_pending(
     for (handle, ty) in module.types.clone().iter() {
         if let crate::TypeInner::Array {
             base,
-            size: crate::ArraySize::Pending(size_expr),
+            size: crate::ArraySize::Pending(size_expr, _),
             stride,
         } = ty.inner
         {

diff --git a/naga/src/back/spv/writer.rs b/naga/src/back/spv/writer.rs
@@ -971,7 +971,7 @@ impl Writer {
                             let length_id = self.get_index_constant(length.get());
                             Instruction::type_array(id, type_id, length_id)
                         }
-                        crate::ArraySize::Pending(_) => unreachable!(),
+                        crate::ArraySize::Pending(..) => unreachable!(),
                         crate::ArraySize::Dynamic => Instruction::type_runtime_array(id, type_id),
                     }
                 }
@@ -982,7 +982,7 @@ impl Writer {
                             let length_id = self.get_index_constant(length.get());
                             Instruction::type_array(id, type_id, length_id)
                         }
-                        crate::ArraySize::Pending(_) => unreachable!(),
+                        crate::ArraySize::Pending(..) => unreachable!(),
                         crate::ArraySize::Dynamic => Instruction::type_runtime_array(id, type_id),
                     }
                 }

diff --git a/naga/src/back/wgsl/writer.rs b/naga/src/back/wgsl/writer.rs
@@ -520,7 +520,7 @@ impl<W: Write> Writer<W> {
                         self.write_type(module, base)?;
                         write!(self.out, ", {len}")?;
                     }
-                    crate::ArraySize::Pending(_) => {
+                    crate::ArraySize::Pending(..) => {
                         unreachable!();
                     }
                     crate::ArraySize::Dynamic => {
@@ -537,7 +537,7 @@ impl<W: Write> Writer<W> {
                         self.write_type(module, base)?;
                         write!(self.out, ", {len}")?;
                     }
-                    crate::ArraySize::Pending(_) => {
+                    crate::ArraySize::Pending(..) => {
                         unreachable!();
                     }
                     crate::ArraySize::Dynamic => {

diff --git a/naga/src/compact/mod.rs b/naga/src/compact/mod.rs
@@ -65,7 +65,7 @@ pub fn compact(module: &mut crate::Module) {
 
     for (_, ty) in module.types.iter() {
         if let crate::TypeInner::Array {
-            size: crate::ArraySize::Pending(size_expr),
+            size: crate::ArraySize::Pending(size_expr, _),
             ..
         } = ty.inner
         {
@@ -219,7 +219,7 @@ pub fn compact(module: &mut crate::Module) {
     for (handle, ty) in module.types.clone().iter() {
         if let crate::TypeInner::Array {
             base,
-            size: crate::ArraySize::Pending(mut size_expr),
+            size: crate::ArraySize::Pending(mut size_expr, ident),
             stride,
         } = ty.inner
         {
@@ -230,7 +230,7 @@ pub fn compact(module: &mut crate::Module) {
                     name: None,
                     inner: crate::TypeInner::Array {
                         base,
-                        size: crate::ArraySize::Pending(size_expr),
+                        size: crate::ArraySize::Pending(size_expr, ident),
                         stride,
                     },
                 },

diff --git a/naga/src/front/glsl/offset.rs b/naga/src/front/glsl/offset.rs
@@ -84,7 +84,7 @@ pub fn calculate_offset(
 
             let span = match size {
                 crate::ArraySize::Constant(size) => size.get() * stride,
-                crate::ArraySize::Pending(_) => unreachable!(),
+                crate::ArraySize::Pending(..) => unreachable!(),
                 crate::ArraySize::Dynamic => stride,
             };
 

diff --git a/naga/src/front/spv/mod.rs b/naga/src/front/spv/mod.rs
@@ -1277,7 +1277,7 @@ impl<I: Iterator<Item = u32>> Frontend<I> {
             crate::TypeInner::Array { size, .. } => {
                 let size = match size {
                     crate::ArraySize::Constant(size) => size.get(),
-                    crate::ArraySize::Pending(_) => {
+                    crate::ArraySize::Pending(..) => {
                         unreachable!();
                     }
                     // A runtime sized array is not a composite type

diff --git a/naga/src/front/wgsl/lower/mod.rs b/naga/src/front/wgsl/lower/mod.rs
@@ -3060,11 +3060,12 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
                         if let Err(Error::ConstantEvaluatorError(ref ty, _)) = err {
                             match **ty {
                                 crate::proc::ConstantEvaluatorError::OverrideExpr => {
-                                    crate::ArraySize::Pending(self.array_size_override(
+                                    let (size_expr, ident) = self.array_size_override(
                                         expr,
                                         &mut ctx.as_override(),
                                         span,
-                                    )?)
+                                    )?;
+                                    crate::ArraySize::Pending(size_expr, ident)
                                 }
                                 _ => {
                                     err?;
@@ -3087,10 +3088,16 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
         size_expr: Handle<ast::Expression<'source>>,
         ctx: &mut ExpressionContext<'source, '_, '_>,
         span: Span,
-    ) -> Result<Handle<crate::Expression>, Error<'source>> {
+    ) -> Result<(Handle<crate::Expression>, Option<Handle<crate::Override>>), Error<'source>> {
         let expr = self.expression(size_expr, ctx)?;
         match resolve_inner!(ctx, expr).scalar_kind().ok_or(0) {
-            Ok(crate::ScalarKind::Sint) | Ok(crate::ScalarKind::Uint) => Ok(expr),
+            Ok(crate::ScalarKind::Sint) | Ok(crate::ScalarKind::Uint) => Ok((expr, {
+                if let crate::Expression::Override(handle) = ctx.module.global_expressions[expr] {
+                    Some(handle)
+                } else {
+                    None
+                }
+            })),
             _ => Err(Error::ExpectedConstExprConcreteIntegerScalar(span)),
         }
     }

diff --git a/naga/src/front/wgsl/to_wgsl.rs b/naga/src/front/wgsl/to_wgsl.rs
@@ -67,7 +67,7 @@ impl crate::TypeInner {
                 let base = base.to_wgsl(gctx);
                 match size {
                     crate::ArraySize::Constant(size) => format!("array<{base}, {size}>"),
-                    crate::ArraySize::Pending(_) => unreachable!(),
+                    crate::ArraySize::Pending(..) => unreachable!(),
                     crate::ArraySize::Dynamic => format!("array<{base}>"),
                 }
             }
@@ -124,7 +124,7 @@ impl crate::TypeInner {
                 let base = member_type.name.as_deref().unwrap_or("unknown");
                 match size {
                     crate::ArraySize::Constant(size) => format!("binding_array<{base}, {size}>"),
-                    crate::ArraySize::Pending(_) => unreachable!(),
+                    crate::ArraySize::Pending(..) => unreachable!(),
                     crate::ArraySize::Dynamic => format!("binding_array<{base}>"),
                 }
             }

diff --git a/naga/src/lib.rs b/naga/src/lib.rs
@@ -497,7 +497,7 @@ pub enum ArraySize {
     /// The array size is constant.
     Constant(std::num::NonZeroU32),
     /// The array size is an override-expression.
-    Pending(Handle<Expression>),
+    Pending(Handle<Expression>, Option<Handle<Override>>),
     /// The array size can change at runtime.
     Dynamic,
 }

diff --git a/naga/src/proc/constant_evaluator.rs b/naga/src/proc/constant_evaluator.rs
@@ -1313,7 +1313,7 @@ impl<'a> ConstantEvaluator<'a> {
                             let expr = Expression::Literal(Literal::U32(len.get()));
                             self.register_evaluated_expr(expr, span)
                         }
-                        ArraySize::Pending(_) => Err(ConstantEvaluatorError::ArrayLengthOverridden),
+                        ArraySize::Pending(..) => Err(ConstantEvaluatorError::ArrayLengthOverridden),
                         ArraySize::Dynamic => Err(ConstantEvaluatorError::ArrayLengthDynamic),
                     },
                     _ => Err(ConstantEvaluatorError::InvalidArrayLengthArg),

diff --git a/naga/src/proc/index.rs b/naga/src/proc/index.rs
@@ -429,7 +429,7 @@ impl crate::ArraySize {
     ) -> Result<IndexableLength, IndexableLengthError> {
         Ok(match self {
             Self::Constant(length) => IndexableLength::Known(length.get()),
-            Self::Pending(_) => IndexableLength::Pending,
+            Self::Pending(..) => IndexableLength::Pending,
             Self::Dynamic => IndexableLength::Dynamic,
         })
     }

diff --git a/naga/src/proc/mod.rs b/naga/src/proc/mod.rs
@@ -299,7 +299,7 @@ impl super::TypeInner {
                     super::ArraySize::Constant(count) => count.get(),
                     // any struct member or array element needing a size at pipeline-creation time
                     // must have a creation-fixed footprint
-                    super::ArraySize::Pending(_) => 0,
+                    super::ArraySize::Pending(..) => 0,
                     // A dynamically-sized array has to have at least one element
                     super::ArraySize::Dynamic => 1,
                 };

diff --git a/naga/src/valid/mod.rs b/naga/src/valid/mod.rs
@@ -616,7 +616,7 @@ impl Validator {
                 })?;
             if !self.allow_overrides {
                 if let crate::TypeInner::Array {
-                    size: crate::ArraySize::Pending(_),
+                    size: crate::ArraySize::Pending(..),
                     ..
                 } = ty.inner
                 {

diff --git a/naga/src/valid/type.rs b/naga/src/valid/type.rs
@@ -521,7 +521,7 @@ impl super::Validator {
                             | TypeFlags::CONSTRUCTIBLE
                             | TypeFlags::CREATION_RESOLVED
                     }
-                    crate::ArraySize::Pending(_) => {
+                    crate::ArraySize::Pending(..) => {
                         TypeFlags::DATA
                             | TypeFlags::SIZED
                             | TypeFlags::COPY
@@ -719,7 +719,7 @@ impl super::Validator {
                     crate::ArraySize::Constant(_) => {
                         TypeFlags::SIZED | TypeFlags::HOST_SHAREABLE | TypeFlags::CREATION_RESOLVED
                     }
-                    crate::ArraySize::Pending(_) => TypeFlags::SIZED | TypeFlags::HOST_SHAREABLE,
+                    crate::ArraySize::Pending(..) => TypeFlags::SIZED | TypeFlags::HOST_SHAREABLE,
                     crate::ArraySize::Dynamic => {
                         // Final type is non-sized
                         TypeFlags::HOST_SHAREABLE | TypeFlags::CREATION_RESOLVED