fix: fixed HIR lowering layer from errors

Zffu · Zffu · commit 586eab1971ea · 2026-04-21T12:14:49.000+02:00
diff --git a/compiler/astoir_hir_lowering/src/func.rs b/compiler/astoir_hir_lowering/src/func.rs
@@ -145,7 +145,7 @@ pub fn lower_ast_function_declaration(
             implementation.clone(),
             curr_ctx.clone(),
             &*node,
-        );
+        )?;
 
         return Ok(implementation);
     }
diff --git a/compiler/astoir_hir_lowering/src/lib.rs b/compiler/astoir_hir_lowering/src/lib.rs
@@ -123,17 +123,13 @@ pub fn lower_ast_toplevel(
 ) -> DiagnosticResult<bool> {
     match node.kind {
         ASTTreeNodeKind::FunctionDeclaration { .. } => {
-            let func_decl = lower_ast_function_declaration(context, node)?;
-
-            context.function_declarations.push(Some(func_decl));
+            lower_ast_function_declaration(context, node)?;
 
             return Ok(true);
         }
 
         ASTTreeNodeKind::ShadowFunctionDeclaration { .. } => {
-            let func_decl = lower_ast_shadow_function_declaration(context, node)?;
-
-            context.function_declarations.push(Some(func_decl));
+            lower_ast_shadow_function_declaration(context, node)?;
 
             return Ok(true);
         }
diff --git a/compiler/astoir_hir_lowering/src/structs.rs b/compiler/astoir_hir_lowering/src/structs.rs
@@ -1,14 +1,16 @@
-use std::collections::HashMap;
+use std::{
+    collections::HashMap,
+    hash::{DefaultHasher, Hash, Hasher},
+};
 
 use ast::tree::{ASTTreeNode, ASTTreeNodeKind};
 use astoir_hir::{
     ctx::{HIRBranchedContext, HIRContext},
     nodes::{HIRNode, HIRNodeKind},
-    structs::HIRStructContainer,
 };
 use compiler_global_scope::{entry::GlobalStorageEntryType, key::EntryKey};
 use compiler_typing::{raw::RawType, structs::RawStructTypeContainer};
-use compiler_utils::utils::indexed::IndexStorage;
+use compiler_utils::{hash::HashedString, utils::indexed::IndexStorage};
 use diagnostics::{DiagnosticResult, builders::make_already_in_scope};
 
 use crate::{lower_ast_body, types::lower_ast_type_struct, values::lower_ast_value};
@@ -32,7 +34,8 @@ fn lower_ast_struct_function_decl(
     context: &mut HIRContext,
     node: Box<ASTTreeNode>,
     container: &mut RawStructTypeContainer,
-) -> DiagnosticResult<Box<HIRNode>> {
+    ty: RawType,
+) -> DiagnosticResult<(Box<HIRNode>, usize)> {
     if let ASTTreeNodeKind::FunctionDeclaration {
         func_name,
         args,
@@ -66,18 +69,47 @@ fn lower_ast_struct_function_decl(
             .functions
             .append(func_name.hash, (arguments.clone(), ret_type.clone()));
 
-        return Ok(Box::new(HIRNode::new(
+        let implementation = Box::new(HIRNode::new(
             HIRNodeKind::StructFunctionDeclaration {
                 func_name: ind,
-                arguments,
-                return_type: ret_type,
+                arguments: arguments.clone(),
+                return_type: ret_type.clone(),
                 body,
-                ctx: curr_ctx,
+                ctx: curr_ctx.clone(),
                 requires_this,
             },
             &node.start,
             &node.end,
-        )));
+        ));
+
+        let mut hasher = DefaultHasher::new();
+        ty.hash(&mut hasher);
+
+        let fnname = format!("{}$${}", hasher.finish(), func_name.hash);
+
+        let ret_type2;
+        let mut arguments2 = vec![];
+
+        if let Some(v) = ret_type {
+            ret_type2 = Some(v.as_resolved()) // TODO: This unsupports generics, maybe fix later
+        } else {
+            ret_type2 = None;
+        }
+
+        for arg in &arguments {
+            arguments2.push((arg.0, arg.1.clone().as_resolved()));
+        }
+
+        context.global_scope.append_struct_function(
+            EntryKey {
+                name_hash: HashedString::new(fnname.clone()).hash,
+            },
+            (ret_type2, arguments2, fnname),
+            implementation,
+            curr_ctx,
+            ty,
+            &*node,
+        )?;
     }
 
     panic!("Invalid node type")
@@ -98,10 +130,10 @@ pub fn lower_ast_struct_declaration(
             fields: IndexStorage::new(),
             functions: IndexStorage::new(),
             type_params,
+            function_ids: vec![],
+            self_ref: context.global_scope.scope.entries.len(),
         };
 
-        let mut func_impls = vec![];
-
         let base = RawType::Struct(layout, container.clone());
 
         let ind = match context.global_scope.append(
@@ -124,25 +156,23 @@ pub fn lower_ast_struct_declaration(
                         GlobalStorageEntryType::Type(RawType::Struct(layout, container.clone()));
                 }
                 &ASTTreeNodeKind::FunctionDeclaration { .. } => {
-                    let body = lower_ast_struct_function_decl(context, member, &mut container)?;
+                    let body = lower_ast_struct_function_decl(
+                        context,
+                        member,
+                        &mut container,
+                        context.global_scope.scope.entries[ind].as_type_unsafe(),
+                    )?;
+
+                    container.function_ids.push(body.1);
 
                     context.global_scope.scope.entries[ind].entry_type =
                         GlobalStorageEntryType::Type(RawType::Struct(layout, container.clone()));
-
-                    func_impls.push(body);
                 }
 
                 _ => panic!("Invalid node type"),
             };
         }
 
-        context.struct_func_impls.insert(
-            ind,
-            HIRStructContainer {
-                function_impls: func_impls,
-            },
-        );
-
         return Ok(Box::new(HIRNode::new(
             HIRNodeKind::StructDeclaration {
                 type_name: ind,
diff --git a/compiler/astoir_hir_lowering/src/uses.rs b/compiler/astoir_hir_lowering/src/uses.rs
@@ -6,10 +6,7 @@ use ast::{
     types::ASTType,
 };
 use ast_parser::parse_ast_ctx;
-use astoir_hir::{
-    ctx::HIRContext,
-    nodes::{HIRNode, HIRNodeKind},
-};
+use astoir_hir::ctx::HIRContext;
 use compiler_global_scope::{entry::GlobalStorageEntryType, key::EntryKey};
 use compiler_typing::{raw::RawType, tree::Type};
 use compiler_utils::hash::HashedString;
@@ -60,24 +57,13 @@ pub fn handle_ast_use_statement_function_decl(
             arguments.push((arg.name.hash, t));
         }
 
-        let func_name = context.functions.append(
-            func_name.hash,
-            (ret_type.clone(), arguments.clone(), func_name.val.clone()),
-        );
-        context.function_contexts.push(None);
-
-        // Fabricate shadow func statement to satisfy functions_declarations
-
-        let node = HIRNode::new(
-            HIRNodeKind::ShadowFunctionDeclaration {
-                func_name,
-                arguments,
-                return_type: ret_type,
+        let _ = context.global_scope.append_implless_function(
+            EntryKey {
+                name_hash: func_name.hash,
             },
-            &node.start,
-            &node.end,
-        );
-        context.function_declarations.push(Some(Box::new(node)));
+            (ret_type.clone(), arguments.clone(), func_name.val.clone()),
+            &*node,
+        )?;
 
         return Ok(());
     }
diff --git a/compiler/astoir_hir_lowering/src/values.rs b/compiler/astoir_hir_lowering/src/values.rs
@@ -4,13 +4,11 @@ use astoir_hir::{
     nodes::{HIRNode, HIRNodeKind},
     structs::StructLRUStep,
 };
+use compiler_global_scope::key::EntryKey;
 use compiler_typing::tree::Type;
 use diagnostics::{
     DiagnosticResult,
-    builders::{
-        make_cannot_find_func, make_invalid_pointing, make_struct_missing_field,
-        make_struct_missing_func,
-    },
+    builders::{make_invalid_pointing, make_struct_missing_field, make_struct_missing_func},
 };
 
 use crate::{
@@ -66,12 +64,12 @@ pub(crate) fn lower_ast_lru_base(
 
                 ind = res.0;
             } else {
-                ind = match context.functions.get_index(func.hash) {
-                    Some(v) => v,
-                    None => return Err(make_cannot_find_func(&*node, &func.val).into()),
+                let entry = EntryKey {
+                    name_hash: func.hash,
                 };
 
-                func_type = context.functions.vals[ind].clone();
+                ind = context.global_scope.get_ind(entry.clone(), &*node)?;
+                func_type = context.global_scope.get_function_base(entry, &*node)?;
             }
 
             let mut hir_args = vec![];
diff --git a/compiler/compiler_typing/src/raw.rs b/compiler/compiler_typing/src/raw.rs
@@ -349,6 +349,11 @@ impl Hash for RawType {
                 hasher.write_u8(*signed as u8);
             }
 
+            RawType::Struct(_, container) => {
+                hasher.write_usize(9);
+                hasher.write_usize(container.self_ref);
+            }
+
             _ => panic!("Unhashable type {:#?}", self),
         }
     }
diff --git a/compiler/compiler_typing/src/structs.rs b/compiler/compiler_typing/src/structs.rs
@@ -19,6 +19,8 @@ pub struct RawStructTypeContainer {
     pub fields: IndexStorage<TypeReference>,
     pub type_params: TypeParameterContainer,
     pub functions: IndexStorage<TypedFunction>,
+    pub function_ids: Vec<usize>,
+    pub self_ref: usize,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]

Original file line number	Diff line number	Diff line change
`@@ -145,7 +145,7 @@ pub fn lower_ast_function_declaration(`
`145`	`145`	`implementation.clone(),`
`146`	`146`	`curr_ctx.clone(),`
`147`	`147`	`&*node,`
`148`		`- );`
	`148`	`+ )?;`
`149`	`149`
`150`	`150`	`return Ok(implementation);`
`151`	`151`	`}`
Original file line number	Diff line number	Diff line change
`@@ -349,6 +349,11 @@ impl Hash for RawType {`
`349`	`349`	`hasher.write_u8(*signed as u8);`
`350`	`350`	`}`
`351`	`351`
	`352`	`+ RawType::Struct(_, container) => {`
	`353`	`+ hasher.write_usize(9);`
	`354`	`+ hasher.write_usize(container.self_ref);`
	`355`	`+ }`
	`356`	`+`
`352`	`357`	`_ => panic!("Unhashable type {:#?}", self),`
`353`	`358`	`}`
`354`	`359`	`}`
Original file line number	Diff line number	Diff line change
`@@ -19,6 +19,8 @@ pub struct RawStructTypeContainer {`
`19`	`19`	`pub fields: IndexStorage<TypeReference>,`
`20`	`20`	`pub type_params: TypeParameterContainer,`
`21`	`21`	`pub functions: IndexStorage<TypedFunction>,`
	`22`	`+ pub function_ids: Vec<usize>,`
	`23`	`+ pub self_ref: usize,`
`22`	`24`	`}`
`23`	`25`
`24`	`26`	`#[derive(Debug, Clone, PartialEq, Eq)]`