Refactor TypeTable

compiler/passes/src/common/mod.rs

@@ -32,7 +32,5 @@ pub use constant_propagation_table::*;
 pub mod symbol_table;
 pub use symbol_table::*;
 
-pub type TypeTable = IndexMap<NodeID, Type>;
-
-use indexmap::IndexMap;
-use leo_ast::{NodeID, Type};
+pub mod type_table;
+pub use type_table::*;

compiler/passes/src/common/rename_table/mod.rs

@@ -14,7 +14,7 @@
 // You should have received a copy of the GNU General Public License
 // along with the Leo library. If not, see <https://www.gnu.org/licenses/>.
 
-use leo_ast::{NodeID};
+use leo_ast::NodeID;
 use leo_span::Symbol;
 
 use indexmap::IndexMap;
@@ -62,8 +62,8 @@ impl RenameTable {
     }
 
     /// Looks up the node ID for `symbol`, recursively checking the parent if it is not found.
-    pub(crate) fn lookup_id(&self, symbol: Symbol) -> Option<&NodeID> {
-        if let Some(id) = self.ids.get(&symbol) {
+    pub(crate) fn lookup_id(&self, symbol: &Symbol) -> Option<&NodeID> {
+        if let Some(id) = self.ids.get(symbol) {
             Some(id)
         } else if let Some(parent) = &self.parent {
             parent.lookup_id(symbol)

compiler/passes/src/common/type_table/mod.rs

@@ -0,0 +1,43 @@
+// Copyright (C) 2019-2023 Aleo Systems Inc.
+// This file is part of the Leo library.
+
+// The Leo library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// The Leo library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with the Leo library. If not, see <https://www.gnu.org/licenses/>.
+
+use leo_ast::{NodeID, Type};
+
+use indexmap::IndexMap;
+use std::{
+    cell::{Ref, RefCell},
+    fmt::Display,
+};
+
+/// A mapping between node IDs and their types.
+#[derive(Debug, Default, Clone)]
+pub struct TypeTable {
+    /// The inner table.
+    /// `RefCell` is used here to avoid `&mut` all over the compiler.
+    inner: RefCell<IndexMap<NodeID, Type>>,
+}
+
+impl TypeTable {
+    /// Gets an entry from the table.
+    pub fn get(&self, index: &NodeID) -> Option<Type> {
+        self.inner.borrow().get(index).cloned()
+    }
+
+    /// Inserts an entry into the table.
+    pub fn insert(&self, index: NodeID, value: Type) {
+        self.inner.borrow_mut().insert(index, value);
+    }
+}