Made all maps that may have a large number of elements be hash-maps.

crates/cairo-lang-lowering/src/cache/mod.rs

@@ -35,7 +35,6 @@ use cairo_lang_syntax::node::TypedStablePtr;
 use cairo_lang_syntax::node::ast::{ExprPtr, FunctionWithBodyPtr, TraitItemFunctionPtr};
 use cairo_lang_utils::Intern;
 use cairo_lang_utils::ordered_hash_map::OrderedHashMap;
-use cairo_lang_utils::small_ordered_map::SmallOrderedMap;
 use id_arena::Arena;
 use salsa::Database;
 use serde::{Deserialize, Serialize};
@@ -692,7 +691,7 @@ impl VarRemappingCached {
         }
     }
     fn embed<'db>(self, ctx: &mut CacheLoadingContext<'db>) -> VarRemapping<'db> {
-        let mut remapping = SmallOrderedMap::default();
+        let mut remapping = OrderedHashMap::default();
         for (dst, src) in self.remapping {
             remapping.insert(ctx.lowered_variables_id[dst], src.embed(ctx));
         }

crates/cairo-lang-lowering/src/inline/mod.rs

@@ -9,7 +9,7 @@ use cairo_lang_diagnostics::{Diagnostics, Maybe};
 use cairo_lang_semantic::items::function_with_body::FunctionWithBodySemantic;
 use cairo_lang_semantic::items::functions::InlineConfiguration;
 use cairo_lang_utils::casts::IntoOrPanic;
-use cairo_lang_utils::small_ordered_map::SmallOrderedMap;
+use cairo_lang_utils::ordered_hash_map::OrderedHashMap;
 use cairo_lang_utils::unordered_hash_map::UnorderedHashMap;
 use itertools::{Itertools, zip_eq};
 use salsa::Database;
