Added support for file-local global variables, and started working on support for C global variables

Author: IsaacShelton

Diff for: src/asg/global.rs

@@ -1,5 +1,9 @@
 use super::{GlobalVarRef, Type};
-use crate::{ast::Privacy, name::ResolvedName, source_files::Source};
+use crate::{
+    ast::{Exposure, Privacy},
+    name::ResolvedName,
+    source_files::Source,
+};
 
 #[derive(Clone, Debug)]
 pub struct GlobalVar {
@@ -8,6 +12,7 @@ pub struct GlobalVar {
     pub source: Source,
     pub is_foreign: bool,
     pub is_thread_local: bool,
+    pub exposure: Exposure,
 }
 
 #[derive(Clone, Debug)]

Diff for: src/ast/exposure.rs

@@ -0,0 +1,8 @@
+use derive_more::IsVariant;
+
+#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, IsVariant)]
+pub enum Exposure {
+    #[default]
+    Hidden,
+    Exposed,
+}

Diff for: src/ast/global_variable.rs

@@ -1,4 +1,4 @@
-use super::{Privacy, Type};
+use super::{Exposure, Privacy, Type};
 use crate::source_files::Source;
 
 #[derive(Clone, Debug)]
@@ -9,4 +9,5 @@ pub struct GlobalVar {
     pub is_foreign: bool,
     pub is_thread_local: bool,
     pub privacy: Privacy,
+    pub exposure: Exposure,
 }

Diff for: src/ast/mod.rs

@@ -2,6 +2,7 @@ mod block;
 mod conforming;
 mod datatype;
 mod enumeration;
+mod exposure;
 mod expr;
 mod file;
 mod func;
@@ -21,6 +22,7 @@ pub use block::*;
 pub use conforming::*;
 pub use datatype::*;
 pub use enumeration::*;
+pub use exposure::*;
 pub use expr::*;
 pub use file::*;
 pub use func::*;

Diff for: src/c/translation/mod.rs

@@ -72,6 +72,7 @@ pub fn declare_named_declaration(
             is_foreign: true,
             is_thread_local,
             privacy: Privacy::Public,
+            exposure: ast::Exposure::Exposed,
         });
         return Ok(());
     }

Diff for: src/ir/global.rs

@@ -1,9 +1,11 @@
 use super::Type;
+use crate::ast::Exposure;
 
 #[derive(Clone, Debug)]
 pub struct Global {
     pub mangled_name: String,
     pub ir_type: Type,
     pub is_foreign: bool,
     pub is_thread_local: bool,
+    pub exposure: Exposure,
 }

Diff for: src/llvm_backend/globals.rs

@@ -15,7 +15,7 @@ pub unsafe fn create_globals(ctx: &mut BackendCtx) -> Result<(), BackendError> {
         let name = CString::new(global.mangled_name.as_bytes()).unwrap();
         let backend_global = LLVMAddGlobal(ctx.backend_module.get(), backend_type, name.as_ptr());
 
-        let linkage = if global.is_foreign {
+        let linkage = if global.exposure.is_exposed() {
             LLVMLinkage::LLVMExternalLinkage
         } else {
             LLVMLinkage::LLVMInternalLinkage

Diff for: src/lower/global.rs

@@ -11,7 +11,7 @@ pub fn lower_global(
     global: &asg::GlobalVar,
     asg: &Asg,
 ) -> Result<(), LowerError> {
-    let mangled_name = if global.is_foreign {
+    let mangled_name = if global.is_foreign || global.exposure.is_exposed() {
         global.name.plain().to_string()
     } else {
         global.name.display(&asg.workspace.fs).to_string()
@@ -21,13 +21,10 @@ pub fn lower_global(
         global_ref,
         Global {
             mangled_name,
-            ir_type: lower_type(
-                ir_module,
-                &unpoly(&PolyRecipe::default(), &global.ty)?,
-                asg,
-            )?,
+            ir_type: lower_type(ir_module, &unpoly(&PolyRecipe::default(), &global.ty)?, asg)?,
             is_foreign: global.is_foreign,
             is_thread_local: global.is_thread_local,
+            exposure: global.exposure,
         },
     );
 

Diff for: src/parser/parse_global_variable.rs

@@ -4,7 +4,7 @@ use super::{
     Parser,
 };
 use crate::{
-    ast::{GlobalVar, Privacy},
+    ast::{Exposure, GlobalVar, Privacy},
     inflow::Inflow,
     token::{Token, TokenKind},
 };
@@ -20,13 +20,15 @@ impl<'a, I: Inflow<Token>> Parser<'a, I> {
         let mut is_foreign = false;
         let mut is_thread_local = false;
         let mut privacy = Privacy::Protected;
+        let mut exposure = Exposure::Hidden;
 
         for annotation in annotations {
             match annotation.kind {
                 AnnotationKind::Foreign => is_foreign = true,
                 AnnotationKind::ThreadLocal => is_thread_local = true,
                 AnnotationKind::Public => privacy = Privacy::Public,
                 AnnotationKind::Private => privacy = Privacy::Private,
+                AnnotationKind::Exposed => exposure = Exposure::Exposed,
                 _ => {
                     return Err(self.unexpected_annotation(&annotation, Some("for global variable")))
                 }
@@ -51,6 +53,7 @@ impl<'a, I: Inflow<Token>> Parser<'a, I> {
             is_foreign,
             is_thread_local,
             privacy,
+            exposure,
         })
     }
 }

Diff for: src/resolve/expr/variable.rs

@@ -50,7 +50,8 @@ pub fn resolve_variable_expr(
     if let Some(basename) = name.as_plain_str() {
         let maybe_global = ctx
             .globals_in_modules
-            .get(&ctx.module_fs_node_id)
+            .get(&ctx.physical_fs_node_id)
+            .or_else(|| ctx.globals_in_modules.get(&ctx.module_fs_node_id))
             .and_then(|globals| globals.get(basename));
 
         let maybe_helper_expr = ctx

Diff for: src/resolve/global_variable.rs

@@ -34,10 +34,17 @@ pub fn resolve_global_variables(
                 source: global.source,
                 is_foreign: global.is_foreign,
                 is_thread_local: global.is_thread_local,
+                exposure: global.exposure,
             });
 
+            let fs_node_id = if global.privacy.is_private() {
+                *physical_file_id
+            } else {
+                module_folder_id
+            };
+
             ctx.globals_in_modules
-                .entry(module_folder_id)
+                .entry(fs_node_id)
                 .or_default()
                 .insert(
                     global.name.clone(),