Added namespace support for global variables and helper exprs

Author: IsaacShelton

Diff for: src/lower/mod.rs

@@ -923,7 +923,7 @@ fn lower_expr(
                 }
             })
         }
-        ExprKind::ResolvedNamedExpression(_name, resolved_expr) => {
+        ExprKind::ResolvedNamedExpression(resolved_expr) => {
             lower_expr(builder, ir_module, resolved_expr, function, resolved_ast)
         }
         ExprKind::Zeroed(resolved_type) => {

Diff for: src/resolve/error.rs

@@ -160,6 +160,9 @@ pub enum ResolveErrorKind {
         ty: String,
         member: String,
     },
+    AmbiguousSymbol {
+        name: String,
+    },
     Other {
         message: String,
     },
@@ -412,6 +415,9 @@ impl Display for ResolveErrorKind {
             ResolveErrorKind::StaticMemberOfTypeDoesNotExist { ty, member } => {
                 write!(f, "Static member '{member}' does not exist on type '{ty}'")?;
             }
+            ResolveErrorKind::AmbiguousSymbol { name } => {
+                write!(f, "Ambiguous symbol '{name}'")?;
+            }
             ResolveErrorKind::Other { message } => {
                 write!(f, "{}", message)?;
             }

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

@@ -1,12 +1,14 @@
 use super::{PreferredType, ResolveExprCtx};
 use crate::{
+    ast::HelperExpr,
+    ir::GlobalVarRef,
     name::{Name, ResolvedName},
     resolve::{
         error::{ResolveError, ResolveErrorKind},
         expr::resolve_expr,
         Initialized,
     },
-    resolved::{self, TypedExpr},
+    resolved::{self, Type, TypedExpr},
     source_files::Source,
 };
 
@@ -49,41 +51,105 @@ pub fn resolve_variable_expr(
     let resolved_name = ResolvedName::new(name);
 
     if let Some((resolved_type, reference)) = ctx.global_search_ctx.find_global(&resolved_name) {
-        return Ok(TypedExpr::new(
-            resolved_type.clone(),
-            resolved::Expr::new(
-                resolved::ExprKind::GlobalVariable(Box::new(resolved::GlobalVariable {
-                    reference: *reference,
-                    resolved_type: resolved_type.clone(),
-                })),
-                source,
-            ),
-        ));
+        return Ok(resolve_global_variable(resolved_type, *reference, source));
     }
 
-    if let Some(define) = ctx.helper_exprs.get(&resolved_name) {
-        let TypedExpr {
-            resolved_type,
-            expr,
-            is_initialized,
-        } = resolve_expr(ctx, &define.value, preferred_type, initialized)?;
-
-        return Ok(TypedExpr::new_maybe_initialized(
-            resolved_type,
-            resolved::Expr::new(
-                resolved::ExprKind::ResolvedNamedExpression(name.to_string(), Box::new(expr)),
-                source,
-            ),
-            is_initialized,
-        ));
+    if let Some(helper_expr) = ctx.helper_exprs.get(&resolved_name) {
+        return resolve_helper_expr(ctx, helper_expr, preferred_type, initialized, source);
     }
 
-    // TODO: Check if any global variables from imported namespaces match
-    // TODO: Check if any helper exprs from imported namespaces match
-    // TODO: They should probably be checked at the same time
+    if name.namespace.is_empty() {
+        let mut matches = ctx
+            .settings
+            .imported_namespaces
+            .iter()
+            .flat_map(|namespace| {
+                let resolved_name = ResolvedName::new(&Name::new(
+                    Some(namespace.to_string()),
+                    name.basename.to_string(),
+                ));
+
+                let global = ctx
+                    .global_search_ctx
+                    .find_global(&resolved_name)
+                    .map(GlobalOrHelper::Global);
+
+                let helper_expr = ctx
+                    .helper_exprs
+                    .get(&resolved_name)
+                    .copied()
+                    .map(GlobalOrHelper::HelperExpr);
+
+                [global, helper_expr]
+            })
+            .flatten();
+
+        if let Some(found) = matches.next() {
+            if matches.next().is_some() {
+                return Err(ResolveErrorKind::AmbiguousSymbol {
+                    name: name.to_string(),
+                }
+                .at(source));
+            }
+
+            return match found {
+                GlobalOrHelper::Global((ty, reference)) => {
+                    Ok(resolve_global_variable(ty, *reference, source))
+                }
+                GlobalOrHelper::HelperExpr(helper_expr) => {
+                    resolve_helper_expr(ctx, helper_expr, preferred_type, initialized, source)
+                }
+            };
+        }
+    }
 
     Err(ResolveErrorKind::UndeclaredVariable {
         name: name.to_string(),
     }
     .at(source))
 }
+
+enum GlobalOrHelper<'a> {
+    Global((&'a Type, &'a GlobalVarRef)),
+    HelperExpr(&'a HelperExpr),
+}
+
+fn resolve_global_variable(
+    resolved_type: &Type,
+    reference: GlobalVarRef,
+    source: Source,
+) -> TypedExpr {
+    TypedExpr::new(
+        resolved_type.clone(),
+        resolved::Expr::new(
+            resolved::ExprKind::GlobalVariable(Box::new(resolved::GlobalVariable {
+                reference,
+                resolved_type: resolved_type.clone(),
+            })),
+            source,
+        ),
+    )
+}
+
+fn resolve_helper_expr(
+    ctx: &mut ResolveExprCtx,
+    helper_expr: &HelperExpr,
+    preferred_type: Option<PreferredType>,
+    initialized: Initialized,
+    source: Source,
+) -> Result<TypedExpr, ResolveError> {
+    let TypedExpr {
+        resolved_type,
+        expr,
+        is_initialized,
+    } = resolve_expr(ctx, &helper_expr.value, preferred_type, initialized)?;
+
+    return Ok(TypedExpr::new_maybe_initialized(
+        resolved_type,
+        resolved::Expr::new(
+            resolved::ExprKind::ResolvedNamedExpression(Box::new(expr)),
+            source,
+        ),
+        is_initialized,
+    ));
+}

Diff for: src/resolved/mod.rs

@@ -435,7 +435,7 @@ pub enum ExprKind {
     While(Box<While>),
     ArrayAccess(Box<ArrayAccess>),
     EnumMemberLiteral(Box<EnumMemberLiteral>),
-    ResolvedNamedExpression(String, Box<Expr>),
+    ResolvedNamedExpression(Box<Expr>),
     Zeroed(Box<Type>),
     InterpreterSyscall(InterpreterSyscallKind, Vec<Expr>),
 }