Introduce SemanticAnalysis to gather the IR, binding and typing (NomicFoundation#1476)

The new `SemanticAnalysis` object is the composition of the `Binder`,
`TypeRegistry` and the IR trees for all the files in the
`CompilationUnit`. Replaces the ad-hoc `Output` structure from the last
pass in the backend pipeline. It's created from the `CompilationUnit` in
a similar way to how the current `BindingGraph`.

NOTE: this is only the introduction of the type to provide a foundation
to build on. The API of `SemanticAnalysis` is not designed yet.

Author: ggiraldez

crates/solidity/outputs/cargo/crate/src/backend/mod.rs

@@ -1,20 +1,10 @@
 #![allow(missing_docs)]
 
-use crate::compilation::CompilationUnit;
-
 pub mod binder;
 pub mod built_ins;
 pub mod ir;
 pub mod passes;
+pub mod semantic;
 pub mod types;
 
-pub type BinderOutput = passes::p5_resolve_references::Output;
-
-pub fn build_binder_output(compilation_unit: CompilationUnit) -> BinderOutput {
-    let data = passes::p0_build_ast::run(compilation_unit);
-    let data = passes::p1_flatten_contracts::run(data);
-    let data = passes::p2_collect_definitions::run(data);
-    let data = passes::p3_linearise_contracts::run(data);
-    let data = passes::p4_type_definitions::run(data);
-    passes::p5_resolve_references::run(data)
-}
+pub use semantic::{SemanticAnalysis, SemanticFile};

crates/solidity/outputs/cargo/crate/src/backend/passes/p0_build_ast.rs

@@ -1,22 +1,6 @@
-use std::collections::HashMap;
-
 use crate::backend::ir::ir1_structured_ast::{builder, SourceUnit};
-use crate::compilation::CompilationUnit;
-
-pub struct Output {
-    pub compilation_unit: CompilationUnit,
-    pub files: HashMap<String, SourceUnit>,
-}
+use crate::compilation::File;
 
-pub fn run(input: CompilationUnit) -> Output {
-    let mut files = HashMap::new();
-    for file in &input.files() {
-        if let Some(source_unit) = builder::build_source_unit(file.tree()) {
-            files.insert(file.id().into(), source_unit);
-        }
-    }
-    Output {
-        compilation_unit: input,
-        files,
-    }
+pub fn run_file(file: &File) -> Option<SourceUnit> {
+    builder::build_source_unit(file.tree())
 }

crates/solidity/outputs/cargo/crate/src/backend/passes/p1_flatten_contracts.rs

@@ -1,38 +1,21 @@
-use std::collections::HashMap;
 use std::rc::Rc;
 
 use semver::Version;
 
-use super::p0_build_ast::Output as Input;
 use crate::backend::ir::ir2_flat_contracts::transformer::Transformer;
-use crate::backend::ir::ir2_flat_contracts::{self as output, input, SourceUnit};
-use crate::compilation::CompilationUnit;
+use crate::backend::ir::ir2_flat_contracts::{self as output, input};
 use crate::cst::TerminalNode;
 use crate::utils::versions::VERSION_0_5_0;
 
-pub struct Output {
-    pub compilation_unit: CompilationUnit,
-    pub files: HashMap<String, SourceUnit>,
-}
-
-/// This pass is reserved to make ergonomic changes to the AST in order to make
-/// it easier to use. For now, it will only flatten contract specifiers:
-/// inheritance and storage layout specifiers. In the future, more
-/// transformations will be added.
-pub fn run(input: Input) -> Output {
+/// This pass makes ergonomic changes to the AST in order to make it easier to
+/// use. It includes changes such as removing redundant intermediate nodes,
+/// unifying similar node types and computing visibility/mutability from
+/// collections of attributes.
+pub fn run_file(language_version: &Version, source_unit: &input::SourceUnit) -> output::SourceUnit {
     let mut pass = Pass {
-        language_version: input.compilation_unit.language_version().clone(),
+        language_version: language_version.clone(),
     };
-    let files = input
-        .files
-        .iter()
-        .map(|(file_id, source_unit)| (file_id.clone(), pass.transform_source_unit(source_unit)))
-        .collect();
-    let compilation_unit = input.compilation_unit;
-    Output {
-        compilation_unit,
-        files,
-    }
+    pass.transform_source_unit(source_unit)
 }
 
 struct Pass {

crates/solidity/outputs/cargo/crate/src/backend/passes/p2_collect_definitions.rs

@@ -1,42 +1,28 @@
-use std::collections::HashMap;
 use std::rc::Rc;
 
 use semver::Version;
 
-use super::p1_flatten_contracts::Output as Input;
 use crate::backend::binder::{Binder, Definition, FileScope, ParametersScope, Scope, ScopeId};
 use crate::backend::ir::ir2_flat_contracts::visitor::Visitor;
 use crate::backend::ir::ir2_flat_contracts::{self as input_ir};
-use crate::compilation::{CompilationUnit, File};
+use crate::backend::semantic::SemanticAnalysis;
+use crate::compilation::File;
 use crate::cst::{NodeId, TerminalNode};
 use crate::utils::versions::VERSION_0_5_0;
 
-pub struct Output {
-    pub compilation_unit: CompilationUnit,
-    pub files: HashMap<String, input_ir::SourceUnit>,
-    pub binder: Binder,
-}
-
 /// In this pass all definitions are collected with their naming identifiers.
 /// Also lexical (and other kinds of) scopes are identified and linked together,
 /// and definitions are registered into them for later lookup. The pass
 /// instantiates a `Binder` object which will store all this information as well
 /// as references and typing information for the nodes, to be resolved in later
 /// passes.
-pub fn run(input: Input) -> Output {
-    let files = input.files;
-    let compilation_unit = input.compilation_unit;
-    let mut pass = Pass::new(compilation_unit.language_version());
-    for (file_id, source_unit) in &files {
-        let file = compilation_unit.file(file_id).unwrap();
-        pass.visit_file(file, source_unit);
-    }
-    let binder = pass.binder;
-
-    Output {
-        compilation_unit,
-        files,
-        binder,
+pub fn run(semantic_analysis: &mut SemanticAnalysis) {
+    let mut pass = Pass::new(
+        semantic_analysis.language_version().clone(),
+        &mut semantic_analysis.binder,
+    );
+    for semantic_file in semantic_analysis.files.values() {
+        pass.visit_file(semantic_file.file(), semantic_file.ir_root());
     }
 }
 
@@ -48,27 +34,27 @@ struct ScopeFrame {
     lexical_scope_id: ScopeId,
 }
 
-struct Pass {
+struct Pass<'a> {
     language_version: Version,
     current_file: Option<Rc<File>>, // needed to resolve imports on the file
     scope_stack: Vec<ScopeFrame>,
-    binder: Binder,
+    binder: &'a mut Binder,
 }
 
-impl Pass {
-    fn new(language_version: &Version) -> Self {
+impl<'a> Pass<'a> {
+    fn new(language_version: Version, binder: &'a mut Binder) -> Self {
         Self {
-            language_version: language_version.clone(),
+            language_version,
             current_file: None,
             scope_stack: Vec::new(),
-            binder: Binder::new(),
+            binder,
         }
     }
 
-    fn visit_file(&mut self, file: Rc<File>, source_unit: &input_ir::SourceUnit) {
+    fn visit_file(&mut self, file: &Rc<File>, source_unit: &input_ir::SourceUnit) {
         assert!(self.current_file.is_none());
 
-        self.current_file = Some(file);
+        self.current_file = Some(Rc::clone(file));
         input_ir::visitor::accept_source_unit(source_unit, self);
         self.current_file = None;
 
@@ -233,7 +219,7 @@ impl Pass {
     }
 }
 
-impl Visitor for Pass {
+impl Visitor for Pass<'_> {
     fn enter_source_unit(&mut self, node: &input_ir::SourceUnit) -> bool {
         let Some(current_file) = &self.current_file else {
             unreachable!("visiting SourceUnit without a current file being set");

crates/solidity/outputs/cargo/crate/src/backend/passes/p3_linearise_contracts/mod.rs

@@ -1,55 +1,35 @@
 use std::collections::HashMap;
 use std::rc::Rc;
 
-use super::p2_collect_definitions::Output as Input;
 use crate::backend::binder::{
     Binder, ContractDefinition, Definition, ImportDefinition, InterfaceDefinition,
     LibraryDefinition, Reference, Resolution, ScopeId,
 };
 use crate::backend::ir::ir2_flat_contracts::{self as input_ir};
-use crate::compilation::CompilationUnit;
+use crate::backend::semantic::SemanticAnalysis;
 use crate::cst::NodeId;
 
 mod c3;
 
-pub struct Output {
-    pub compilation_unit: CompilationUnit,
-    pub files: HashMap<String, input_ir::SourceUnit>,
-    pub binder: Binder,
-}
-
 /// In this pass we collect all bases of contracts and interfaces and then
 /// compute the linearisation for each of them.
-pub fn run(input: Input) -> Output {
-    let files = input.files;
-    let mut pass = Pass::new(input.compilation_unit, input.binder);
-    for source_unit in files.values() {
-        pass.visit_file_collect_bases(source_unit);
+pub fn run(semantic_analysis: &mut SemanticAnalysis) {
+    let mut pass = Pass::new(&mut semantic_analysis.binder);
+    for semantic_file in semantic_analysis.files.values() {
+        pass.visit_file_collect_bases(semantic_file.ir_root());
     }
-    for source_unit in files.values() {
-        pass.visit_file_linearise_contracts(source_unit);
-    }
-
-    let compilation_unit = pass.compilation_unit;
-    let binder = pass.binder;
-    Output {
-        compilation_unit,
-        files,
-        binder,
+    for semantic_file in semantic_analysis.files.values() {
+        pass.visit_file_linearise_contracts(semantic_file.ir_root());
     }
 }
 
-pub struct Pass {
-    pub compilation_unit: CompilationUnit,
-    pub binder: Binder,
+pub struct Pass<'a> {
+    pub binder: &'a mut Binder,
 }
 
-impl Pass {
-    pub fn new(compilation_unit: CompilationUnit, binder: Binder) -> Self {
-        Self {
-            compilation_unit,
-            binder,
-        }
+impl<'a> Pass<'a> {
+    pub fn new(binder: &'a mut Binder) -> Self {
+        Self { binder }
     }
 
     fn visit_file_collect_bases(&mut self, source_unit: &input_ir::SourceUnit) {

crates/solidity/outputs/cargo/crate/src/backend/passes/p4_type_definitions/mod.rs

@@ -1,25 +1,15 @@
-use std::collections::HashMap;
-
 use semver::Version;
 
-use super::p3_linearise_contracts::Output as Input;
 use crate::backend::binder::{Binder, Definition, Scope, ScopeId};
 use crate::backend::ir::ir2_flat_contracts::{self as input_ir};
+use crate::backend::semantic::SemanticAnalysis;
 use crate::backend::types::{Type, TypeId, TypeRegistry};
-use crate::compilation::CompilationUnit;
 use crate::cst::NodeId;
 
 mod resolution;
 mod typing;
 mod visitor;
 
-pub struct Output {
-    pub compilation_unit: CompilationUnit,
-    pub files: HashMap<String, input_ir::SourceUnit>,
-    pub binder: Binder,
-    pub types: TypeRegistry,
-}
-
 /// This pass will determine and assign typing information to all the
 /// definitions collected in the earlier pass and as a result register most
 /// types used in the compilation unit, by instantiating a `TypeRegistry`
@@ -29,42 +19,35 @@ pub struct Output {
 /// Finally, public state variables will be assigned an equivalent getter
 /// function type. This happens after the main typing pass to ensure all types
 /// are already registered.
-pub fn run(input: Input) -> Output {
-    let files = input.files;
-    let compilation_unit = input.compilation_unit;
-    let mut pass = Pass::new(input.binder, compilation_unit.language_version());
-    for source_unit in files.values() {
-        pass.visit_file(source_unit);
+pub fn run(semantic_analysis: &mut SemanticAnalysis) {
+    let mut pass = Pass::new(
+        semantic_analysis.language_version().clone(),
+        &mut semantic_analysis.binder,
+        &mut semantic_analysis.types,
+    );
+    for semantic_file in semantic_analysis.files.values() {
+        pass.visit_file(semantic_file.ir_root());
     }
-    for source_unit in files.values() {
-        pass.visit_file_type_getters(source_unit);
-    }
-    let binder = pass.binder;
-    let types = pass.types;
-
-    Output {
-        compilation_unit,
-        files,
-        binder,
-        types,
+    for semantic_file in semantic_analysis.files.values() {
+        pass.visit_file_type_getters(semantic_file.ir_root());
     }
 }
 
-struct Pass {
+struct Pass<'a> {
     language_version: Version,
     scope_stack: Vec<ScopeId>,
-    binder: Binder,
-    types: TypeRegistry,
+    binder: &'a mut Binder,
+    types: &'a mut TypeRegistry,
     current_receiver_type: Option<TypeId>,
 }
 
-impl Pass {
-    fn new(binder: Binder, language_version: &Version) -> Self {
+impl<'a> Pass<'a> {
+    fn new(language_version: Version, binder: &'a mut Binder, types: &'a mut TypeRegistry) -> Self {
         Self {
-            language_version: language_version.clone(),
+            language_version,
             scope_stack: Vec::new(),
             binder,
-            types: TypeRegistry::new(language_version.clone()),
+            types,
             current_receiver_type: None,
         }
     }

crates/solidity/outputs/cargo/crate/src/backend/passes/p4_type_definitions/resolution.rs

@@ -8,7 +8,7 @@ use crate::backend::binder::{
 use crate::backend::ir::ir2_flat_contracts::{self as input_ir};
 use crate::backend::types::{DataLocation, FunctionType, Type, TypeId};
 
-impl Pass {
+impl Pass<'_> {
     // Resolves an IdentifierPath. It starts resolution at the "contract" scope
     // level, or at the file level if there's no contract scope open. It will
     // follow through in contracts/intrefaces/libraries as well as imports and

crates/solidity/outputs/cargo/crate/src/backend/passes/p4_type_definitions/typing.rs

@@ -4,7 +4,7 @@ use crate::backend::ir::ir2_flat_contracts::{self as input_ir};
 use crate::backend::types::{DataLocation, FunctionType, FunctionTypeKind, Type, TypeId};
 use crate::cst::NodeId;
 
-impl Pass {
+impl Pass<'_> {
     pub(super) fn type_of_identifier_path(
         &mut self,
         identifier_path: &input_ir::IdentifierPath,

crates/solidity/outputs/cargo/crate/src/backend/passes/p4_type_definitions/visitor.rs

@@ -10,7 +10,7 @@ use crate::backend::types::{DataLocation, Type};
 use crate::cst::TerminalKind;
 use crate::utils::versions::VERSION_0_5_0;
 
-impl Visitor for Pass {
+impl Visitor for Pass<'_> {
     fn enter_source_unit(&mut self, node: &input_ir::SourceUnit) -> bool {
         self.enter_scope_for_node_id(node.node_id);
         true

crates/solidity/outputs/cargo/crate/src/backend/passes/p5_resolve_references/disambiguation.rs

@@ -4,7 +4,7 @@ use crate::backend::types::{FunctionType, Type, TypeId};
 use crate::cst::NodeId;
 
 /// Disambiguation functions that require typing (aka overload resolution)
-impl Pass {
+impl Pass<'_> {
     fn get_function_definition_parameters(
         &self,
         definition_id: Option<NodeId>,