fix: fixed HIR

Author: Zffu

compiler/astoir_hir/src/ctx.rs

@@ -2,14 +2,14 @@
 
 use std::collections::{HashMap, HashSet};
 
-use compiler_typing::{storage::TypeStorage, tree::Type};
+use compiler_typing::{TypedGlobalScope, tree::Type};
 use compiler_utils::{hash::SelfHash, utils::indexed::IndexStorage};
 use diagnostics::{
     DiagnosticResult, DiagnosticSpanOrigin,
     builders::{make_cannot_find_func, make_cannot_find_var, make_doesnt_exist_in_era},
 };
 
-use crate::{nodes::HIRNode, storage::GlobalScopeStorage, structs::HIRStructContainer};
+use crate::{nodes::HIRNode, structs::HIRStructContainer};
 
 pub type HIRFunction = (Option<Type>, Vec<(u64, Type)>, String);
 
@@ -278,8 +278,7 @@ pub struct HIRContext {
     pub function_contexts: Vec<Option<HIRBranchedContext>>,
     pub static_variables: IndexStorage<Type>,
     pub struct_func_impls: HashMap<usize, HIRStructContainer>,
-    pub type_storage: TypeStorage,
-    pub global_scope: GlobalScopeStorage,
+    pub global_scope: TypedGlobalScope,
 }
 
 #[derive(PartialEq)]
@@ -293,11 +292,10 @@ impl HIRContext {
         return HIRContext {
             functions: IndexStorage::new(),
             static_variables: IndexStorage::new(),
-            type_storage: TypeStorage::new().unwrap(),
             function_contexts: vec![],
             function_declarations: vec![],
             struct_func_impls: HashMap::new(),
-            global_scope: GlobalScopeStorage::new(),
+            global_scope: TypedGlobalScope::new(),
         };
     }
 

compiler/astoir_hir/src/lib.rs

@@ -4,5 +4,4 @@
 pub mod ctx;
 pub mod nodes;
 pub mod resolve;
-pub mod storage;
 pub mod structs;

compiler/astoir_hir/src/nodes.rs

@@ -316,7 +316,7 @@ impl HIRNode {
             return Ok(self.clone());
         }
 
-        if self_type.can_transmute(&t, &context.type_storage) {
+        if self_type.can_transmute(&t, &context.global_scope) {
             match &self.kind {
                 HIRNodeKind::IntegerLiteral { value, int_type: _ } => {
                     return Ok(self.with(HIRNodeKind::IntegerLiteral {
@@ -326,7 +326,7 @@ impl HIRNode {
                 }
 
                 HIRNodeKind::ArrayVariableInitializerValue { vals } => {
-                    if can_transmute_inner(&self_type, &t, &context.type_storage) {
+                    if can_transmute_inner(&self_type, &t, &context.global_scope) {
                         let mut new_vals = vec![];
                         let inner = t.get_inner_type();
 
@@ -346,7 +346,7 @@ impl HIRNode {
                 }
 
                 HIRNodeKind::ArrayVariableInitializerValueSameValue { size, val } => {
-                    if can_transmute_inner(&self_type, &t, &context.type_storage) {
+                    if can_transmute_inner(&self_type, &t, &context.global_scope) {
                         let new_val = Box::new(val.use_as(
                             context,
                             curr_ctx,
@@ -355,12 +355,12 @@ impl HIRNode {
                             var_origin,
                         )?);
 
-                        return Ok(
-                            self.with(HIRNodeKind::ArrayVariableInitializerValueSameValue {
+                        return Ok(self.with(
+                            HIRNodeKind::ArrayVariableInitializerValueSameValue {
                                 size: *size,
                                 val: new_val,
-                            }),
-                        );
+                            },
+                        ));
                     }
                 }
 
@@ -379,23 +379,23 @@ impl HIRNode {
             return Err(make_diff_type(
                 origin,
                 &"unnamed".to_string(),
-                &t.faulty_lowering_generic(&context.type_storage),
+                &t.faulty_lowering_generic(&context.global_scope),
                 &self
                     .get_node_type(context, curr_ctx)
                     .unwrap()
-                    .faulty_lowering_generic(&context.type_storage),
+                    .faulty_lowering_generic(&context.global_scope),
                 v,
             )
             .into());
         }
 
         return Err(make_diff_type_val(
             origin,
-            &t.faulty_lowering_generic(&context.type_storage),
+            &t.faulty_lowering_generic(&context.global_scope),
             &self
                 .get_node_type(context, curr_ctx)
                 .unwrap()
-                .faulty_lowering_generic(&context.type_storage),
+                .faulty_lowering_generic(&context.global_scope),
         )
         .into());
     }

compiler/astoir_hir/src/resolve.rs

@@ -29,7 +29,7 @@ pub fn resolve_to_type<K: DiagnosticSpanOrigin>(
                 return Err(make_req_type_kind(origin, &"field-having".to_string()).into());
             }
 
-            for field in destination.get_fields(&context.type_storage) {
+            for field in destination.get_fields(&context.global_scope) {
                 let identity = SelfHash { hash: field };
 
                 if !fields.contains_key(&identity) {
@@ -39,7 +39,7 @@ pub fn resolve_to_type<K: DiagnosticSpanOrigin>(
                 let val = fields[&identity].clone();
 
                 let field_data = destination
-                    .get_field(&context.type_storage, field)?
+                    .get_field(&context.global_scope, field)?
                     .1
                     .resolve(&destination);