Simplify mapping types and use regular Parameter for key and value types

Author: ggiraldez

crates/codegen/generator/src/ir/builders/ir2_flat_contracts.rs

@@ -13,6 +13,7 @@ pub(super) fn build_from(structured_ast_model: &IrModel) -> ModelWithTransformer
     simplify_imports(&mut mutator);
     simplify_variable_declarations(&mut mutator);
     simplify_parameters(&mut mutator);
+    simplify_mapping_type_parameters(&mut mutator);
 
     mutator.into()
 }
@@ -328,3 +329,14 @@ fn simplify_parameters(mutator: &mut IrModelMutator) {
     mutator.remove_type("ErrorParameter");
     mutator.add_sequence_field("ErrorDefinition", "parameters", "Parameters", false);
 }
+
+fn simplify_mapping_type_parameters(mutator: &mut IrModelMutator) {
+    // Replace `MappingKey` and `MappingValue` with regular `Parameter` types.
+    // `MappingKeyType` is a subset of `TypeName` and can be removed as well.
+    mutator.remove_type("MappingKeyType");
+    mutator.remove_type("MappingKey");
+    mutator.remove_type("MappingValue");
+
+    mutator.add_sequence_field("MappingType", "key_type", "Parameter", false);
+    mutator.add_sequence_field("MappingType", "value_type", "Parameter", false);
+}

crates/solidity/outputs/cargo/crate/src/backend/ir/ir2_flat_contracts/nodes.generated.rs

@@ -518,6 +518,17 @@ impl Transformer for Pass {
             parameters,
         })
     }
+
+    fn transform_mapping_type(&mut self, source: &input::MappingType) -> output::MappingType {
+        let key_type = self.transform_mapping_key(&source.key_type);
+        let value_type = self.transform_mapping_value(&source.value_type);
+
+        Rc::new(output::MappingTypeStruct {
+            node_id: source.node_id,
+            key_type,
+            value_type,
+        })
+    }
 }
 
 impl Pass {
@@ -1250,4 +1261,41 @@ impl Pass {
             indexed: false,
         })
     }
+
+    fn transform_mapping_key(&mut self, source: &input::MappingKey) -> output::Parameter {
+        let type_name = self.transform_mapping_key_type(&source.key_type);
+        let name = source.name.as_ref().map(Rc::clone);
+
+        Rc::new(output::ParameterStruct {
+            node_id: source.node_id,
+            type_name,
+            storage_location: None,
+            name,
+            indexed: false,
+        })
+    }
+
+    fn transform_mapping_key_type(&mut self, source: &input::MappingKeyType) -> output::TypeName {
+        match source {
+            input::MappingKeyType::ElementaryType(elementary_type) => {
+                output::TypeName::ElementaryType(self.transform_elementary_type(elementary_type))
+            }
+            input::MappingKeyType::IdentifierPath(terminal_nodes) => {
+                output::TypeName::IdentifierPath(self.transform_identifier_path(terminal_nodes))
+            }
+        }
+    }
+
+    fn transform_mapping_value(&mut self, source: &input::MappingValue) -> output::Parameter {
+        let type_name = self.transform_type_name(&source.type_name);
+        let name = source.name.as_ref().map(Rc::clone);
+
+        Rc::new(output::ParameterStruct {
+            node_id: source.node_id,
+            type_name,
+            storage_location: None,
+            name,
+            indexed: false,
+        })
+    }
 }

crates/solidity/outputs/cargo/crate/src/backend/ir/ir2_flat_contracts/transformer.generated.rs

@@ -124,14 +124,8 @@ impl Pass {
             }
             input_ir::TypeName::MappingType(mapping_type) => {
                 let data_location = Some(DataLocation::Storage);
-                let key_type_id = match &mapping_type.key_type.key_type {
-                    input_ir::MappingKeyType::ElementaryType(elementary_type) => {
-                        self.type_of_elementary_type(elementary_type, data_location)
-                    }
-                    input_ir::MappingKeyType::IdentifierPath(identifier_path) => {
-                        self.type_of_identifier_path(identifier_path, data_location)
-                    }
-                }?;
+                let key_type_id =
+                    self.resolve_type_name(&mapping_type.key_type.type_name, data_location)?;
                 let value_type_id =
                     self.resolve_type_name(&mapping_type.value_type.type_name, data_location)?;
                 Some(self.types.register_type(Type::Mapping {

crates/solidity/outputs/cargo/crate/src/backend/ir/ir2_flat_contracts/visitor.generated.rs

@@ -177,15 +177,6 @@ impl Visitor for Pass {
         }
     }
 
-    fn enter_mapping_key_type(&mut self, node: &input_ir::MappingKeyType) -> bool {
-        if let input_ir::MappingKeyType::IdentifierPath(identifier_path) = node {
-            self.resolve_identifier_path(identifier_path);
-            false
-        } else {
-            true
-        }
-    }
-
     fn enter_override_paths(&mut self, items: &input_ir::OverridePaths) -> bool {
         for identifier_path in items {
             self.resolve_identifier_path(identifier_path);