Started working on namespace support for enums and helper expressions

Author: IsaacShelton

Diff for: src/ast/expr/enum_member.rs

@@ -1,8 +1,8 @@
-use crate::source_files::Source;
+use crate::{name::Name, source_files::Source};
 
 #[derive(Clone, Debug)]
 pub struct EnumMemberLiteral {
-    pub enum_name: String,
+    pub enum_name: Name,
     pub variant_name: String,
     pub source: Source,
 }

Diff for: src/ast/file.rs

@@ -2,16 +2,17 @@ use super::{
     enumeration::Enum, global_variable::GlobalVar, structure::Structure, type_alias::TypeAlias,
     Function, HelperExpr, SettingsId,
 };
+use crate::name::Name;
 use indexmap::IndexMap;
 
 #[derive(Clone, Debug)]
 pub struct AstFile {
     pub functions: Vec<Function>,
     pub structures: Vec<Structure>,
-    pub type_aliases: IndexMap<String, TypeAlias>,
+    pub type_aliases: IndexMap<Name, TypeAlias>,
     pub global_variables: Vec<GlobalVar>,
-    pub enums: IndexMap<String, Enum>,
-    pub helper_exprs: IndexMap<String, HelperExpr>,
+    pub enums: IndexMap<Name, Enum>,
+    pub helper_exprs: IndexMap<Name, HelperExpr>,
     pub settings: Option<SettingsId>,
 }
 

Diff for: src/ast/named.rs

@@ -1,7 +1,8 @@
+use crate::name::Name;
 use std::fmt::Debug;
 
 pub struct Named<T> {
-    pub name: String,
+    pub name: Name,
     pub value: T,
 }
 

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

@@ -10,6 +10,7 @@ use crate::{
     ast::{self, AstFile},
     c::parser::{CTypedef, DeclarationSpecifiers, Declarator, ParseError},
     diagnostics::Diagnostics,
+    name::Name,
 };
 use std::collections::HashMap;
 
