Further simplification of the IR tree (NomicFoundation#1473)

This PR adds more simplifications to the IR tree, reducing the number of
non-terminal node types from 220 to 166. These include:

- Constant non-public `StateVariableDefinition`s are transmuted into
`ConstantDefinition`s (public vars generate a getter, which would trade
the reduced complexity with the binder passes)
- File import clauses are unified under `PathImport`; symbol
deconstruction imports are still a separate node type
- `VariableDeclarationStatement` are used for tuple declarations as
well, so any local variable is now unified under the same type
- Removed redundant `VariableDeclarationType` for an optional `TypeName`
- Parameters (function, error, event) are unified under a single
`Parameter` node type, which now has an `indexed` boolean property to
accommodate event parameters
- `Parameter` is also used for the mapping key and value types as well

Author: ggiraldez

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

@@ -7,8 +7,13 @@ pub(super) fn build_from(structured_ast_model: &IrModel) -> ModelWithTransformer
     unify_function_types(&mut mutator);
     flatten_function_attributes(&mut mutator);
     flatten_state_variable_attributes(&mut mutator);
+    transmute_constant_state_variables(&mut mutator);
     collapse_redundant_node_types(&mut mutator);
     simplify_string_literals(&mut mutator);
+    simplify_imports(&mut mutator);
+    simplify_variable_declarations(&mut mutator);
+    simplify_parameters(&mut mutator);
+    simplify_mapping_type_parameters(&mut mutator);
 
     mutator.into()
 }
