Merge branch 'master' into solari6

Author: JMS55

Cargo.toml

@@ -6,6 +6,7 @@ license = "MIT OR Apache-2.0"
 description = "a crate for combining and manipulating shaders using naga IR"
 repository = "https://github.com/bevyengine/naga_oil/"
 readme = "README.md"
+rust-version = "1.84"
 
 [features]
 default = ["test_shader", "glsl"]
@@ -17,20 +18,20 @@ prune = []
 allow_deprecated = []
 
 [dependencies]
-naga = { version = "24", features = ["wgsl-in", "wgsl-out"] }
+naga = { version = "25", features = ["wgsl-in", "wgsl-out"] }
 tracing = "0.1"
 regex = "1.8"
 regex-syntax = "0.8"
-thiserror = "1.0"
-codespan-reporting = "0.11"
+thiserror = "2.0"
+codespan-reporting = "0.12"
 data-encoding = "2.3.2"
-bit-set = "0.5"
-rustc-hash = "1.1.0"
+bit-set = "0.8"
+rustc-hash = "1.1"
 unicode-ident = "1"
 once_cell = "1.17.0"
 indexmap = "2"
 
 [dev-dependencies]
-wgpu = { version = "24", features = ["naga-ir"] }
-futures-lite = "1"
+wgpu = { version = "25", features = ["naga-ir"] }
+futures-lite = "2"
 tracing-subscriber = { version = "0.3", features = ["std", "fmt"] }

examples/pbr_compose_test.rs

