Simplify IR2 language (#1443)

This PR introduces several changes to the shape of the IR2 language used
to compute bindings and typing, to reduce the tree depth and improve its
usability.

- Function types are unified under a single IR2 type
`FunctionDefinition`, which now includes a `kind` discriminator. Regular
functions, constructors, modifiers, and special functions are now all
represented under this type in the IR2 tree.
- Collapsed several non-terminal types which consist of a single content
field and possibly punctuation or fixed unique keywords: parameters and
returns declarations, import aliases, else branches, index access
expressions, etc.
- Simplified arguments for function calls to a choice type with a vector
of expressions for positional parameters, or `NamedArgument` which is an
identifier and the corresponding expression.
- Simplified string literals, which no longer distinguish between single
and double quoted values. This applies to normal strings, hex strings
and unicode strings. Also, the `StringExpression` (for a string literal
value) is now a choice between vectors of strings, hex strings or
unicode strings and the (deprecated in newer Solidity) single value
variants are represented using one element vectors.
- Function and state variable attributes are flattened and categorized
into separate fields: visibility, mutability, override specifiers and
modifier invocations (for functions).
- All optional unique terminals are now represented as a boolean to
indicate the presence of the keyword.

As a result, the number of IR2 node types is reduced and the tree
structure is more shallow, making the passes code simpler.

Author: ggiraldez

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

@@ -0,0 +1,24 @@
+use crate::ir::{IrModel, IrModelMutator, ModelWithBuilder};
+
+pub(super) fn build_from(cst_model: &IrModel) -> ModelWithBuilder {
+    let mut mutator = IrModelMutator::create_from(cst_model);
+
+    // remove fields from sequences that contain redundant terminal nodes
+    for (sequence_id, sequence) in &cst_model.sequences {
+        if sequence.multiple_operators {
+            // don't remove terminals if the sequence is modelling a precedence
+            // expression with multiple variant operators
+            continue;
+        }
+        for field in &sequence.fields {
+            if !field.is_optional
+                && field.r#type.is_terminal()
+                && cst_model.terminals[field.r#type.as_identifier()]
+            {
+                mutator.remove_sequence_field(sequence_id, &field.label);
+            }
+        }
+    }
+
+    mutator.into()
+}

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

@@ -0,0 +1,246 @@
+use crate::ir::{IrModel, IrModelMutator, ModelWithTransformer};
+
+pub(super) fn build_from(structured_ast_model: &IrModel) -> ModelWithTransformer {
+    let mut mutator = IrModelMutator::create_from(structured_ast_model);
+
+    flatten_contract_specifiers(&mut mutator);
+    unify_function_types(&mut mutator);
+    flatten_function_attributes(&mut mutator);
+    flatten_state_variable_attributes(&mut mutator);
+    collapse_redundant_node_types(&mut mutator);
+    simplify_string_literals(&mut mutator);
+
+    mutator.into()
+}
+
+fn flatten_contract_specifiers(mutator: &mut IrModelMutator) {
+    // Flatten contract specifiers and bring the inherited types and storage
+    // layout to the contract definition itself.
+    mutator.remove_type("ContractSpecifiers");
+    mutator.remove_type("ContractSpecifier");
+    mutator.collapse_sequence("InheritanceSpecifier");
+    mutator.collapse_sequence("StorageLayoutSpecifier");
+    mutator.add_sequence_field(
+        "ContractDefinition",
+        "inheritance_types",
+        "InheritanceTypes",
+        false,
+    );
+    mutator.add_sequence_field("ContractDefinition", "storage_layout", "Expression", true);
+}
+
+fn unify_function_types(mutator: &mut IrModelMutator) {
+    // Unifiy function definition types
+    mutator.add_enum_type(
+        "FunctionKind",
+        &[
+            "Regular",
+            "Constructor",
+            "Unnamed",
+            "Fallback",
+            "Receive",
+            "Modifier",
+        ],
+    );
+
+    // Add the kind to the FunctionDefinition type, which will now hold all kinds
+    mutator.add_sequence_field("FunctionDefinition", "kind", "FunctionKind", false);
+
+    // Then remove other specific function types and related attributes
+    mutator.remove_type("ConstructorDefinition");
+    mutator.remove_type("ConstructorAttributes");
+    mutator.remove_type("ConstructorAttribute");
+
+    mutator.remove_type("UnnamedFunctionDefinition");
+    mutator.remove_type("UnnamedFunctionAttributes");
+    mutator.remove_type("UnnamedFunctionAttribute");
+
+    mutator.remove_type("FallbackFunctionDefinition");
+    mutator.remove_type("FallbackFunctionAttributes");
+    mutator.remove_type("FallbackFunctionAttribute");
+
+    mutator.remove_type("ReceiveFunctionDefinition");
+    mutator.remove_type("ReceiveFunctionAttributes");
+    mutator.remove_type("ReceiveFunctionAttribute");
+
+    mutator.remove_type("ModifierDefinition");
+    mutator.remove_type("ModifierAttributes");
+    mutator.remove_type("ModifierAttribute");
+
+    // This also requires modifying the name and body fields
+    mutator.remove_sequence_field("FunctionDefinition", "name");
+    mutator.add_sequence_field("FunctionDefinition", "name", "Identifier", true);
+    mutator.remove_sequence_field("FunctionDefinition", "body");
+    mutator.add_sequence_field("FunctionDefinition", "body", "Block", true);
+
+    // We don't need FunctionName or FunctionBody anymore
+    mutator.remove_type("FunctionName");
+    mutator.remove_type("FunctionBody");
+}
+
+fn flatten_function_attributes(mutator: &mut IrModelMutator) {
+    // Function visibility, computed from a subset of the attributes
+    mutator.add_enum_type(
+        "FunctionVisibility",
+        &["Public", "Private", "Internal", "External"],
+    );
+
+    // Function mutability, computed from a subset of the attributes
+    mutator.add_enum_type(
+        "FunctionMutability",
+        &["Pure", "View", "NonPayable", "Payable"],
+    );
+
+    mutator.add_sequence_field(
+        "FunctionDefinition",
+        "visibility",
+        "FunctionVisibility",
+        false,
+    );
+    mutator.add_sequence_field(
+        "FunctionDefinition",
+        "mutability",
+        "FunctionMutability",
+        false,
+    );
+    // We use an optional unique terminal to effectively have a boolean
+    mutator.add_sequence_field(
+        "FunctionDefinition",
+        "virtual_keyword",
+        "VirtualKeyword",
+        true,
+    );
+
+    // Flatten list of override specifiers and modifier invocations
+    mutator.add_sequence_field(
+        "FunctionDefinition",
+        "override_specifier",
+        "OverridePaths",
+        true,
+    );
+    mutator.add_collection_type("ModifierInvocations", "ModifierInvocation");
+    mutator.add_sequence_field(
+        "FunctionDefinition",
+        "modifier_invocations",
+        "ModifierInvocations",
+        false,
+    );
+
+    // And remove the list of attributes
+    mutator.remove_type("FunctionAttributes");
+    mutator.remove_type("FunctionAttribute");
+
+    // For `FunctionType` we need visibility and mutability
+    mutator.add_sequence_field("FunctionType", "visibility", "FunctionVisibility", false);
+    mutator.add_sequence_field("FunctionType", "mutability", "FunctionMutability", false);
+    mutator.remove_type("FunctionTypeAttributes");
+    mutator.remove_type("FunctionTypeAttribute");
+}
+
+fn flatten_state_variable_attributes(mutator: &mut IrModelMutator) {
+    // Function 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
+    mutator.add_enum_type(
+        "StateVariableMutability",
+        &["Mutable", "Constant", "Immutable", "Transient"],
+    );
+
+    mutator.add_sequence_field(
+        "StateVariableDefinition",
+        "visibility",
+        "StateVariableVisibility",
+        false,
+    );
+    mutator.add_sequence_field(
+        "StateVariableDefinition",
+        "mutability",
+        "StateVariableMutability",
+        false,
+    );
+    mutator.add_sequence_field(
+        "StateVariableDefinition",
+        "override_specifier",
+        "OverridePaths",
+        true,
+    );
+
+    // And remove the list of attributes
+    mutator.remove_type("StateVariableAttributes");
+    mutator.remove_type("StateVariableAttribute");
+}
+
+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");
+    mutator.collapse_sequence("StateVariableDefinitionValue");
+    mutator.collapse_sequence("OverridePathsDeclaration");
+    mutator.collapse_sequence("VariableDeclarationValue");
+    mutator.collapse_sequence("NamedArgumentGroup");
+
+    // Collapse IndexAccessEnd manually (requires code in the transformer
+    // implementation) because it's an optional containing an optional, and that
+    // complicates automatic code generation in the transformer.
+    mutator.remove_type("IndexAccessEnd");
+    mutator.add_sequence_field("IndexAccessExpression", "end", "Expression", true);
+
+    // Collapse the middle node in ArgumentsDeclaration
+    mutator.remove_type("PositionalArgumentsDeclaration");
+    mutator.remove_type("NamedArgumentsDeclaration");
+    mutator.add_choice_variant("ArgumentsDeclaration", "PositionalArguments");
+    mutator.add_choice_variant("ArgumentsDeclaration", "NamedArguments");
+}
+
+fn simplify_string_literals(mutator: &mut IrModelMutator) {
+    // Remove all existing types, as we will simplify them to 3 variants
+    mutator.remove_type("StringLiterals");
+    mutator.remove_type("StringLiteral");
+    mutator.remove_type("HexStringLiterals");
+    mutator.remove_type("HexStringLiteral");
+    mutator.remove_type("UnicodeStringLiterals");
+    mutator.remove_type("UnicodeStringLiteral");
+
+    // Re-declare `StringLiteral`, `HexStringLiteral` and `UnicodeStringLiteral`
+    // as non-unique terminals
+    mutator.add_non_unique_terminal("StringLiteral");
+    mutator.add_non_unique_terminal("HexStringLiteral");
+    mutator.add_non_unique_terminal("UnicodeStringLiteral");
+
+    // Create the collection types using the double-quoted variants.
+    // The choice is irrelevant because we only care that it's a non-unique
+    // terminal, which is represented by an `Rc<TerminalNode>` anyway.
+    mutator.add_collection_type("Strings", "StringLiteral");
+    mutator.add_collection_type("HexStrings", "HexStringLiteral");
+    mutator.add_collection_type("UnicodeStrings", "UnicodeStringLiteral");
+
+    // Now we add the variants to the expression type
+    mutator.add_choice_variant("StringExpression", "Strings");
+    mutator.add_choice_variant("StringExpression", "HexStrings");
+    mutator.add_choice_variant("StringExpression", "UnicodeStrings");
+
+    // Update other uses of StringLiteral
+    mutator.add_sequence_field("PathImport", "path", "StringLiteral", false);
+    mutator.add_sequence_field("NamedImport", "path", "StringLiteral", false);
+    mutator.add_sequence_field("ImportDeconstruction", "path", "StringLiteral", false);
+    mutator.add_choice_variant("ExperimentalFeature", "StringLiteral");
+    mutator.add_choice_variant("YulLiteral", "StringLiteral");
+    mutator.add_choice_variant("YulLiteral", "HexStringLiteral");
+
+    // For `AssemblyFlags`, also remove the enclosing declaration structure
+    mutator.remove_type("AssemblyFlagsDeclaration");
+    mutator.add_collection_type("AssemblyFlags", "StringLiteral");
+    mutator.add_sequence_field("AssemblyStatement", "flags", "AssemblyFlags", false);
+    mutator.add_sequence_field("AssemblyStatement", "label", "StringLiteral", true);
+}

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

@@ -0,0 +1,40 @@
+use std::collections::BTreeMap;
+
+use language_definition::model::Language;
+use serde::Serialize;
+
+use super::{IrModel, ModelWithBuilder, ModelWithTransformer};
+
+mod ir1_structured_ast;
+mod ir2_flat_contracts;
+
+#[derive(Serialize)]
+#[serde(untagged)]
+pub enum GenericModel {
+    ModelWithBuilder(ModelWithBuilder),
+    ModelWithTransformer(ModelWithTransformer),
+}
+
+pub fn build_ir_models(language: &Language) -> BTreeMap<String, GenericModel> {
+    let mut ir_models = BTreeMap::new();
+
+    // IR0: CST:
+    let cst_model = IrModel::from_language(language);
+
+    // IR1: structured AST:
+    let ir1_structured_ast_model = ir1_structured_ast::build_from(&cst_model);
+
+    // IR2: flat contract specifiers:
+    let ir2_flat_contracts_model = ir2_flat_contracts::build_from(&ir1_structured_ast_model.target);
+
+    ir_models.insert(
+        "ir1_structured_ast".to_string(),
+        GenericModel::ModelWithBuilder(ir1_structured_ast_model),
+    );
+    ir_models.insert(
+        "ir2_flat_contracts".to_string(),
+        GenericModel::ModelWithTransformer(ir2_flat_contracts_model),
+    );
+
+    ir_models
+}