@@ -138,13 +143,17 @@ fn flatten_function_attributes(mutator: &mut IrModelMutator) {
 }
 
 fn flatten_state_variable_attributes(mutator: &mut IrModelMutator) {
-    // Function visibility, computed from a subset of the attributes
+    // State variable visibility, computed from a subset of the attributes
     mutator.add_enum_type(
         "StateVariableVisibility",
         &["Public", "Private", "Internal"],
     );
 
-    // Function mutability, computed from a subset of the attributes
+    // State variable mutability, computed from a subset of the attributes.
+    // NB. Even though most constant declarations are transformed into
+    // `ConstantDefinition`, those with `public` visibility need to generate a
+    // getter and thus we still need to represent them using a
+    // `StateVariableDefinition`.
     mutator.add_enum_type(
         "StateVariableMutability",
         &["Mutable", "Constant", "Immutable", "Transient"],
@@ -174,14 +183,35 @@ fn flatten_state_variable_attributes(mutator: &mut IrModelMutator) {
     mutator.remove_type("StateVariableAttribute");
 }
 
+fn transmute_constant_state_variables(mutator: &mut IrModelMutator) {
+    // State variables that are marked constant and are not public will be
+    // transformed into `ConstantDefinition` (ie. the type used for top-level
+    // constant definitions). Public constant state variables *cannot* be
+    // transformed because they generate a getter, so it makes more sense to
+    // keep them as `StateVariableDefinition`
+    mutator.add_choice_variant("ContractMember", "ConstantDefinition");
+
+    // Modify `ConstantDefinition` to accomodate for constant state variables
+    mutator.add_sequence_field(
+        "ConstantDefinition",
+        "visibility",
+        "StateVariableVisibility",
+        true,
+    );
+
+    // ...and make the value optional because state variables may not define it
+    // NOTE: this is not valid Solidity, but we still want to support the
+    // representation until we have robust validation
+    mutator.remove_sequence_field("ConstantDefinition", "value");
+    mutator.add_sequence_field("ConstantDefinition", "value", "Expression", true);
+}
+
 fn collapse_redundant_node_types(mutator: &mut IrModelMutator) {
     // Collapse redundant node types
     mutator.collapse_sequence("ParametersDeclaration");
     mutator.collapse_sequence("ReturnsDeclaration");
     mutator.collapse_sequence("YulParametersDeclaration");
     mutator.collapse_sequence("YulReturnsDeclaration");
-    mutator.collapse_sequence("EventParametersDeclaration");
-    mutator.collapse_sequence("ErrorParametersDeclaration");
     mutator.collapse_sequence("ImportAlias");
     mutator.collapse_sequence("ElseBranch");
     mutator.collapse_sequence("UsingAlias");
@@ -244,3 +274,78 @@ fn simplify_string_literals(mutator: &mut IrModelMutator) {
     mutator.add_sequence_field("AssemblyStatement", "flags", "AssemblyFlags", false);
     mutator.add_sequence_field("AssemblyStatement", "label", "StringLiteral", true);
 }
+
+fn simplify_imports(mutator: &mut IrModelMutator) {
+    // Collapse `ImportDirective` which is only a container for the `ImportClause`
+    mutator.collapse_sequence("ImportDirective");
+    // Remove `NamedImport`, since it can be converted to the equivalent `PathImport`
+    mutator.remove_type("NamedImport");
+    // TODO: collapsing `ImportDirective` means that the `ImportClause` gets
+    // lifted to the `SourceUnitMember` enum and its name is inconsistent with
+    // the rest of the variants (eg. `PragmaDirective` or `UsingDirective`). We
+    // want to either rename `ImportClause` to `ImportDirective` (this may lead
+    // to confusion due to the difference against the CST) or find a new better
+    // name.
+}
+
+fn simplify_variable_declarations(mutator: &mut IrModelMutator) {
+    // Collapse the `VariableDeclarationType` into the parent `VariableDeclarationStatement`
+    mutator.remove_type("VariableDeclarationType");
+    mutator.add_sequence_field(
+        "VariableDeclarationStatement",
+        "type_name",
+        "TypeName",
+        true,
+    );
+
+    // Re-use `VariableDeclarationStatement` for variable declarations in tuple
+    // deconstruction expressions. Remove `TupleMember` first.
+    mutator.remove_type("UntypedTupleMember");
+    mutator.remove_type("TypedTupleMember");
+    mutator.remove_type("TupleMember");
+    mutator.remove_type("TupleDeconstructionElements");
+    mutator.remove_type("TupleDeconstructionElement");
+
+    // Create a `TupleDeconstructionMember` initially as an enum so that the
+    // `None` variant has no child
+    mutator.add_enum_type("TupleDeconstructionMember", &["None"]);
+    mutator.add_choice_variant("TupleDeconstructionMember", "Identifier");
+    mutator.add_choice_variant("TupleDeconstructionMember", "VariableDeclarationStatement");
+    mutator.add_collection_type("TupleDeconstructionMembers", "TupleDeconstructionMember");
+    mutator.add_sequence_field(
+        "TupleDeconstructionStatement",
+        "members",
+        "TupleDeconstructionMembers",
+        false,
+    );
+    // This refactor also means we don't need the `var_keyword` field in the
+    // `TupleDeconstructionStatement` anymore
+    mutator.remove_sequence_field("TupleDeconstructionStatement", "var_keyword");
+}
+
+fn simplify_parameters(mutator: &mut IrModelMutator) {
+    // Replace `EventParameter` and `ErrorParameter` with `Parameter`. This
+    // requires adding an `indexed` attribute (required for event parameters).
+    mutator.add_sequence_field("Parameter", "indexed", "IndexedKeyword", true);
+
+    mutator.remove_type("EventParametersDeclaration");
+    mutator.remove_type("EventParameters");
+    mutator.remove_type("EventParameter");
+    mutator.add_sequence_field("EventDefinition", "parameters", "Parameters", false);
+
+    mutator.remove_type("ErrorParametersDeclaration");
+    mutator.remove_type("ErrorParameters");
+    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/codegen/generator/src/ir/mutator.rs

@@ -366,6 +366,7 @@ impl IrModelMutator {
             !replace_field.is_optional,
             "Cannot collapse sequence {sequence_id} of an optional field"
         );
+        let replaced_type = self.find_node_type(&sequence_id.into());
 
         // Iterate remaining sequences and replace any fields referencing the
         // removed type by the target type
@@ -377,6 +378,20 @@ impl IrModelMutator {
             }
         }
 
+        // Iterate choice types, remove type to be collapsed and add the
+        // replacement variant instead
+        // TODO: the transformer for this case is not generated automatically,
+        // but if we change the structure of `MutatedChoice` we could accomodate it
+        for (_, choice) in &mut self.choices {
+            if choice.variants.contains(&replaced_type) {
+                choice.has_removed_variants = true;
+                choice.variants.retain(|item| *item != identifier);
+                choice
+                    .added_variants
+                    .push(replace_field.target_type.clone());
+            }
+        }
+
         // Determine the target type; the type of the single field may be
         // already collapsed, so we need to use it in that case
         let target_type = if let Some(collapsed) = self