Started improving type alias support and error messages

Author: IsaacShelton

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

@@ -1,31 +1,38 @@
 use crate::{
-    asg::{EnumRef, HumanName},
+    asg::{EnumRef, HumanName, Type},
     source_files::Source,
 };
 use core::hash::Hash;
+use num::BigInt;
 
 #[derive(Clone, Debug)]
 pub struct EnumMemberLiteral {
     pub human_name: HumanName,
-    pub enum_ref: EnumRef,
+    pub enum_target: EnumTarget,
     pub variant_name: String,
     pub source: Source,
 }
 
 impl Hash for EnumMemberLiteral {
     fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
         self.human_name.hash(state);
-        self.enum_ref.hash(state);
+        self.enum_target.hash(state);
         self.variant_name.hash(state);
     }
 }
 
 impl PartialEq for EnumMemberLiteral {
     fn eq(&self, other: &Self) -> bool {
         self.human_name.eq(&other.human_name)
-            && self.enum_ref.eq(&other.enum_ref)
+            && self.enum_target.eq(&other.enum_target)
             && self.variant_name.eq(&other.variant_name)
     }
 }
 
 impl Eq for EnumMemberLiteral {}
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub enum EnumTarget {
+    Named(EnumRef),
+    Anonymous(BigInt, Type),
+}

Diff for: src/asg/mod.rs

@@ -34,7 +34,7 @@ pub use impl_params::*;
 pub use implementation::*;
 pub use overload::*;
 use slotmap::{new_key_type, SlotMap};
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 pub use stmt::*;
 pub use structure::*;
 pub use trait_constraint::*;
@@ -83,27 +83,54 @@ impl<'a> Asg<'a> {
         }
     }
 
-    pub fn unalias(&'a self, mut ty: &'a Type) -> Result<&'a Type, UnaliasError> {
+    pub fn unalias(&'a self, whole_type: &'a Type) -> Result<&'a Type, UnaliasError> {
+        let mut running = whole_type;
         let mut depth = 0;
 
-        while let TypeKind::TypeAlias(_, type_alias_ref) = ty.kind {
-            ty = self
+        while let TypeKind::TypeAlias(_, type_alias_ref) = running.kind {
+            running = self
                 .type_aliases
                 .get(type_alias_ref)
                 .expect("valid type alias ref");
 
             depth += 1;
 
             if depth > Self::MAX_UNALIAS_DEPTH {
-                return Err(UnaliasError::MaxDepthExceeded);
+                return Err(self.find_type_alias_self_reference(whole_type));
             }
         }
 
-        Ok(ty)
+        Ok(running)
+    }
+
+    fn find_type_alias_self_reference(&self, whole_type: &Type) -> UnaliasError {
+        let mut seen = HashSet::new();
+        let mut running = whole_type;
+        let mut depth = 0;
+
+        while let TypeKind::TypeAlias(human_name, type_alias_ref) = &running.kind {
+            running = self
+                .type_aliases
+                .get(*type_alias_ref)
+                .expect("valid type alias ref");
+
+            if !seen.insert(type_alias_ref) {
+                return UnaliasError::SelfReferentialTypeAlias(human_name.0.clone());
+            }
+
+            depth += 1;
+
+            if depth > Self::MAX_UNALIAS_DEPTH {
+                break;
+            }
+        }
+
+        return UnaliasError::MaxDepthExceeded;
     }
 }
 
 #[derive(Clone, Debug)]
 pub enum UnaliasError {
     MaxDepthExceeded,
+    SelfReferentialTypeAlias(String),
 }

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

@@ -419,32 +419,41 @@ pub fn lower_expr(
             Ok(Value::Literal(Literal::Void))
         }
         ExprKind::EnumMemberLiteral(enum_member_literal) => {
-            let enum_definition = asg
-                .enums
-                .get(enum_member_literal.enum_ref)
-                .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.human_name.to_string(),
-                        variant_name: enum_member_literal.variant_name.clone(),
-                    }
-                    .at(enum_member_literal.source)
-                })?;
-
-            let ir_type = lower_type(ir_module, &builder.unpoly(&enum_definition.ty)?, asg)?;
-
-            let value = &member.value;
+            let (value, ir_type, source) = match &enum_member_literal.enum_target {
+                asg::EnumTarget::Named(enum_ref) => {
+                    let enum_definition = asg
+                        .enums
+                        .get(*enum_ref)
+                        .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.human_name.to_string(),
+                                variant_name: enum_member_literal.variant_name.clone(),
+                            }
+                            .at(enum_member_literal.source)
+                        })?;
+
+                    let ir_type =
+                        lower_type(ir_module, &builder.unpoly(&enum_definition.ty)?, asg)?;
+
+                    (&member.value, ir_type, enum_definition.source)
+                }
+                asg::EnumTarget::Anonymous(value, ty) => {
+                    let ir_type = lower_type(ir_module, &builder.unpoly(&ty)?, asg)?;
+                    (value, ir_type, enum_member_literal.source)
+                }
+            };
 
             let make_error = |_| {
                 LowerErrorKind::CannotFit {
                     value: value.to_string(),
                     expected_type: enum_member_literal.human_name.to_string(),
                 }
-                .at(enum_definition.source)
+                .at(source)
             };
 
             Ok(match ir_type {
@@ -476,7 +485,7 @@ pub fn lower_expr(
                     return Err(LowerErrorKind::EnumBackingTypeMustBeInteger {
                         enum_name: enum_member_literal.human_name.to_string(),
                     }
-                    .at(enum_definition.source))
+                    .at(source))
                 }
             })
         }

