Started working on support for anonymous enums

IsaacShelton · IsaacShelton · commit 5459b976c685 · 2025-02-02T23:12:40.000-06:00
diff --git a/src/asg/datatype/kind/anonymous_enum.rs b/src/asg/datatype/kind/anonymous_enum.rs
@@ -1,15 +1,27 @@
-use crate::{ast::EnumMember, asg::Type, source_files::Source};
+use crate::{asg::Type, ast::EnumMember, source_files::Source};
+use core::hash::Hash;
 use indexmap::IndexMap;
 
 #[derive(Clone, Debug)]
 pub struct AnonymousEnum {
-    pub ty: Box<Type>,
-    pub source: Source,
+    pub backing_type: Type,
     pub members: IndexMap<String, EnumMember>,
+    pub source: Source,
 }
 
 impl PartialEq for AnonymousEnum {
     fn eq(&self, other: &Self) -> bool {
-        self.ty.eq(&other.ty) && self.members.eq(&other.members)
+        self.backing_type.eq(&other.backing_type) && self.members.eq(&other.members)
+    }
+}
+
+impl Hash for AnonymousEnum {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.backing_type.hash(state);
+
+        for (key, value) in self.members.iter() {
+            key.hash(state);
+            value.hash(state);
+        }
     }
 }
diff --git a/src/asg/datatype/kind/mod.rs b/src/asg/datatype/kind/mod.rs
@@ -10,6 +10,7 @@ use crate::{
     source_files::Source,
     target::Target,
 };
+pub use anonymous_enum::AnonymousEnum;
 pub use constraint::Constraint;
 use core::hash::Hash;
 use derive_more::{IsVariant, Unwrap};
