feat: added HIR scope append functions

Author: Zffu

Cargo.lock

@@ -7,4 +7,5 @@ edition = "2024"
 compiler_utils = { path = "../compiler_utils" }
 diagnostics = { path = "../diagnostics" }
 compiler_typing = { path = "../compiler_typing" }
+compiler_global_scope = { path = "../compiler_global_scope" }
 lexer = { path = "../lexer" }

compiler/astoir_hir/Cargo.toml

@@ -1,6 +1,8 @@
 //! HIR version of the global scope in order to store descriptors and implementations
 
-use compiler_typing::TypedGlobalScope;
+use compiler_global_scope::key::EntryKey;
+use compiler_typing::{TypedGlobalScope, TypedGlobalScopeEntry, raw::RawType, tree::Type};
+use diagnostics::{DiagnosticResult, DiagnosticSpanOrigin};
 
 use crate::{ctx::HIRFunction, nodes::HIRNode};
 
@@ -11,3 +13,102 @@ pub struct HIRGlobalScopeStorage {
     pub descriptors: Vec<HIRFunction>,
     pub implementations: Vec<Box<HIRNode>>,
 }
+
+impl HIRGlobalScopeStorage {
+    pub fn new() -> Self {
+        HIRGlobalScopeStorage {
+            scope: TypedGlobalScope::new(),
+            descriptors: vec![],
+            implementations: vec![],
+        }
+    }
+
+    /// This doesn't automatically handle descriptors and implementations
+    pub fn append<K: DiagnosticSpanOrigin>(
+        &mut self,
+        name: EntryKey,
+        entry: TypedGlobalScopeEntry,
+        origin: &K,
+    ) -> DiagnosticResult<usize> {
+        self.scope.append(name, entry, origin)
+    }
+
+    pub fn append_func<K: DiagnosticSpanOrigin>(
+        &mut self,
+        name: EntryKey,
+        descriptor: HIRFunction,
+        implementation: Box<HIRNode>,
+        origin: &K,
+    ) -> DiagnosticResult<usize> {
+        self.descriptors.push(descriptor);
+        self.implementations.push(implementation);
+
+        self.scope.append(
+            name,
+            TypedGlobalScopeEntry::Function {
+                descriptor_ind: self.scope.descriptor_counter,
+                impl_ind: self.scope.impl_counter,
+            },
+            origin,
+        )
+    }
+
+    pub fn append_implless_function<K: DiagnosticSpanOrigin>(
+        &mut self,
+        name: EntryKey,
+        descriptor: HIRFunction,
+        origin: &K,
+    ) -> DiagnosticResult<usize> {
+        self.descriptors.push(descriptor);
+
+        self.scope.append(
+            name,
+            TypedGlobalScopeEntry::ImplLessFunction(self.scope.descriptor_counter),
+            origin,
+        )
+    }
+
+    pub fn append_struct_function<K: DiagnosticSpanOrigin>(
+        &mut self,
+        name: EntryKey,
+        descriptor: HIRFunction,
+        implementation: Box<HIRNode>,
+        struct_type: RawType,
+        origin: &K,
+    ) -> DiagnosticResult<usize> {
+        self.descriptors.push(descriptor);
+        self.implementations.push(implementation);
+
+        let ind = self.scope.value_to_ind[&TypedGlobalScopeEntry::Type(struct_type)];
+
+        self.scope.append(
+            name,
+            TypedGlobalScopeEntry::StructFunction {
+                descriptor_ind: self.scope.descriptor_counter,
+                impl_ind: self.scope.impl_counter,
+                struct_type: ind,
+            },
+            origin,
+        )
+    }
+
+    pub fn append_type<K: DiagnosticSpanOrigin>(
+        &mut self,
+        name: EntryKey,
+        t: RawType,
+        origin: &K,
+    ) -> DiagnosticResult<usize> {
+        self.scope
+            .append(name, TypedGlobalScopeEntry::Type(t), origin)
+    }
+
+    pub fn append_type_binding<K: DiagnosticSpanOrigin>(
+        &mut self,
+        name: EntryKey,
+        t: Type,
+        origin: &K,
+    ) -> DiagnosticResult<usize> {
+        self.scope
+            .append(name, TypedGlobalScopeEntry::TypeAlias(t), origin)
+    }
+}

compiler/astoir_hir/src/scope.rs

@@ -2,7 +2,7 @@
 
 use std::collections::HashMap;
 
-use compiler_global_scope::GlobalScopeStorage;
+use compiler_global_scope::{GlobalScopeStorage, entry::GlobalStorageEntryType};
 use compiler_utils::hash::HashedString;
 use diagnostics::DiagnosticResult;
 
@@ -18,6 +18,7 @@ pub mod tree;
 pub mod utils;
 
 pub type TypedGlobalScope = GlobalScopeStorage<Type, RawType>;
+pub type TypedGlobalScopeEntry = GlobalStorageEntryType<Type, RawType>;
 
 /// A function contained within a type.
 pub type TypedFunction = (Vec<(u64, TypeReference)>, Option<TypeReference>);