Diff for: src/resolve/error.rs

@@ -523,28 +523,19 @@ impl Display for ResolveErrorKind {
                 )?;
             }
             ResolveErrorKind::UnaliasError(details) => match details {
-                UnaliasError::MaxDepthExceeded => write!(
-                    f,
-                    "Maximum type alias depth exceeded, please ensure your type alias is not recursive"
-                )?,
+                UnaliasError::MaxDepthExceeded => write!(f, "Maximum type alias depth exceeded")?,
+                UnaliasError::SelfReferentialTypeAlias(type_alias_name) => {
+                    write!(f, "Type alias '{}' is self-referential", type_alias_name)?
+                }
             },
             ResolveErrorKind::CannotDeclareVariableOutsideFunction => {
-                write!(
-                    f,
-                    "Cannot declare variable outside of function"
-                )?;
-            },
+                write!(f, "Cannot declare variable outside of function")?;
+            }
             ResolveErrorKind::CannotReturnOutsideFunction => {
-                write!(
-                    f,
-                    "Cannot return outside of function"
-                )?;
+                write!(f, "Cannot return outside of function")?;
             }
             ResolveErrorKind::CannotAssignVariableOutsideFunction => {
-                write!(
-                    f,
-                    "Cannot assign variable outside of function"
-                )?;
+                write!(f, "Cannot assign variable outside of function")?;
             }
             ResolveErrorKind::PolymorphError(e) => {
                 e.fmt(f)?;
@@ -553,14 +544,16 @@ impl Display for ResolveErrorKind {
                 write!(f, "Undeclared trait '{}'", trait_name)?;
             }
             ResolveErrorKind::CannotUseOperator { operator, on_type } => {
-                write!(f, "Cannot use operator '{}' on type '{}'", operator, on_type)?;
+                write!(
+                    f,
+                    "Cannot use operator '{}' on type '{}'",
+                    operator, on_type
+                )?;
             }
             ResolveErrorKind::ConstraintsNotSatisfiedForType { name } => {
                 write!(f, "Constraints not satisfied for type '{}'", name)?;
             }
-            ResolveErrorKind::TypeIsNotATrait {
-                name
-            } => {
+            ResolveErrorKind::TypeIsNotATrait { name } => {
                 write!(f, "Type '{}' is not a trait", name)?;
             }
             ResolveErrorKind::DuplicateTypeName { name } => {

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

@@ -9,7 +9,9 @@ use crate::{
     resolve::{
         conform::{conform_expr, to_default::conform_expr_to_default, ConformMode, Perform},
         error::{ResolveError, ResolveErrorKind},
-        resolve_type_args_to_poly_args, Initialized, PolyCatalog,
+        resolve_type_args_to_poly_args,
+        type_ctx::ResolveTypeOptions,
+        Initialized, PolyCatalog,
     },
     source_files::Source,
 };
@@ -132,7 +134,9 @@ pub fn call_callee(
         .map_err(ResolveError::from)?;
 
     if let Some(required_ty) = &call.expected_to_return {
-        let resolved_required_ty = ctx.type_ctx().resolve(required_ty)?;
+        let resolved_required_ty = ctx
+            .type_ctx()
+            .resolve(required_ty, ResolveTypeOptions::Unalias)?;
 
         if resolved_required_ty != return_type {
             return Err(ResolveErrorKind::FunctionMustReturnType {

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

@@ -20,6 +20,7 @@ use super::{
     destination::resolve_expr_to_destination,
     error::ResolveError,
     func_haystack::FuncHaystack,
+    type_ctx::ResolveTypeOptions,
     variable_haystack::VariableHaystack,
     Initialized, ResolveTypeCtx,
 };
@@ -376,7 +377,9 @@ pub fn resolve_expr(
             resolve_static_member_call(ctx, static_access_call)
         }
         ast::ExprKind::SizeOf(ast_type) => {
-            let ty = ctx.type_ctx().resolve(ast_type)?;
+            let ty = ctx
+                .type_ctx()
+                .resolve(ast_type, ResolveTypeOptions::Unalias)?;
 
             Ok(TypedExpr::new(
                 asg::TypeKind::Integer(IntegerBits::Bits64, IntegerSign::Unsigned).at(source),
@@ -405,11 +408,15 @@ pub fn resolve_expr(
                 result_type,
             } = &**info;
 
-            let ty = ctx.type_ctx().resolve(result_type)?;
+            let ty = ctx
+                .type_ctx()
+                .resolve(result_type, ResolveTypeOptions::Unalias)?;
             let mut resolved_args = Vec::with_capacity(args.len());
 
             for (expected_arg_type, arg) in args {
-                let preferred_type = ctx.type_ctx().resolve(expected_arg_type)?;
+                let preferred_type = ctx
+                    .type_ctx()
+                    .resolve(expected_arg_type, ResolveTypeOptions::Unalias)?;
 
                 resolved_args.push(
                     resolve_expr(

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

@@ -1,6 +1,6 @@
 use super::{call::call_callee, resolve_expr, ResolveExprCtx, ResolveExprMode};
 use crate::{
-    asg::{self, ImplRef, PolyCall, PolyCallee, TypeKind, TypedExpr},
+    asg::{self, HumanName, ImplRef, PolyCall, PolyCallee, TypeKind, TypedExpr},
     ast::{self, StaticMemberCall, StaticMemberValue, TypeArg},
     name::Name,
     resolve::{
@@ -11,7 +11,9 @@ use crate::{
         expr::PreferredType,
         func_haystack::{FindFunctionError, FuncHaystack},
         initialized::Initialized,
-        resolve_type_args_to_poly_args, PolyCatalog, PolyRecipe,
+        resolve_type_args_to_poly_args,
+        type_ctx::ResolveTypeOptions,
+        PolyCatalog, PolyRecipe,
     },
     source_files::Source,
 };
@@ -29,9 +31,24 @@ pub fn resolve_static_member_value(
         source,
     } = static_member_value;
 
-    let ty = ctx.type_ctx().resolve(&subject)?;
+    let ty = ctx
+        .type_ctx()
+        .resolve(&subject, ResolveTypeOptions::Unalias)?;
 
-    let TypeKind::Enum(human_name, enum_ref) = &ty.kind else {
+    let extracted = match &ty.kind {
+        TypeKind::AnonymousEnum(enumeration) => enumeration.members.get(value).map(|member| {
+            (
+                HumanName("(anonymous enum)".into()),
+                asg::EnumTarget::Anonymous(member.value.clone(), ty.clone()),
+            )
+        }),
+        TypeKind::Enum(human_name, enum_ref) => {
+            Some((human_name.clone(), asg::EnumTarget::Named(*enum_ref)))
+        }
+        _ => None,
+    };
+
+    let Some((human_name, enum_target)) = extracted else {
         return Err(ResolveErrorKind::StaticMemberOfTypeDoesNotExist {
             ty: subject.to_string(),
             member: value.to_string(),
@@ -40,11 +57,11 @@ pub fn resolve_static_member_value(
     };
 
     Ok(TypedExpr::new(
-        ty.clone(),
+        ty,
         asg::Expr::new(
             asg::ExprKind::EnumMemberLiteral(Box::new(asg::EnumMemberLiteral {
-                human_name: human_name.clone(),
-                enum_ref: *enum_ref,
+                human_name,
+                enum_target,
                 variant_name: value.to_string(),
                 source: *value_source,
             })),
@@ -153,7 +170,10 @@ pub fn resolve_impl_mention(
         match arg {
             ast::TypeArg::Type(ty) => {
                 catalog
-                    .put_type(name, &ctx.type_ctx().resolve(ty)?)
+                    .put_type(
+                        name,
+                        &ctx.type_ctx().resolve(ty, ResolveTypeOptions::Unalias)?,
+                    )
                     .expect("unique impl parameter names");
             }
             ast::TypeArg::Expr(expr) => {

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

@@ -6,6 +6,7 @@ use crate::{
         conform::{conform_expr, ConformMode, Perform},
         core_struct_info::{get_core_struct_info, CoreStructInfo},
         error::{ResolveError, ResolveErrorKind},
+        type_ctx::ResolveTypeOptions,
         Initialized, PolyCatalog, PolymorphError,
     },
     source_files::Source,
@@ -58,7 +59,9 @@ pub fn resolve_struct_literal_expr(
     conform_behavior: ConformBehavior,
     source: Source,
 ) -> Result<TypedExpr, ResolveError> {
-    let struct_type = ctx.type_ctx().resolve(ast_type)?;
+    let struct_type = ctx
+        .type_ctx()
+        .resolve(ast_type, ResolveTypeOptions::Unalias)?;
 
     let CoreStructInfo {
         name: struct_name,