@@ -32,7 +33,7 @@ pub fn declare_named_declaration(
 
     if is_typedef {
         ast_file.type_aliases.insert(
-            name.to_string(),
+            Name::plain(name.clone()),
             ast::TypeAlias {
                 value: ast_type.clone(),
                 source: declarator.source,

Diff for: src/c/translation/types/enumeration.rs

@@ -55,22 +55,24 @@ pub fn make_anonymous_enum(
                 if let Some(definition_name) = &definition.name {
                     let aka_value =
                         ast::ExprKind::EnumMemberLiteral(Box::new(ast::EnumMemberLiteral {
-                            enum_name: format!("enum<{}>", definition_name),
+                            enum_name: Name::plain(format!("enum<{}>", definition_name)),
                             variant_name: enumerator.name.clone(),
                             source: enumerator.source,
                         }))
                         .at(enumerator.source);
 
                     ast_file.helper_exprs.try_insert(
-                        enumerator.name.clone(),
+                        Name::plain(enumerator.name.clone()),
                         ast::HelperExpr {
                             value: aka_value,
                             source: enumerator.source,
                             is_file_local_only: false,
                         },
                         |name| {
-                            ParseErrorKind::EnumMemberNameConflictsWithExistingSymbol { name }
-                                .at(enumerator.source)
+                            ParseErrorKind::EnumMemberNameConflictsWithExistingSymbol {
+                                name: name.to_string(),
+                            }
+                            .at(enumerator.source)
                         },
                     )?;
                 }

Diff for: src/interpreter_env/mod.rs

@@ -100,7 +100,7 @@ pub fn setup_build_system_interpreter_symbols(file: &mut AstFile) {
     });
 
     file.enums.insert(
-        "ProjectKind".into(),
+        Name::plain("ProjectKind"),
         Enum {
             backing_type: Some(TypeKind::u64().at(source)),
             source,

Diff for: src/lower/mod.rs

@@ -7,6 +7,7 @@ use crate::{
     ast::{CInteger, IntegerBits, IntegerRigidity},
     cli::BuildOptions,
     ir::{self, BasicBlocks, Global, Literal, OverflowOperator, Value, ValueReference},
+    name::ResolvedName,
     resolved::{
         self, Destination, DestinationKind, Expr, ExprKind, FloatOrInteger, FloatSize, Member,
         NumericMode, SignOrIndeterminate, StmtKind, StructureLiteral, UnaryMathOperation,
@@ -860,15 +861,15 @@ fn lower_expr(
         ExprKind::EnumMemberLiteral(enum_member_literal) => {
             let enum_definition = resolved_ast
                 .enums
-                .get(&enum_member_literal.enum_name)
+                .get(&ResolvedName::new(&enum_member_literal.enum_name))
                 .expect("referenced enum to exist for enum member literal");
 
             let member = enum_definition
                 .members
                 .get(&enum_member_literal.variant_name)
                 .ok_or_else(|| {
                     LowerErrorKind::NoSuchEnumMember {
-                        enum_name: enum_member_literal.enum_name.clone(),
+                        enum_name: enum_member_literal.enum_name.to_string(),
                         variant_name: enum_member_literal.variant_name.clone(),
                     }
                     .at(enum_member_literal.source)
@@ -885,7 +886,7 @@ fn lower_expr(
             let make_error = |_| {
                 LowerErrorKind::CannotFit {
                     value: value.to_string(),
-                    expected_type: enum_member_literal.enum_name.clone(),
+                    expected_type: enum_member_literal.enum_name.to_string(),
                 }
                 .at(enum_definition.source)
             };
@@ -917,7 +918,7 @@ fn lower_expr(
                 }
                 _ => {
                     return Err(LowerErrorKind::EnumBackingTypeMustBeInteger {
-                        enum_name: enum_member_literal.enum_name.clone(),
+                        enum_name: enum_member_literal.enum_name.to_string(),
                     }
                     .at(enum_definition.source))
                 }

Diff for: src/parser/parse_enum.rs

@@ -2,6 +2,7 @@ use super::{annotation::Annotation, error::ParseError, Parser};
 use crate::{
     ast::{Enum, EnumMember, Named},
     inflow::Inflow,
+    name::Name,
     token::{Token, TokenKind},
 };
 use indexmap::IndexMap;
@@ -54,7 +55,7 @@ impl<'a, I: Inflow<Token>> Parser<'a, I> {
         self.parse_token(TokenKind::CloseParen, Some("to close enum body"))?;
 
         Ok(Named::<Enum> {
-            name,
+            name: Name::plain(name),
             value: Enum {
                 backing_type: None,
                 members,

Diff for: src/parser/parse_expr/primary/enum_member_literal.rs

@@ -2,6 +2,7 @@ use super::Parser;
 use crate::{
     ast::{EnumMemberLiteral, Expr, ExprKind},
     inflow::Inflow,
+    name::Name,
     parser::error::{ParseError, ParseErrorKind},
     source_files::Source,
     token::{Token, TokenKind},
@@ -10,7 +11,7 @@ use crate::{
 impl<'a, I: Inflow<Token>> Parser<'a, I> {
     pub fn parse_enum_member_literal(
         &mut self,
-        enum_name: String,
+        enum_name: Name,
         source: Source,
     ) -> Result<Expr, ParseError> {
         // EnumName::EnumVariant

Diff for: src/parser/parse_expr/primary/mod.rs

@@ -89,7 +89,6 @@ impl<'a, I: Inflow<Token>> Parser<'a, I> {
                             return Err(ParseErrorKind::GenericsNotSupportedHere.at(source));
                         }
 
-                        let name = into_plain_name(name, source)?;
                         self.parse_enum_member_literal(name, source)
                     }
                     TokenKind::OpenCurly => {

Diff for: src/parser/parse_helper_expr.rs

@@ -2,6 +2,7 @@ use super::{annotation::Annotation, error::ParseError, Parser};
 use crate::{
     ast::{HelperExpr, Named},
     inflow::Inflow,
+    name::Name,
     token::{Token, TokenKind},
 };
 
@@ -28,12 +29,12 @@ impl<'a, I: Inflow<Token>> Parser<'a, I> {
         let value = self.parse_expr()?;
 
         Ok(Named::<HelperExpr> {
+            name: Name::plain(name),
             value: HelperExpr {
                 value,
                 source,
                 is_file_local_only: false,
             },
-            name,
         })
     }
 }

Diff for: src/parser/parse_top_level.rs

@@ -60,7 +60,10 @@ impl<'a, I: Inflow<Token>> Parser<'a, I> {
                 let source = alias.source;
 
                 ast_file.type_aliases.try_insert(name, alias, |name| {
-                    ParseErrorKind::TypeAliasHasMultipleDefinitions { name }.at(source)
+                    ParseErrorKind::TypeAliasHasMultipleDefinitions {
+                        name: name.to_string(),
+                    }
+                    .at(source)
                 })?;
             }
             TokenKind::EnumKeyword => {
@@ -72,7 +75,10 @@ impl<'a, I: Inflow<Token>> Parser<'a, I> {
                 let source = enum_definition.source;
 
                 ast_file.enums.try_insert(name, enum_definition, |name| {
-                    ParseErrorKind::EnumHasMultipleDefinitions { name }.at(source)
+                    ParseErrorKind::EnumHasMultipleDefinitions {
+                        name: name.to_string(),
+                    }
+                    .at(source)
                 })?;
             }
             TokenKind::DefineKeyword => {
@@ -83,7 +89,10 @@ impl<'a, I: Inflow<Token>> Parser<'a, I> {
                 let source = named_expr.source;
 
                 ast_file.helper_exprs.try_insert(name, named_expr, |name| {
-                    ParseErrorKind::DefineHasMultipleDefinitions { name }.at(source)
+                    ParseErrorKind::DefineHasMultipleDefinitions {
+                        name: name.to_string(),
+                    }
+                    .at(source)
                 })?;
             }
             TokenKind::EndOfFile => {

Diff for: src/parser/parse_type_alias.rs

@@ -2,6 +2,7 @@ use super::{annotation::Annotation, error::ParseError, Parser};
 use crate::{
     ast::{Named, TypeAlias},
     inflow::Inflow,
+    name::Name,
     token::{Token, TokenKind},
 };
 
@@ -28,7 +29,7 @@ impl<'a, I: Inflow<Token>> Parser<'a, I> {
         let becomes_type = self.parse_type(None::<&str>, Some("for type alias"))?;
 
         Ok(Named::<TypeAlias> {
-            name,
+            name: Name::plain(name),
             value: TypeAlias {
                 value: becomes_type,
                 source,

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

@@ -28,6 +28,7 @@ use crate::{
     ast::{
         self, CInteger, CIntegerAssumptions, ConformBehavior, Language, Settings, UnaryOperator,
     },
+    name::ResolvedName,
     resolve::{
         ensure_initialized,
         error::ResolveErrorKind,
@@ -53,7 +54,7 @@ pub struct ResolveExprCtx<'a, 'b> {
     pub global_search_ctx: &'b GlobalSearchCtx,
     pub variable_search_ctx: VariableSearchCtx,
     pub resolved_function_ref: resolved::FunctionRef,
-    pub helper_exprs: &'b IndexMap<String, &'a ast::HelperExpr>,
+    pub helper_exprs: &'b IndexMap<ResolvedName, &'a ast::HelperExpr>,
     pub settings: &'b Settings,
 }
 
@@ -315,7 +316,8 @@ pub fn resolve_expr(
         )),
         ast::ExprKind::EnumMemberLiteral(enum_member_literal) => {
             let resolved_type =
-                resolved::TypeKind::Enum(enum_member_literal.enum_name.clone()).at(ast_expr.source);
+                resolved::TypeKind::Enum(ResolvedName::new(&enum_member_literal.enum_name))
+                    .at(ast_expr.source);
 
             Ok(TypedExpr::new(
                 resolved_type,

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

@@ -1,5 +1,6 @@
 use super::{PreferredType, ResolveExprCtx};
 use crate::{
+    name::{Name, ResolvedName},
     resolve::{
         error::{ResolveError, ResolveErrorKind},
         expr::resolve_expr,
@@ -51,7 +52,12 @@ pub fn resolve_variable_expr(
                 source,
             ),
         ))
-    } else if let Some(define) = ctx.helper_exprs.get(name) {
+    } else if let Some(define) = ctx
+        .helper_exprs
+        // TODO: CLEANUP: PERFORMANCE: Once we have proper support for
+        // namespaced helper expressions, this should be cleaned up
+        .get(&ResolvedName::new(&Name::new(None::<&str>, name)))
+    {
         let TypedExpr {
             resolved_type,
             expr,

Diff for: src/resolve/function_search_ctx.rs

@@ -25,13 +25,7 @@ impl FunctionSearchCtx {
     }
 
     pub fn find_function(&self, name: &Name) -> Result<resolved::FunctionRef, FindFunctionError> {
-        eprintln!("warning: function call name resolution not fully implemented yet");
-
-        let resolved_name = if !name.namespace.is_empty() {
-            ResolvedName::Project(format!("{}{}", name.namespace, name.basename).into_boxed_str())
-        } else {
-            ResolvedName::Project(name.basename.clone().into_boxed_str())
-        };
+        let resolved_name = ResolvedName::new(name);
 
         if let Some(found) = self
             .available
@@ -45,9 +39,10 @@ impl FunctionSearchCtx {
         if name.namespace.is_empty() {
             let mut matches = self.imported_namespaces.iter().filter_map(|namespace| {
                 self.available
-                    .get(&ResolvedName::Project(
-                        format!("{}/{}", namespace, name.basename).into_boxed_str(),
-                    ))
+                    .get(&ResolvedName::new(&Name::new(
+                        Some(namespace.to_string()),
+                        name.basename.clone(),
+                    )))
                     .and_then(|list| list.first())
                     .copied()
             });