@@ -33,7 +34,7 @@ pub enum TypeKind {
     Never,
     AnonymousStruct(),
     AnonymousUnion(),
-    AnonymousEnum(),
+    AnonymousEnum(Box<AnonymousEnum>),
     FixedArray(Box<FixedArray>),
     FuncPtr(FuncPtr),
     Enum(HumanName, EnumRef),
@@ -63,7 +64,7 @@ impl TypeKind {
             TypeKind::Void | TypeKind::Never => false,
             TypeKind::AnonymousStruct() => false,
             TypeKind::AnonymousUnion() => false,
-            TypeKind::AnonymousEnum() => false,
+            TypeKind::AnonymousEnum(_) => false,
             TypeKind::FixedArray(fixed_array) => fixed_array.inner.kind.contains_polymorph(),
             TypeKind::FuncPtr(_) => todo!(),
             TypeKind::Enum(_, _) => false,
@@ -89,6 +90,7 @@ impl TypeKind {
             }
             TypeKind::TypeAlias(_, _type_ref) => todo!(),
             TypeKind::Unresolved => panic!(),
+            TypeKind::AnonymousEnum(enumeration) => enumeration.backing_type.kind.sign(target),
             TypeKind::Floating(_)
             | TypeKind::FloatLiteral(_)
             | TypeKind::Ptr(_)
@@ -100,7 +102,6 @@ impl TypeKind {
             | TypeKind::FixedArray(..)
             | TypeKind::FuncPtr(..)
             | TypeKind::Enum(_, _)
-            | TypeKind::AnonymousEnum()
             | TypeKind::Polymorph(_, _)
             | TypeKind::Trait(_, _, _) => None,
         }
@@ -141,7 +142,7 @@ impl TypeKind {
             | TypeKind::Never
             | TypeKind::AnonymousStruct()
             | TypeKind::AnonymousUnion()
-            | TypeKind::AnonymousEnum() => Ok(Cow::Borrowed(self)),
+            | TypeKind::AnonymousEnum(_) => Ok(Cow::Borrowed(self)),
             TypeKind::FixedArray(fixed_array) => {
                 let TypeParam::Size(size) = mapper(TypeParam::Size(fixed_array.size))
                     .map_err(TypeParamError::MappingError)?
diff --git a/src/asg/datatype/mod.rs b/src/asg/datatype/mod.rs
@@ -41,11 +41,11 @@ impl Type {
             TypeKind::Ptr(inner) => inner.strip_constraints(),
             TypeKind::Void => (),
             TypeKind::Never => (),
-            TypeKind::AnonymousStruct() => todo!(),
-            TypeKind::AnonymousUnion() => todo!(),
-            TypeKind::AnonymousEnum() => todo!(),
+            TypeKind::AnonymousStruct() => todo!("strip_constraints for anonymous struct"),
+            TypeKind::AnonymousUnion() => todo!("strip_constraints for anonymous union"),
+            TypeKind::AnonymousEnum(_) => (),
             TypeKind::FixedArray(fixed_array) => fixed_array.inner.strip_constraints(),
-            TypeKind::FuncPtr(_) => todo!(),
+            TypeKind::FuncPtr(_) => todo!("strip_constraints for function pointer"),
             TypeKind::Enum(_, _) => (),
             TypeKind::Structure(_, _, parameters) => {
                 for parameter in parameters {
diff --git a/src/ast/enumeration.rs b/src/ast/enumeration.rs
@@ -12,7 +12,7 @@ pub struct Enum {
     pub privacy: Privacy,
 }
 
-#[derive(Clone, Debug, PartialEq)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct EnumMember {
     pub value: BigInt,
     pub explicit_value: bool,
diff --git a/src/lower/datatype.rs b/src/lower/datatype.rs
@@ -94,7 +94,7 @@ pub fn lower_type(
         asg::TypeKind::AnonymousUnion() => {
             todo!("lower anonymous union")
         }
-        asg::TypeKind::AnonymousEnum() => {
+        asg::TypeKind::AnonymousEnum(_) => {
             todo!("lower anonymous enum")
         }
         asg::TypeKind::FixedArray(fixed_array) => {
diff --git a/src/resolve/collect_constraints.rs b/src/resolve/collect_constraints.rs
@@ -29,7 +29,7 @@ pub fn collect_constraints_into(map: &mut HashMap<String, HashSet<Constraint>>,
         asg::TypeKind::Never => (),
         asg::TypeKind::AnonymousStruct() => todo!(),
         asg::TypeKind::AnonymousUnion() => todo!(),
-        asg::TypeKind::AnonymousEnum() => todo!(),
+        asg::TypeKind::AnonymousEnum(_) => (),
         asg::TypeKind::FixedArray(fixed_array) => collect_constraints_into(map, &fixed_array.inner),
         asg::TypeKind::FuncPtr(_) => todo!(),
         asg::TypeKind::Enum(_, _) => (),
diff --git a/src/resolve/impl_head/mod.rs b/src/resolve/impl_head/mod.rs
@@ -201,7 +201,7 @@ fn matches(
         },
         asg::TypeKind::AnonymousStruct()
         | asg::TypeKind::AnonymousUnion()
-        | asg::TypeKind::AnonymousEnum() => (ty_in_impl == ty_in_trait)
+        | asg::TypeKind::AnonymousEnum(_) => (ty_in_impl == ty_in_trait)
             .then_some(Ok(()))
             .unwrap_or_else(|| Err(mismatch(ty_in_impl.source))),
         asg::TypeKind::FixedArray(trait_fixed_array) => match &ty_in_impl.kind {
diff --git a/src/resolve/polymorph/matcher.rs b/src/resolve/polymorph/matcher.rs
@@ -124,7 +124,34 @@ impl<'local, 'ast, 'root_ctx> TypeMatcher<'local, 'ast, 'root_ctx> {
             },
             TypeKind::AnonymousStruct() => todo!(),
             TypeKind::AnonymousUnion() => todo!(),
-            TypeKind::AnonymousEnum() => todo!(),
+            TypeKind::AnonymousEnum(pattern_inner) => match &concrete.kind {
+                TypeKind::AnonymousEnum(concrete_inner) => {
+                    // NOTE: Can never be polymorphic, so ok
+                    if pattern_inner.backing_type != concrete_inner.backing_type
+                        || pattern_inner.members.len() != concrete_inner.members.len()
+                    {
+                        return no_match();
+                    }
+
+                    for ((pattern_name, pattern_value), (concrete_name, concrete_value)) in
+                        pattern_inner
+                            .members
+                            .iter()
+                            .zip(concrete_inner.members.iter())
+                    {
+                        // NOTE: We are only checking the actual values match,
+                        // should we care if the explicitness between them is different too?
+                        if pattern_name != concrete_name
+                            || pattern_value.value == concrete_value.value
+                        {
+                            return no_match();
+                        }
+                    }
+
+                    Ok(())
+                }
+                _ => no_match(),
+            },
             TypeKind::FixedArray(pattern_inner) => match &concrete.kind {
                 TypeKind::FixedArray(concrete_inner) => {
                     self.match_type(&pattern_inner.inner, &concrete_inner.inner)
diff --git a/src/resolve/polymorph/resolver.rs b/src/resolve/polymorph/resolver.rs
@@ -58,7 +58,10 @@ impl<'a> PolyRecipeResolver<'a> {
             }
             asg::TypeKind::AnonymousStruct() => todo!(),
             asg::TypeKind::AnonymousUnion() => todo!(),
-            asg::TypeKind::AnonymousEnum() => todo!(),
+            asg::TypeKind::AnonymousEnum(_) => {
+                // NOTE: There are no inner polymorphs
+                ty.clone()
+            }
             asg::TypeKind::FixedArray(fixed_array) => {
                 asg::TypeKind::FixedArray(Box::new(asg::FixedArray {
                     size: fixed_array.size,
diff --git a/src/resolve/type_ctx/resolve_type.rs b/src/resolve/type_ctx/resolve_type.rs
@@ -1,6 +1,6 @@
 use super::{resolve_constraints, ResolveTypeCtx};
 use crate::{
-    asg::{self, Params},
+    asg::{self, AnonymousEnum, Params},
     ast::{self, IntegerBits},
     ir::IntegerSign,
     resolve::error::{ResolveError, ResolveErrorKind},
@@ -69,8 +69,22 @@ impl<'a> ResolveTypeCtx<'a> {
             ast::TypeKind::Floating(size) => Ok(asg::TypeKind::Floating(*size)),
             ast::TypeKind::AnonymousStruct(..) => todo!("resolve anonymous struct type"),
             ast::TypeKind::AnonymousUnion(..) => todo!("resolve anonymous union type"),
-            ast::TypeKind::AnonymousEnum(_) => {
-                todo!("resolve anonymous enum type")
+            ast::TypeKind::AnonymousEnum(enumeration) => {
+                let backing_type = enumeration
+                    .backing_type
+                    .as_ref()
+                    .map(|ty| self.resolve(ty.as_ref()))
+                    .transpose()?
+                    .unwrap_or_else(|| {
+                        asg::TypeKind::Integer(IntegerBits::Bits32, IntegerSign::Signed)
+                            .at(ast_type.source)
+                    });
+
+                Ok(asg::TypeKind::AnonymousEnum(Box::new(AnonymousEnum {
+                    members: enumeration.members.clone(),
+                    backing_type,
+                    source: ast_type.source,
+                })))
             }
             ast::TypeKind::FixedArray(fixed_array) => {
                 if let ast::ExprKind::Integer(integer) = &fixed_array.count.kind {

Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ pub struct Enum {`
`12`	`12`	`pub privacy: Privacy,`
`13`	`13`	`}`
`14`	`14`
`15`		`-#[derive(Clone, Debug, PartialEq)]`
	`15`	`+#[derive(Clone, Debug, PartialEq, Eq, Hash)]`
`16`	`16`	`pub struct EnumMember {`
`17`	`17`	`pub value: BigInt,`
`18`	`18`	`pub explicit_value: bool,`
Original file line number	Diff line number	Diff line change
`@@ -94,7 +94,7 @@ pub fn lower_type(`
`94`	`94`	`asg::TypeKind::AnonymousUnion() => {`
`95`	`95`	`todo!("lower anonymous union")`
`96`	`96`	`}`
`97`		`- asg::TypeKind::AnonymousEnum() => {`
	`97`	`+ asg::TypeKind::AnonymousEnum(_) => {`
`98`	`98`	`todo!("lower anonymous enum")`
`99`	`99`	`}`
`100`	`100`	`asg::TypeKind::FixedArray(fixed_array) => {`