Rename contexts to highlight the inner contexts are shared rather tha…

…n used directly

crates/noirc_evaluator/src/ssa_refactor/ssa_builder/function_builder.rs

@@ -3,7 +3,7 @@ use crate::ssa_refactor::ir::{
     function::{Function, FunctionId},
 };
 
-use super::Builder;
+use super::SharedBuilderContext;
 
 /// The per-function context for each ssa function being generated.
 ///
@@ -13,7 +13,7 @@ use super::Builder;
 /// Contrary to the name, this struct has the capacity to build as many
 /// functions as needed, although it is limited to one function at a time.
 pub(crate) struct FunctionBuilder<'ssa> {
-    global_context: &'ssa Builder,
+    global_context: &'ssa SharedBuilderContext,
 
     current_function: Function,
     current_function_id: FunctionId,
@@ -24,7 +24,7 @@ pub(crate) struct FunctionBuilder<'ssa> {
 }
 
 impl<'ssa> FunctionBuilder<'ssa> {
-    pub(crate) fn new(parameters: usize, context: &'ssa Builder) -> Self {
+    pub(crate) fn new(parameters: usize, context: &'ssa SharedBuilderContext) -> Self {
         let new_function = Function::new(parameters);
         let current_block = new_function.entry_block();
 

crates/noirc_evaluator/src/ssa_refactor/ssa_builder/mod.rs

@@ -8,11 +8,11 @@ use crate::ssa_refactor::ir::{
 /// The global context while building the ssa representation.
 /// Because this may be shared across threads, it is synchronized internally as necessary.
 #[derive(Default)]
-pub(crate) struct Builder {
+pub(crate) struct SharedBuilderContext {
     function_count: AtomicCounter<Function>,
 }
 
-impl Builder {
+impl SharedBuilderContext {
     pub(super) fn next_function(&self) -> FunctionId {
         self.function_count.next()
     }

crates/noirc_evaluator/src/ssa_refactor/ssa_gen/context.rs

@@ -4,7 +4,7 @@ use std::sync::{Mutex, RwLock};
 use noirc_frontend::monomorphization::ast::{self, LocalId};
 use noirc_frontend::monomorphization::ast::{FuncId, Program};
 
-use crate::ssa_refactor::ssa_builder::Builder;
+use crate::ssa_refactor::ssa_builder::SharedBuilderContext;
 use crate::ssa_refactor::{
     ir::function::FunctionId as IrFunctionId, ssa_builder::function_builder::FunctionBuilder,
 };
@@ -17,11 +17,11 @@ type FunctionQueue = Vec<(ast::FuncId, IrFunctionId)>;
 pub(super) struct FunctionContext<'a> {
     definitions: HashMap<LocalId, Value>,
     function_builder: FunctionBuilder<'a>,
-    shared_context: &'a Context,
+    shared_context: &'a SharedContext,
 }
 
 /// Shared context for all functions during ssa codegen
-pub(super) struct Context {
+pub(super) struct SharedContext {
     functions: RwLock<HashMap<FuncId, IrFunctionId>>,
     function_queue: Mutex<FunctionQueue>,
     pub(super) program: Program,
@@ -30,8 +30,8 @@ pub(super) struct Context {
 impl<'a> FunctionContext<'a> {
     pub(super) fn new(
         parameter_count: usize,
-        shared_context: &'a Context,
-        shared_builder_context: &'a Builder,
+        shared_context: &'a SharedContext,
+        shared_builder_context: &'a SharedBuilderContext,
     ) -> Self {
         Self {
             definitions: HashMap::new(),
@@ -49,7 +49,7 @@ impl<'a> FunctionContext<'a> {
     }
 }
 
-impl Context {
+impl SharedContext {
     pub(super) fn new(program: Program) -> Self {
         Self { functions: Default::default(), function_queue: Default::default(), program }
     }

crates/noirc_evaluator/src/ssa_refactor/ssa_gen/mod.rs

@@ -1,17 +1,17 @@
 mod context;
 mod value;
 
-use context::Context;
+use context::SharedContext;
 use noirc_errors::Location;
 use noirc_frontend::monomorphization::ast::{self, Expression, Program};
 
 use self::{context::FunctionContext, value::Value};
 
-use super::ssa_builder::Builder;
+use super::ssa_builder::SharedBuilderContext;
 
 pub(crate) fn generate_ssa(program: Program) {
-    let context = Context::new(program);
-    let builder_context = Builder::default();
+    let context = SharedContext::new(program);
+    let builder_context = SharedBuilderContext::default();
 
     let main = context.program.main();
     // TODO struct parameter counting