Started working on implicit integer conversions for C enum values

Author: IsaacShelton

Diff for: src/asg/datatype/kind/anonymous_enum.rs

@@ -6,6 +6,7 @@ use indexmap::IndexMap;
 pub struct AnonymousEnum {
     pub backing_type: Type,
     pub members: IndexMap<String, EnumMember>,
+    pub allow_implicit_integer_conversions: bool,
     pub source: Source,
 }
 

Diff for: src/ast/datatype/nameless_enumeration.rs

@@ -6,4 +6,5 @@ use indexmap::IndexMap;
 pub struct AnonymousEnum {
     pub members: IndexMap<String, EnumMember>,
     pub backing_type: Option<Box<Type>>,
+    pub allow_implicit_integer_conversions: bool,
 }

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

@@ -84,6 +84,7 @@ pub fn make_anonymous_enum(
             Ok(TypeKind::AnonymousEnum(AnonymousEnum {
                 members,
                 backing_type,
+                allow_implicit_integer_conversions: true,
             }))
         }
         Enumeration::Named(named) => {

Diff for: src/resolve/conform/from_anonymous_enum.rs

@@ -0,0 +1,32 @@
+use super::{ConformMode, Objective, ObjectiveResult};
+use crate::{
+    asg::{AnonymousEnum, Expr, Type, TypeKind},
+    source_files::Source,
+};
+
+pub fn from_anonymous_enum<O: Objective>(
+    _expr: &Expr,
+    _from_type: &Type,
+    _mode: ConformMode,
+    to_type: &Type,
+    enumeration: &AnonymousEnum,
+    _source: Source,
+) -> ObjectiveResult<O> {
+    match &to_type.kind {
+        TypeKind::Integer(_to_bits, _to_sign) => {
+            if !enumeration.allow_implicit_integer_conversions {
+                return O::fail();
+            }
+
+            todo!("convert from anonymous enum to fixed integer")
+        }
+        TypeKind::CInteger(_to_c_integer, _to_sign) => {
+            if !enumeration.allow_implicit_integer_conversions {
+                return O::fail();
+            }
+
+            todo!("convert from anonymous enum to flexible integer")
+        }
+        _ => O::fail(),
+    }
+}

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

@@ -1,3 +1,4 @@
+mod from_anonymous_enum;
 mod from_c_integer;
 mod from_float;
 mod from_float_literal;
@@ -8,9 +9,9 @@ mod mode;
 pub mod to_default;
 
 use self::{
-    from_c_integer::from_c_integer, from_float::from_float, from_float_literal::from_float_literal,
-    from_integer::from_integer, from_integer_literal::from_integer_literal,
-    from_pointer::from_pointer,
+    from_anonymous_enum::from_anonymous_enum, from_c_integer::from_c_integer,
+    from_float::from_float, from_float_literal::from_float_literal, from_integer::from_integer,
+    from_integer_literal::from_integer_literal, from_pointer::from_pointer,
 };
 use super::{
     error::{ResolveError, ResolveErrorKind},
@@ -115,6 +116,14 @@ pub fn conform_expr<O: Objective>(
             to_type,
             conform_source,
         ),
+        TypeKind::AnonymousEnum(enumeration) => from_anonymous_enum::<O>(
+            &expr.expr,
+            from_type,
+            mode,
+            to_type,
+            enumeration.as_ref(),
+            conform_source,
+        ),
         _ => O::fail(),
     }
 }

Diff for: src/resolve/type_ctx/resolve_type.rs

@@ -111,6 +111,8 @@ impl<'a> ResolveTypeCtx<'a> {
                 Ok(asg::TypeKind::AnonymousEnum(Box::new(AnonymousEnum {
                     members: enumeration.members.clone(),
                     backing_type,
+                    allow_implicit_integer_conversions: enumeration
+                        .allow_implicit_integer_conversions,
                     source: ast_type.source,
                 })))
             }