Finished adding support for private file-local functions

Author: IsaacShelton

Diff for: src/resolve/func_body.rs

@@ -21,7 +21,7 @@ pub fn resolve_func_bodies(
     while let Some(job) = ctx.jobs.pop_front() {
         match job {
             FuncJob::Regular(physical_file_id, ast_func_index, func_ref) => {
-                let module_file_id = ast_workspace.get_owning_module_or_self(physical_file_id);
+                let module_folder_id = ast_workspace.get_owning_module_or_self(physical_file_id);
 
                 let ast_file = ast_workspace
                     .files
@@ -37,7 +37,7 @@ pub fn resolve_func_bodies(
                     ctx,
                     asg,
                     ast_workspace,
-                    module_file_id,
+                    module_folder_id,
                     physical_file_id,
                     ast_function,
                     func_ref,
@@ -49,7 +49,7 @@ pub fn resolve_func_bodies(
                 ast_impl_function_index,
                 func_ref,
             ) => {
-                let module_file_id = ast_workspace.get_owning_module_or_self(physical_file_id);
+                let module_folder_id = ast_workspace.get_owning_module_or_self(physical_file_id);
 
                 let ast_file = ast_workspace
                     .files
@@ -68,7 +68,7 @@ pub fn resolve_func_bodies(
                     ctx,
                     asg,
                     ast_workspace,
-                    module_file_id,
+                    module_folder_id,
                     physical_file_id,
                     ast_function,
                     func_ref,
@@ -84,20 +84,20 @@ fn resolve_func_body(
     ctx: &mut ResolveCtx,
     asg: &mut Asg,
     ast_workspace: &AstWorkspace,
-    module_file_id: FsNodeId,
+    module_folder_id: FsNodeId,
     physical_file_id: FsNodeId,
     ast_function: &ast::Func,
     func_ref: FuncRef,
 ) -> Result<(), ResolveError> {
     let func_haystack = ctx
         .func_haystacks
-        .get(&module_file_id)
+        .get(&module_folder_id)
         .expect("function haystack to exist for file");
 
     let variable_haystack = resolve_param_vars(
         ctx,
         asg,
-        module_file_id,
+        module_folder_id,
         physical_file_id,
         ast_function,
         func_ref,
@@ -122,7 +122,7 @@ fn resolve_func_body(
             globals_in_modules: &ctx.globals_in_modules,
             helper_exprs_in_modules: &mut ctx.helper_exprs_in_modules,
             impls_in_modules: &mut ctx.impls_in_modules,
-            module_fs_node_id: module_file_id,
+            module_fs_node_id: module_folder_id,
             physical_fs_node_id: physical_file_id,
         },
         &ast_function.stmts,
@@ -140,7 +140,7 @@ fn resolve_func_body(
 fn resolve_param_vars(
     ctx: &ResolveCtx,
     asg: &mut Asg,
-    module_file_id: FsNodeId,
+    module_folder_id: FsNodeId,
     physical_file_id: FsNodeId,
     ast_func: &ast::Func,
     func_ref: FuncRef,
@@ -150,7 +150,7 @@ fn resolve_param_vars(
     for param in ast_func.head.params.required.iter() {
         let type_ctx = ResolveTypeCtx::new(
             &asg,
-            module_file_id,
+            module_folder_id,
             physical_file_id,
             &ctx.types_in_modules,
         );

Diff for: src/resolve/func_haystack.rs

@@ -20,7 +20,6 @@ use std::collections::HashMap;
 pub struct FuncHaystack {
     pub available: HashMap<ResolvedName, Vec<asg::FuncRef>>,
     pub imported_namespaces: Vec<Box<str>>,
-    pub physical_fs_node_id: FsNodeId,
     pub module_fs_node_id: FsNodeId,
 }
 
@@ -31,15 +30,10 @@ pub enum FindFunctionError {
 }
 
 impl FuncHaystack {
-    pub fn new(
-        imported_namespaces: Vec<Box<str>>,
-        physical_fs_node_id: FsNodeId,
-        module_fs_node_id: FsNodeId,
-    ) -> Self {
+    pub fn new(imported_namespaces: Vec<Box<str>>, module_fs_node_id: FsNodeId) -> Self {
         Self {
             available: Default::default(),
             imported_namespaces,
-            physical_fs_node_id,
             module_fs_node_id,
         }
     }
@@ -66,10 +60,10 @@ impl FuncHaystack {
             .get(&ResolvedName::new(self.module_fs_node_id, name))
             .into_iter()
             .chain(
-                (self.module_fs_node_id != self.physical_fs_node_id)
+                (self.module_fs_node_id != ctx.physical_fs_node_id)
                     .then(|| {
                         self.available
-                            .get(&ResolvedName::new(self.physical_fs_node_id, name))
+                            .get(&ResolvedName::new(ctx.physical_fs_node_id, name))
                     })
                     .into_iter()
                     .flatten(),
@@ -213,10 +207,10 @@ impl FuncHaystack {
             .get(&ResolvedName::new(self.module_fs_node_id, name))
             .into_iter()
             .chain(
-                (self.module_fs_node_id != self.physical_fs_node_id)
+                (self.module_fs_node_id != ctx.physical_fs_node_id)
                     .then(|| {
                         self.available
-                            .get(&ResolvedName::new(self.physical_fs_node_id, name))
+                            .get(&ResolvedName::new(ctx.physical_fs_node_id, name))
                     })
                     .into_iter()
                     .flatten(),

Diff for: src/resolve/func_head.rs

@@ -26,15 +26,15 @@ pub fn create_func_heads<'a>(
     options: &BuildOptions,
 ) -> Result<(), ResolveError> {
     for (physical_file_id, file) in ast_workspace.files.iter() {
-        let module_file_id = ast_workspace.get_owning_module_or_self(*physical_file_id);
+        let module_folder_id = ast_workspace.get_owning_module_or_self(*physical_file_id);
 
-        create_impl_heads(ctx, asg, options, module_file_id, *physical_file_id, file)?;
+        create_impl_heads(ctx, asg, options, module_folder_id, *physical_file_id, file)?;
 
         for (func_i, func) in file.funcs.iter().enumerate() {
             let name = if func.head.privacy.is_private() {
                 ResolvedName::new(*physical_file_id, &Name::plain(&func.head.name))
             } else {
-                ResolvedName::new(module_file_id, &Name::plain(&func.head.name))
+                ResolvedName::new(module_folder_id, &Name::plain(&func.head.name))
             };
 
             let func_ref = create_func_head(
@@ -43,13 +43,13 @@ pub fn create_func_heads<'a>(
                 options,
                 name.clone(),
                 &func.head,
-                module_file_id,
+                module_folder_id,
                 *physical_file_id,
             )?;
 
             if func.head.privacy.is_public() {
                 let name = &func.head.name;
-                let public_of_module = ctx.public_funcs.entry(module_file_id).or_default();
+                let public_of_module = ctx.public_funcs.entry(module_folder_id).or_default();
 
                 public_of_module
                     .get_or_insert_with(name, || Default::default())
@@ -59,13 +59,12 @@ pub fn create_func_heads<'a>(
             let settings = file.settings.map(|id| &ast_workspace.settings[id.0]);
             let imported_namespaces = settings.map(|settings| &settings.imported_namespaces);
 
-            let func_haystack = ctx.func_haystacks.get_or_insert_with(module_file_id, || {
+            let func_haystack = ctx.func_haystacks.get_or_insert_with(module_folder_id, || {
                 FuncHaystack::new(
                     imported_namespaces
                         .map(|namespaces| namespaces.clone())
                         .unwrap_or_else(|| vec![]),
-                    *physical_file_id,
-                    module_file_id,
+                    module_folder_id,
                 )
             });
 
@@ -89,12 +88,12 @@ pub fn create_func_head<'a>(
     options: &BuildOptions,
     name: ResolvedName,
     head: &FuncHead,
-    module_file_id: FsNodeId,
+    module_folder_id: FsNodeId,
     physical_file_id: FsNodeId,
 ) -> Result<FuncRef, ResolveError> {
     let type_ctx = ResolveTypeCtx::new(
         &asg,
-        module_file_id,
+        module_folder_id,
         physical_file_id,
         &ctx.types_in_modules,
     );

Diff for: src/resolve/global_variable.rs

@@ -15,18 +15,18 @@ pub fn resolve_global_variables(
     ast_workspace: &AstWorkspace,
 ) -> Result<(), ResolveError> {
     for (physical_file_id, file) in ast_workspace.files.iter() {
-        let module_file_id = ast_workspace.get_owning_module_or_self(*physical_file_id);
+        let module_folder_id = ast_workspace.get_owning_module_or_self(*physical_file_id);
 
         for global in file.global_variables.iter() {
             let type_ctx = ResolveTypeCtx::new(
                 &asg,
-                module_file_id,
+                module_folder_id,
                 *physical_file_id,
                 &ctx.types_in_modules,
             );
 
             let ty = type_ctx.resolve(&global.ast_type, ResolveTypeOptions::Unalias)?;
-            let resolved_name = ResolvedName::new(module_file_id, &Name::plain(&global.name));
+            let resolved_name = ResolvedName::new(module_folder_id, &Name::plain(&global.name));
 
             let global_ref = asg.globals.insert(asg::GlobalVar {
                 name: resolved_name,
@@ -37,7 +37,7 @@ pub fn resolve_global_variables(
             });
 
             ctx.globals_in_modules
-                .entry(module_file_id)
+                .entry(module_folder_id)
                 .or_default()
                 .insert(
                     global.name.clone(),

Diff for: src/resolve/helper_expr.rs

@@ -16,13 +16,13 @@ pub fn resolve_helper_expressions(
     ast_workspace: &AstWorkspace,
 ) -> Result<(), ResolveError> {
     for (physical_file_id, file) in ast_workspace.files.iter() {
-        let module_file_id = ast_workspace.get_owning_module_or_self(*physical_file_id);
+        let module_folder_id = ast_workspace.get_owning_module_or_self(*physical_file_id);
         let settings = &ast_workspace.settings[file.settings.unwrap_or_default().0];
 
         // NOTE: This module should already have a function haystack
         let func_haystack = ctx
             .func_haystacks
-            .get(&module_file_id)
+            .get(&module_folder_id)
             .expect("function haystack to exist for file");
 
         for helper_expr in file.helper_exprs.iter() {
@@ -39,7 +39,7 @@ pub fn resolve_helper_expressions(
                     globals_in_modules: &ctx.globals_in_modules,
                     helper_exprs_in_modules: &ctx.helper_exprs_in_modules,
                     impls_in_modules: &ctx.impls_in_modules,
-                    module_fs_node_id: module_file_id,
+                    module_fs_node_id: module_folder_id,
                     physical_fs_node_id: *physical_file_id,
                 };
 
@@ -54,7 +54,7 @@ pub fn resolve_helper_expressions(
 
             let helper_exprs = ctx
                 .helper_exprs_in_modules
-                .entry(module_file_id)
+                .entry(module_folder_id)
                 .or_default();
 
             helper_exprs.insert(

Diff for: src/resolve/impl_head/mod.rs

@@ -20,23 +20,23 @@ pub fn create_impl_heads(
     ctx: &mut ResolveCtx,
     asg: &mut Asg,
     options: &BuildOptions,
-    module_file_id: FsNodeId,
+    module_folder_id: FsNodeId,
     physical_file_id: FsNodeId,
     file: &AstFile,
 ) -> Result<(), ResolveError> {
     for (impl_i, ast_impl) in file.impls.iter().enumerate() {
-        let impl_ref = create_impl_head(ctx, asg, module_file_id, physical_file_id, ast_impl)?;
+        let impl_ref = create_impl_head(ctx, asg, module_folder_id, physical_file_id, ast_impl)?;
 
         for (func_i, func) in ast_impl.body.iter().enumerate() {
-            let name = ResolvedName::new(module_file_id, &Name::plain(&func.head.name));
+            let name = ResolvedName::new(module_folder_id, &Name::plain(&func.head.name));
 
             let func_ref = create_func_head(
                 ctx,
                 asg,
                 options,
                 name.clone(),
                 &func.head,
-                module_file_id,
+                module_folder_id,
                 physical_file_id,
             )?;