@@ -145,11 +145,10 @@ fn test_wgsl_string_compile(n: usize) {
         .into_iter()
         .next()
         .unwrap();
-    let device = futures_lite::future::block_on(
-        adapter.request_device(&wgpu::DeviceDescriptor::default(), None),
-    )
-    .unwrap()
-    .0;
+    let device =
+        futures_lite::future::block_on(adapter.request_device(&wgpu::DeviceDescriptor::default()))
+            .unwrap()
+            .0;
 
     for _ in 0..n {
         let _desc = device.create_shader_module(wgpu::ShaderModuleDescriptor {
@@ -169,11 +168,10 @@ fn test_composer_compile(n: usize, composer: &mut Composer) {
         .into_iter()
         .next()
         .unwrap();
-    let device = futures_lite::future::block_on(
-        adapter.request_device(&wgpu::DeviceDescriptor::default(), None),
-    )
-    .unwrap()
-    .0;
+    let device =
+        futures_lite::future::block_on(adapter.request_device(&wgpu::DeviceDescriptor::default()))
+            .unwrap()
+            .0;
 
     for _ in 0..n {
         let module = composer

src/compose/comment_strip_iter.rs

@@ -51,7 +51,7 @@ impl<'a> Iterator for CommentReplaceIter<'a> {
                 .unwrap_or(line_in.len());
 
             if let CommentState::Block(_) = self.state {
-                output.extend(std::iter::repeat(' ').take(section_end - section_start));
+                output.extend(std::iter::repeat_n(' ', section_end - section_start));
             } else {
                 output.push_str(&line_in[section_start..section_end]);
             }
@@ -62,10 +62,10 @@ impl<'a> Iterator for CommentReplaceIter<'a> {
                     match marker.as_str() {
                         // only possible in None state
                         "//" => {
-                            output.extend(
-                                std::iter::repeat(' ')
-                                    .take(line_in.len() - marker.start() - section_start),
-                            );
+                            output.extend(std::iter::repeat_n(
+                                ' ',
+                                line_in.len() - marker.start() - section_start,
+                            ));
                             return Some(Cow::Owned(output));
                         }
                         // only possible in None or Block state

src/compose/mod.rs

@@ -1233,7 +1233,7 @@ impl Composer {
         for (h, ty) in source_ir.types.iter() {
             if let Some(name) = &ty.name {
                 if composable.owned_types.contains(name)
-                    && items.map_or(true, |items| items.contains(name))
+                    && items.is_none_or(|items| items.contains(name))
                 {
                     derived.import_type(&h);
                 }
@@ -1243,7 +1243,7 @@ impl Composer {
         for (h, c) in source_ir.constants.iter() {
             if let Some(name) = &c.name {
                 if composable.owned_constants.contains(name)
-                    && items.map_or(true, |items| items.contains(name))
+                    && items.is_none_or(|items| items.contains(name))
                 {
                     derived.import_const(&h);
                 }
@@ -1253,7 +1253,7 @@ impl Composer {
         for (h, po) in source_ir.overrides.iter() {
             if let Some(name) = &po.name {
                 if composable.owned_functions.contains(name)
-                    && items.map_or(true, |items| items.contains(name))
+                    && items.is_none_or(|items| items.contains(name))
                 {
                     derived.import_pipeline_override(&h);
                 }
@@ -1263,7 +1263,7 @@ impl Composer {
         for (h, v) in source_ir.global_variables.iter() {
             if let Some(name) = &v.name {
                 if composable.owned_vars.contains(name)
-                    && items.map_or(true, |items| items.contains(name))
+                    && items.is_none_or(|items| items.contains(name))
                 {
                     derived.import_global(&h);
                 }
@@ -1273,7 +1273,7 @@ impl Composer {
         for (h_f, f) in source_ir.functions.iter() {
             if let Some(name) = &f.name {
                 if composable.owned_functions.contains(name)
-                    && (items.map_or(true, |items| items.contains(name))
+                    && (items.is_none_or(|items| items.contains(name))
                         || composable
                             .override_functions
                             .values()

src/compose/preprocess.rs

@@ -267,7 +267,7 @@ impl Preprocessor {
 
                     loop {
                         // output spaces for removed lines to keep spans consistent (errors report against substituted_source, which is not preprocessed)
-                        final_string.extend(std::iter::repeat(" ").take(line.len()));
+                        final_string.extend(std::iter::repeat_n(" ", line.len()));
                         offset += line.len() + 1;
 
                         // PERF: Ideally we don't do multiple `match_indices` passes over `line`
@@ -351,15 +351,15 @@ impl Preprocessor {
 
                     final_string.push_str(&item_replaced_line);
                     let diff = line.len().saturating_sub(item_replaced_line.len());
-                    final_string.extend(std::iter::repeat(" ").take(diff));
+                    final_string.extend(std::iter::repeat_n(" ", diff));
                     offset += original_line.len() + 1;
                     output = true;
                 }
             }
 
             if !output {
                 // output spaces for removed lines to keep spans consistent (errors report against substituted_source, which is not preprocessed)
-                final_string.extend(std::iter::repeat(" ").take(line.len()));
+                final_string.extend(std::iter::repeat_n(" ", line.len()));
                 offset += line.len() + 1;
             }
             final_string.push('\n');

src/compose/test.rs

@@ -1401,14 +1401,12 @@ mod test {
             .into_iter()
             .next()
             .unwrap();
-        let (device, queue) = futures_lite::future::block_on(adapter.request_device(
-            &wgpu::DeviceDescriptor {
+        let (device, queue) =
+            futures_lite::future::block_on(adapter.request_device(&wgpu::DeviceDescriptor {
                 required_features: Features::MAPPABLE_PRIMARY_BUFFERS,
                 ..Default::default()
-            },
-            None,
-        ))
-        .unwrap();
+            }))
+            .unwrap();
 
         let shader_module = device.create_shader_module(wgpu::ShaderModuleDescriptor {
             source: wgpu::ShaderSource::Naga(Cow::Owned(module)),
@@ -1477,15 +1475,23 @@ mod test {
 
         queue.submit([buffer]);
 
-        while !device.poll(wgpu::MaintainBase::Wait).is_queue_empty() {
+        while !device
+            .poll(wgpu::MaintainBase::Wait)
+            .unwrap()
+            .is_queue_empty()
+        {
             println!("waiting...");
         }
 
         output_buffer
             .slice(..)
             .map_async(wgpu::MapMode::Read, |_| ());
 
-        while !device.poll(wgpu::MaintainBase::Wait).is_queue_empty() {
+        while !device
+            .poll(wgpu::MaintainBase::Wait)
+            .unwrap()
+            .is_queue_empty()
+        {
             println!("waiting...");
         }
 

src/compose/tests/expected/err_validation_1.txt

@@ -3,8 +3,8 @@ error: failed to build a valid final module: Function [1] 'func' is invalid
   │  
 7 │ ╭ fn func() -> f32 {
 8 │ │     return 1u;
-  │ │            ^^ naga::Expression [0]
-  │ ╰──────────────^ naga::Function [1]
+  │ │            ^^ naga::ir::Expression [0]
+  │ ╰──────────────^ naga::ir::Function [1]
   │  
   = The `return` value Some([0]) does not match the function return value
 

src/compose/tests/expected/err_validation_2.txt

@@ -3,8 +3,8 @@ error: failed to build a valid final module: Function [0] 'valid_inc::func' is i
   │  
 7 │ ╭ fn func() -> f32 {
 8 │ │     return 1u;
-  │ │            ^^ naga::Expression [0]
-  │ ╰──────────────^ naga::Function [0]
+  │ │            ^^ naga::ir::Expression [0]
+  │ ╰──────────────^ naga::ir::Function [0]
   │  
   = The `return` value Some([0]) does not match the function return value
 

src/derive.rs

@@ -92,8 +92,8 @@ impl<'a> DerivedModule<'a> {
                     | TypeInner::Image { .. }
                     | TypeInner::Sampler { .. }
                     | TypeInner::Atomic { .. }
-                    | TypeInner::AccelerationStructure
-                    | TypeInner::RayQuery => ty.inner.clone(),
+                    | TypeInner::AccelerationStructure { .. }
+                    | TypeInner::RayQuery { .. } => ty.inner.clone(),
 
                     TypeInner::Pointer { base, space } => TypeInner::Pointer {
                         base: self.import_type(base),
@@ -172,7 +172,7 @@ impl<'a> DerivedModule<'a> {
             let new_global = GlobalVariable {
                 name: gv.name.clone(),
                 space: gv.space,
-                binding: gv.binding.clone(),
+                binding: gv.binding,
                 ty: self.import_type(&gv.ty),
                 init: gv.init.map(|c| self.import_global_expression(c)),
             };
@@ -407,6 +407,14 @@ impl<'a> DerivedModule<'a> {
                                 }
                             }
                             naga::RayQueryFunction::Terminate => naga::RayQueryFunction::Terminate,
+                            naga::RayQueryFunction::GenerateIntersection { hit_t } => {
+                                naga::RayQueryFunction::GenerateIntersection {
+                                    hit_t: map_expr!(hit_t),
+                                }
+                            }
+                            naga::RayQueryFunction::ConfirmIntersection => {
+                                naga::RayQueryFunction::ConfirmIntersection
+                            }
                         },
                     },
                     Statement::SubgroupBallot { result, predicate } => Statement::SubgroupBallot {
@@ -694,6 +702,12 @@ impl<'a> DerivedModule<'a> {
                     committed: *committed,
                 }
             }
+            Expression::RayQueryVertexPositions { query, committed } => {
+                Expression::RayQueryVertexPositions {
+                    query: map_expr!(query),
+                    committed: *committed,
+                }
+            }
             Expression::Override(h_override) => {
                 is_external = true;
                 Expression::Override(self.import_pipeline_override(h_override))

src/prune/mod.rs

@@ -450,7 +450,7 @@ impl FunctionReq {
                     pointer: expr_map[pointer],
                     fun: *fun,
                     value: expr_map[value],
-                    result: expr_map[result],
+                    result: result.as_ref().map(|it| expr_map[it]),
                 })
             }
             (
@@ -1568,12 +1568,15 @@ impl<'a> Pruner<'a> {
                 let required_store = self.store_required(context, &var_ref);
                 debug!("atomic store required: {:?}", required_store);
 
-                let required_load = func_req.exprs_required.get(result).cloned();
+                let required_load = match result {
+                    Some(result) => func_req.exprs_required.get(result).cloned(),
+                    None => None,
+                };
                 debug!("atomic load required: {:?}", required_load);
 
                 if required_load.is_some() || required_store.is_some() {
                     // just pass it all through i guess ..?
-                    if let Some(required_load) = required_load {
+                    if let (Some(required_load), Some(result)) = (required_load, result) {
                         self.add_expression(function, func_req, context, *result, &required_load);
                     }
                     if let Some(required_store) = required_store {