@@ -193,7 +193,7 @@ impl<'db, 'mt> Rebuilder<'db> for Mapper<'db, 'mt, '_> {
         match end {
             BlockEnd::Return(returns, _location) => {
                 let remapping = VarRemapping {
-                    remapping: SmallOrderedMap::from_iter(zip_eq(
+                    remapping: OrderedHashMap::from_iter(zip_eq(
                         self.outputs.iter().cloned(),
                         returns.iter().cloned(),
                     )),

crates/cairo-lang-lowering/src/objects.rs

@@ -18,7 +18,7 @@ use cairo_lang_semantic::items::imp::ImplLookupContextId;
 use cairo_lang_semantic::types::{TypeInfo, TypesSemantic};
 use cairo_lang_semantic::{ConcreteEnumId, ConcreteVariant};
 use cairo_lang_utils::Intern;
-use cairo_lang_utils::small_ordered_map::SmallOrderedMap;
+use cairo_lang_utils::ordered_hash_map::OrderedHashMap;
 use id_arena::{Arena, DefaultArenaBehavior, Id};
 
 pub mod blocks;
@@ -172,10 +172,10 @@ unsafe impl<'db> salsa::Update for Lowered<'db> {
 #[derive(Clone, Debug, Default, PartialEq, Eq)]
 pub struct VarRemapping<'db> {
     /// Map from new_var to old_var (since new_var cannot appear twice, but old_var can).
-    pub remapping: SmallOrderedMap<VariableId, VarUsage<'db>>,
+    pub remapping: OrderedHashMap<VariableId, VarUsage<'db>>,
 }
 impl<'db> Deref for VarRemapping<'db> {
-    type Target = SmallOrderedMap<VariableId, VarUsage<'db>>;
+    type Target = OrderedHashMap<VariableId, VarUsage<'db>>;
 
     fn deref(&self) -> &Self::Target {
         &self.remapping

crates/cairo-lang-lowering/src/optimizations/dedup_blocks.rs

@@ -4,7 +4,7 @@ mod test;
 
 use cairo_lang_semantic::items::constant::ConstValueId;
 use cairo_lang_semantic::{ConcreteVariant, TypeId};
-use cairo_lang_utils::small_ordered_map::SmallOrderedMap;
+use cairo_lang_utils::ordered_hash_map::OrderedHashMap;
 use cairo_lang_utils::unordered_hash_map::{self, UnorderedHashMap};
 use itertools::{Itertools, zip_eq};
 
@@ -294,7 +294,7 @@ pub fn dedup_blocks<'db>(lowered: &mut Lowered<'db>) {
                 end: BlockEnd::Goto(
                     block_id,
                     VarRemapping {
-                        remapping: SmallOrderedMap::from_iter(zip_eq(
+                        remapping: OrderedHashMap::from_iter(zip_eq(
                             target_inputs.iter().map(|var_usage| var_usage.var_id),
                             inputs.iter().cloned(),
                         )),
@@ -318,7 +318,7 @@ pub fn dedup_blocks<'db>(lowered: &mut Lowered<'db>) {
 
                 let inputs = ctx.block_id_to_inputs.get(target_block).unwrap();
                 let mut inputs_remapping = VarRemapping {
-                    remapping: SmallOrderedMap::from_iter(zip_eq(
+                    remapping: OrderedHashMap::from_iter(zip_eq(
                         target_inputs.iter().map(|var_usage| var_usage.var_id),
                         inputs.iter().cloned(),
                     )),

crates/cairo-lang-lowering/src/optimizations/match_optimizer.rs

@@ -5,7 +5,6 @@ mod test;
 use cairo_lang_semantic::MatchArmSelector;
 use cairo_lang_utils::ordered_hash_map::OrderedHashMap;
 use cairo_lang_utils::ordered_hash_set::OrderedHashSet;
-use cairo_lang_utils::small_ordered_map::SmallOrderedMap;
 use cairo_lang_utils::unordered_hash_map::UnorderedHashMap;
 use itertools::{Itertools, zip_eq};
 
@@ -280,11 +279,9 @@ fn try_get_fix_info<'db>(
         Some(remappings) => {
             // Filter the additional remappings to only include those that are used in relevant arm.
             VarRemapping {
-                remapping: SmallOrderedMap::from_iter(remappings.iter().filter_map(
-                    |(dst, src)| {
-                        if demand.vars.contains_key(dst) { Some((*dst, *src)) } else { None }
-                    },
-                )),
+                remapping: OrderedHashMap::from_iter(remappings.iter().filter_map(|(dst, src)| {
+                    if demand.vars.contains_key(dst) { Some((*dst, *src)) } else { None }
+                })),
             }
         }
         None => VarRemapping::default(),

crates/cairo-lang-lowering/src/utils.rs

@@ -1,4 +1,4 @@
-use cairo_lang_utils::small_ordered_map::SmallOrderedMap;
+use cairo_lang_utils::ordered_hash_map::OrderedHashMap;
 
 use crate::ids::LocationId;
 use crate::{
@@ -95,7 +95,7 @@ pub trait RebuilderEx<'db>: Rebuilder<'db> {
     /// Apply map_var_id to all the variables in the `remapping`.
     fn rebuild_remapping(&mut self, remapping: &VarRemapping<'db>) -> VarRemapping<'db> {
         let mut remapping = VarRemapping {
-            remapping: SmallOrderedMap::from_iter(remapping.iter().map(|(dst, src_var_usage)| {
+            remapping: OrderedHashMap::from_iter(remapping.iter().map(|(dst, src_var_usage)| {
                 (self.map_var_id(*dst), self.map_var_usage(*src_var_usage))
             })),
         };

crates/cairo-lang-sierra-to-casm/src/references.rs

@@ -5,7 +5,7 @@ use cairo_lang_sierra::ids::{ConcreteTypeId, VarId};
 use cairo_lang_sierra::program::{Function, StatementIdx};
 use cairo_lang_sierra_type_size::TypeSizeMap;
 use cairo_lang_utils::casts::IntoOrPanic;
-use cairo_lang_utils::small_ordered_map::SmallOrderedMap;
+use cairo_lang_utils::ordered_hash_map::OrderedHashMap;
 use cairo_lang_utils::write_comma_separated;
 use thiserror::Error;
 
@@ -23,7 +23,7 @@ pub enum ReferencesError {
     UnknownType(ConcreteTypeId),
 }
 
-pub type StatementRefs = SmallOrderedMap<VarId, ReferenceValue>;
+pub type StatementRefs = OrderedHashMap<VarId, ReferenceValue>;
 
 /// A Sierra reference to a value.
 /// Corresponds to an argument or return value of a Sierra statement.

crates/cairo-lang-sierra/src/edit_state.rs

@@ -1,4 +1,4 @@
-use cairo_lang_utils::small_ordered_map::SmallOrderedMap;
+use cairo_lang_utils::ordered_hash_map::OrderedHashMap;
 use thiserror::Error;
 
 use crate::ids::VarId;
@@ -25,12 +25,12 @@ impl EditStateError {
 
 /// Given a map with var ids as keys, extracts out the given ids, failing if some id is missing.
 pub fn take_args<'a, V: 'a>(
-    mut state: SmallOrderedMap<VarId, V>,
+    mut state: OrderedHashMap<VarId, V>,
     ids: impl Iterator<Item = &'a VarId>,
-) -> Result<(SmallOrderedMap<VarId, V>, Vec<V>), EditStateError> {
+) -> Result<(OrderedHashMap<VarId, V>, Vec<V>), EditStateError> {
     let mut vals = vec![];
     for id in ids {
-        match state.remove(id) {
+        match state.swap_remove(id) {
             None => {
                 return Err(EditStateError::MissingReference(id.clone()));
             }
@@ -44,9 +44,9 @@ pub fn take_args<'a, V: 'a>(
 
 /// Adds the given pairs to map with var ids as keys, failing if some variable is overridden.
 pub fn put_results<'a, V>(
-    mut state: SmallOrderedMap<VarId, V>,
+    mut state: OrderedHashMap<VarId, V>,
     results: impl Iterator<Item = (&'a VarId, V)>,
-) -> Result<SmallOrderedMap<VarId, V>, EditStateError> {
+) -> Result<OrderedHashMap<VarId, V>, EditStateError> {
     for (id, v) in results {
         if state.insert(id.clone(), v).is_some() {
             return Err(EditStateError::VariableOverride(id.clone()));

crates/cairo-lang-sierra/src/edit_state_test.rs

@@ -1,10 +1,10 @@
 use cairo_lang_test_utils::test;
-use cairo_lang_utils::small_ordered_map::SmallOrderedMap;
+use cairo_lang_utils::ordered_hash_map::OrderedHashMap;
 
 use crate::edit_state::{EditStateError, put_results, take_args};
 use crate::ids::VarId;
 
-pub type State = SmallOrderedMap<VarId, i64>;
+pub type State = OrderedHashMap<VarId, i64>;
 
 #[test]
 fn empty() {
@@ -15,19 +15,19 @@ fn empty() {
 #[test]
 fn basic_mapping() {
     assert_eq!(
-        take_args(State::from_iter([("arg".into(), 0)]), vec![&"arg".into()].into_iter(),),
+        take_args(State::from([("arg".into(), 0)]), vec![&"arg".into()].into_iter(),),
         Ok((State::default(), vec![0]))
     );
     assert_eq!(
         put_results(State::default(), vec![(&"res".into(), 1)].into_iter(),),
-        Ok(State::from_iter([("res".into(), 1)]))
+        Ok(State::from([("res".into(), 1)]))
     );
     assert_eq!(
         take_args(State::default(), vec![&"arg".into()].into_iter(),),
         Err(EditStateError::MissingReference("arg".into()))
     );
     assert_eq!(
-        put_results(State::from_iter([("res".into(), 1)]), vec![(&"res".into(), 1)].into_iter(),),
+        put_results(State::from([("res".into(), 1)]), vec![(&"res".into(), 1)].into_iter(),),
         Err(EditStateError::VariableOverride("res".into()))
     );
 }

crates/cairo-lang-sierra/src/simulation/mod.rs

@@ -1,6 +1,6 @@
 use std::collections::HashMap;
 
-use cairo_lang_utils::small_ordered_map::SmallOrderedMap;
+use cairo_lang_utils::ordered_hash_map::OrderedHashMap;
 use itertools::izip;
 use thiserror::Error;
 
@@ -83,7 +83,7 @@ impl SimulationContext<'_> {
                 actual: inputs.len(),
             });
         }
-        let mut state = SmallOrderedMap::<VarId, CoreValue>::from_iter(
+        let mut state = OrderedHashMap::<VarId, CoreValue>::from_iter(
             izip!(func.params.iter(), inputs).map(|(param, input)| (param.id.clone(), input)),
         );
         loop {