change named_expressions type to IndexMap

gfx-rs · Nov 18, 2022 · 3f63cc0 · 3f63cc0
1 parent abc077c
commit 3f63cc0
Show file tree

Hide file tree

Showing 5 changed files with 15 additions and 55 deletions.
diff --git a/src/back/hlsl/writer.rs b/src/back/hlsl/writer.rs
@@ -1847,10 +1847,12 @@ impl<'a, W: fmt::Write> super::Writer<'a, W> {
                         let indent_level_3 = indent_level_2.next();
                         for case in &cases[i..=end_case_idx] {
                             writeln!(self.out, "{}{{", indent_level_2)?;
+                            let prev_len = self.named_expressions.len();
                             for sta in case.body.iter() {
                                 self.write_stmt(module, sta, func_ctx, indent_level_3)?;
                             }
-                            self.clear_named_expressions_from_block(&case.body);
+                            // Clear all named expressions that were previously inserted by the statements in the block
+                            self.named_expressions.truncate(prev_len);
                             writeln!(self.out, "{}}}", indent_level_2)?;
                         }
 
@@ -1877,51 +1879,6 @@ impl<'a, W: fmt::Write> super::Writer<'a, W> {
         Ok(())
     }
 
-    /// Clears all named expressions that were previously inserted by the statements in the block
-    fn clear_named_expressions_from_block(&mut self, block: &crate::Block) {
-        for statement in block.iter() {
-            match *statement {
-                crate::Statement::Emit(ref range) => {
-                    for handle in range.clone() {
-                        self.named_expressions.remove(&handle);
-                    }
-                }
-                crate::Statement::Atomic { result: handle, .. }
-                | crate::Statement::Call {
-                    result: Some(handle),
-                    ..
-                } => {
-                    self.named_expressions.remove(&handle);
-                }
-                crate::Statement::Block(ref block) => {
-                    self.clear_named_expressions_from_block(block)
-                }
-                crate::Statement::If {
-                    ref accept,
-                    ref reject,
-                    ..
-                } => {
-                    self.clear_named_expressions_from_block(accept);
-                    self.clear_named_expressions_from_block(reject);
-                }
-                crate::Statement::Loop {
-                    ref body,
-                    ref continuing,
-                    ..
-                } => {
-                    self.clear_named_expressions_from_block(body);
-                    self.clear_named_expressions_from_block(continuing);
-                }
-                crate::Statement::Switch { ref cases, .. } => {
-                    for case in cases {
-                        self.clear_named_expressions_from_block(&case.body);
-                    }
-                }
-                _ => {}
-            }
-        }
-    }
-
     /// Helper method to write expressions
     ///
     /// # Notes

diff --git a/src/front/glsl/functions.rs b/src/front/glsl/functions.rs
@@ -8,9 +8,8 @@ use super::{
 };
 use crate::{
     front::glsl::types::type_power, proc::ensure_block_returns, AddressSpace, Arena, Block,
-    Constant, ConstantInner, EntryPoint, Expression, FastHashMap, Function, FunctionArgument,
-    FunctionResult, Handle, LocalVariable, ScalarKind, ScalarValue, Span, Statement, StructMember,
-    Type, TypeInner,
+    Constant, ConstantInner, EntryPoint, Expression, Function, FunctionArgument, FunctionResult,
+    Handle, LocalVariable, ScalarKind, ScalarValue, Span, Statement, StructMember, Type, TypeInner,
 };
 use std::iter;
 
@@ -1065,7 +1064,7 @@ impl Parser {
             result,
             local_variables: locals,
             expressions,
-            named_expressions: FastHashMap::default(),
+            named_expressions: crate::NamedExpressions::default(),
             body,
         };
 

diff --git a/src/front/spv/function.rs b/src/front/spv/function.rs
@@ -61,7 +61,7 @@ impl<I: Iterator<Item = u32>> super::Parser<I> {
                 local_variables: Arena::new(),
                 expressions: self
                     .make_expression_storage(&module.global_variables, &module.constants),
-                named_expressions: crate::FastHashMap::default(),
+                named_expressions: crate::NamedExpressions::default(),
                 body: crate::Block::new(),
             }
         };
@@ -298,7 +298,7 @@ impl<I: Iterator<Item = u32>> super::Parser<I> {
                 result: None,
                 local_variables: Arena::new(),
                 expressions: Arena::new(),
-                named_expressions: crate::FastHashMap::default(),
+                named_expressions: crate::NamedExpressions::default(),
                 body: crate::Block::new(),
             };
 

diff --git a/src/front/wgsl/mod.rs b/src/front/wgsl/mod.rs
@@ -863,7 +863,7 @@ struct StatementContext<'input, 'temp, 'out> {
     typifier: &'temp mut super::Typifier,
     variables: &'out mut Arena<crate::LocalVariable>,
     expressions: &'out mut Arena<crate::Expression>,
-    named_expressions: &'out mut FastHashMap<Handle<crate::Expression>, String>,
+    named_expressions: &'out mut crate::NamedExpressions,
     types: &'out mut UniqueArena<crate::Type>,
     constants: &'out mut Arena<crate::Constant>,
     global_vars: &'out Arena<crate::GlobalVariable>,
@@ -4454,7 +4454,7 @@ impl Parser {
 
         // read body
         let mut typifier = super::Typifier::new();
-        let mut named_expressions = crate::FastHashMap::default();
+        let mut named_expressions = crate::NamedExpressions::default();
         fun.body = self.parse_block(
             lexer,
             StatementContext {

diff --git a/src/lib.rs b/src/lib.rs
@@ -232,7 +232,11 @@ pub type FastHashMap<K, T> = rustc_hash::FxHashMap<K, T>;
 pub type FastHashSet<K> = rustc_hash::FxHashSet<K>;
 
 /// Map of expressions that have associated variable names
-pub(crate) type NamedExpressions = FastHashMap<Handle<Expression>, String>;
+pub(crate) type NamedExpressions = indexmap::IndexMap<
+    Handle<Expression>,
+    String,
+    std::hash::BuildHasherDefault<rustc_hash::FxHasher>,
+>;
 
 /// Early fragment tests.
 ///