Remove BackendContext and use SemanticAnalysis directly

Also, create the semantic analysis from the `CompilationUnit` in a similar way
as for the current `BindingGraph`.

Author: ggiraldez

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

@@ -1,18 +1,10 @@
 #![allow(missing_docs)]
 
-use std::rc::Rc;
-
-use crate::compilation::CompilationUnit;
-
 pub mod binder;
 pub mod built_ins;
-pub mod context;
 pub mod ir;
 pub mod passes;
+pub mod semantic;
 pub mod types;
 
-pub use context::BackendContext;
-
-pub fn build_context(compilation_unit: Rc<CompilationUnit>) -> Rc<BackendContext> {
-    Rc::new(BackendContext::build(compilation_unit))
-}
+pub use semantic::{SemanticAnalysis, SemanticFile};

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

@@ -1,23 +1,6 @@
-use std::collections::HashMap;
-use std::rc::Rc;
-
 use crate::backend::ir::ir1_structured_ast::{builder, SourceUnit};
-use crate::compilation::CompilationUnit;
-
-pub struct Output {
-    pub compilation_unit: Rc<CompilationUnit>,
-    pub files: HashMap<String, SourceUnit>,
-}
+use crate::compilation::File;
 
-pub fn run(input: Rc<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/p0_build_ast.rs

@@ -1,38 +1,17 @@
-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: Rc<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 {
+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/p1_flatten_contracts.rs

@@ -3,9 +3,9 @@ use std::rc::Rc;
 use semver::Version;
 
 use crate::backend::binder::{Binder, Definition, FileScope, ParametersScope, Scope, ScopeId};
-use crate::backend::context::SemanticAnalysis;
 use crate::backend::ir::ir2_flat_contracts::visitor::Visitor;
 use crate::backend::ir::ir2_flat_contracts::{self as input_ir};
+use crate::backend::semantic::SemanticAnalysis;
 use crate::compilation::File;
 use crate::cst::{NodeId, TerminalNode};
 use crate::utils::versions::VERSION_0_5_0;
@@ -21,9 +21,8 @@ pub fn run(semantic_analysis: &mut SemanticAnalysis) {
         semantic_analysis.language_version().clone(),
         &mut semantic_analysis.binder,
     );
-    for (file_id, source_unit) in &semantic_analysis.files {
-        let file = semantic_analysis.compilation_unit.file(file_id).unwrap();
-        pass.visit_file(file, source_unit);
+    for semantic_file in semantic_analysis.files.values() {
+        pass.visit_file(semantic_file.file(), semantic_file.ir_root());
     }
 }
 
@@ -52,10 +51,10 @@ impl<'a> Pass<'a> {
         }
     }
 
-    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;
 

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

@@ -5,39 +5,31 @@ use crate::backend::binder::{
     Binder, ContractDefinition, Definition, ImportDefinition, InterfaceDefinition,
     LibraryDefinition, Reference, Resolution, ScopeId,
 };
-use crate::backend::context::SemanticAnalysis;
 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;
 
 /// In this pass we collect all bases of contracts and interfaces and then
 /// compute the linearisation for each of them.
 pub fn run(semantic_analysis: &mut SemanticAnalysis) {
-    let mut pass = Pass::new(
-        Rc::clone(&semantic_analysis.compilation_unit),
-        &mut semantic_analysis.binder,
-    );
-    for source_unit in semantic_analysis.files.values() {
-        pass.visit_file_collect_bases(source_unit);
+    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 semantic_analysis.files.values() {
-        pass.visit_file_linearise_contracts(source_unit);
+    for semantic_file in semantic_analysis.files.values() {
+        pass.visit_file_linearise_contracts(semantic_file.ir_root());
     }
 }
 
 pub struct Pass<'a> {
-    pub compilation_unit: Rc<CompilationUnit>,
     pub binder: &'a mut Binder,
 }
 
 impl<'a> Pass<'a> {
-    pub fn new(compilation_unit: Rc<CompilationUnit>, binder: &'a mut Binder) -> Self {
-        Self {
-            compilation_unit,
-            binder,
-        }
+    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/p3_linearise_contracts/mod.rs

@@ -1,8 +1,8 @@
 use semver::Version;
 
 use crate::backend::binder::{Binder, Definition, Scope, ScopeId};
-use crate::backend::context::SemanticAnalysis;
 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::cst::NodeId;
 
@@ -25,11 +25,11 @@ pub fn run(semantic_analysis: &mut SemanticAnalysis) {
         &mut semantic_analysis.binder,
         &mut semantic_analysis.types,
     );
-    for source_unit in semantic_analysis.files.values() {
-        pass.visit_file(source_unit);
+    for semantic_file in semantic_analysis.files.values() {
+        pass.visit_file(semantic_file.ir_root());
     }
-    for source_unit in semantic_analysis.files.values() {
-        pass.visit_file_type_getters(source_unit);
+    for semantic_file in semantic_analysis.files.values() {
+        pass.visit_file_type_getters(semantic_file.ir_root());
     }
 }
 

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

@@ -2,8 +2,8 @@ use semver::Version;
 
 use crate::backend::binder::{Binder, Scope, ScopeId};
 use crate::backend::built_ins::BuiltInsResolver;
-use crate::backend::context::SemanticAnalysis;
 use crate::backend::ir::ir2_flat_contracts::{self as input_ir};
+use crate::backend::semantic::SemanticAnalysis;
 use crate::backend::types::TypeRegistry;
 use crate::cst::NodeId;
 
@@ -23,8 +23,8 @@ pub fn run(semantic_analysis: &mut SemanticAnalysis) {
         &mut semantic_analysis.binder,
         &mut semantic_analysis.types,
     );
-    for source_unit in semantic_analysis.files.values() {
-        pass.visit_file(source_unit);
+    for semantic_file in semantic_analysis.files.values() {
+        pass.visit_file(semantic_file.ir_root());
     }
 }