transpile: Translate EnumConstant with associated constants

Author: Rua

c2rust-ast-builder/src/builder.rs

@@ -1416,6 +1416,26 @@ impl Builder {
         }))
     }
 
+    pub fn const_impl_item<I>(self, name: I, ty: Box<Type>, init: Box<Expr>) -> ImplItem
+    where
+        I: Make<Ident>,
+    {
+        let name = name.make(&self);
+        ImplItem::Const(ImplItemConst {
+            attrs: self.attrs,
+            vis: self.vis,
+            defaultness: None,
+            const_token: Token![const](self.span),
+            ident: name,
+            generics: self.generics,
+            colon_token: Token![:](self.span),
+            ty: *ty,
+            eq_token: Token![=](self.span),
+            expr: *init,
+            semi_token: Token![;](self.span),
+        })
+    }
+
     pub fn fn_item<S>(self, sig: S, mut block: Block) -> Box<Item>
     where
         S: Make<Signature>,

c2rust-transpile/src/translator/enums.rs

@@ -4,6 +4,7 @@ use syn::Expr;
 
 use crate::c_ast::CUnOp;
 use crate::{
+    c_ast::iterators::SomeId,
     diagnostics::TranslationResult,
     translator::{signed_int_expr, ConvertedDecl, EnumMode, ExprContext, Translation},
     with_stmts::WithStmts,
@@ -17,68 +18,121 @@ impl<'c> Translation<'c> {
         enum_id: CEnumId,
         span: Span,
         integral_type: CQualTypeId,
+        variants: &[CEnumConstantId],
     ) -> TranslationResult<ConvertedDecl> {
         let enum_name = &self
             .type_converter
             .borrow()
             .resolve_decl_name(enum_id)
             .expect("Enums should already be renamed");
-
-        let item = match self.tcfg.enum_mode {
+        let integral_type_rs = self.convert_type(integral_type.ctype)?;
+        let enum_item = match self.tcfg.enum_mode {
             EnumMode::NewType => {
-                let field = mk()
-                    .pub_()
-                    .enum_field(self.convert_type(integral_type.ctype)?);
+                let field = mk().pub_().enum_field(integral_type_rs);
                 mk().span(span)
                     .call_attr("derive", vec!["Clone", "Copy"])
                     .call_attr("repr", vec!["transparent"])
                     .pub_()
                     .struct_item(enum_name, vec![field], true)
             }
 
-            EnumMode::Consts => {
-                let ty = self.convert_type(integral_type.ctype)?;
-                mk().span(span).pub_().type_item(enum_name, ty)
-            }
+            EnumMode::Consts => mk()
+                .span(span)
+                .pub_()
+                .type_item(enum_name, integral_type_rs),
         };
 
-        Ok(ConvertedDecl::Item(item))
-    }
+        if variants.is_empty() {
+            return Ok(ConvertedDecl::Item(enum_item));
+        }
 
-    pub fn convert_enum_constant(
-        &self,
-        enum_constant_id: CEnumConstantId,
-        span: Span,
-        value: ConstIntExpr,
-    ) -> TranslationResult<ConvertedDecl> {
-        let name = self
-            .renamer
-            .borrow_mut()
-            .get(&enum_constant_id)
-            .expect("Enum constant not named");
-        let enum_id = self.ast_context.parents[&enum_constant_id];
-        let enum_name = self
-            .type_converter
-            .borrow()
-            .resolve_decl_name(enum_id)
-            .expect("Enums should already be renamed");
+        match self.tcfg.enum_mode {
+            EnumMode::NewType => {
+                let enum_type = mk().ident_ty("Self");
+                let constants = variants
+                    .iter()
+                    .map(|&enum_constant_id| {
+                        let name = match self.ast_context[enum_constant_id].kind {
+                            CDeclKind::EnumConstant { ref name, .. } => self
+                                .type_converter
+                                .borrow_mut()
+                                .declare_field_name(enum_id, enum_constant_id, name),
+                            _ => panic!("{:?} does not point to an enum variant", enum_constant_id),
+                        };
+                        let (span, init) = self.make_enum_constant_init(enum_constant_id);
+                        mk().span(span)
+                            .pub_()
+                            .const_impl_item(name, enum_type.clone(), init)
+                    })
+                    .collect();
+
+                let impl_block = mk().impl_item(mk().ident_ty(enum_name), constants);
+                Ok(ConvertedDecl::Items(vec![enum_item, impl_block]))
+            }
 
-        let ty = mk().ident_ty(enum_name);
+            EnumMode::Consts => {
+                let enum_type = mk().ident_ty(enum_name);
+                let constants_iter = variants.iter().map(|&enum_constant_id| {
+                    let name = self
+                        .renamer
+                        .borrow_mut()
+                        .get(&enum_constant_id)
+                        .expect("Enum constant not named");
+                    let (span, init) = self.make_enum_constant_init(enum_constant_id);
+                    mk().span(span)
+                        .pub_()
+                        .const_item(name, enum_type.clone(), init)
+                });
+
+                let items = std::iter::once(enum_item).chain(constants_iter).collect();
+                Ok(ConvertedDecl::Items(items))
+            }
+        }
+    }
+
+    fn make_enum_constant_init(&self, enum_constant_id: CEnumConstantId) -> (Span, Box<Expr>) {
+        let value = match self.ast_context[enum_constant_id].kind {
+            CDeclKind::EnumConstant { value, .. } => value,
+            _ => panic!("{:?} does not point to an enum variant", enum_constant_id),
+        };
         let val = match value {
             ConstIntExpr::I(value) => signed_int_expr(value),
             ConstIntExpr::U(value) => mk().lit_expr(mk().int_unsuffixed_lit(value as u128)),
         };
-        let init = self.enum_constructor_expr(enum_id, val);
+        let enum_id = self.ast_context.parents[&enum_constant_id];
+        let init = self.enum_constructor_expr(enum_id, val, true);
+        let span = self
+            .get_span(SomeId::Decl(enum_constant_id))
+            .unwrap_or_else(Span::call_site);
 
-        Ok(ConvertedDecl::Item(
-            mk().span(span).pub_().const_item(name, ty, init),
-        ))
+        (span, init)
     }
 
     pub fn convert_enum_zero_initializer(&self, enum_id: CEnumId) -> WithStmts<Box<Expr>> {
         WithStmts::new_val(self.enum_for_i64(enum_id, 0))
     }
 
+    /// Translates a `DeclRef` for an `EnumConstant`.
+    pub fn convert_enum_constant_decl_ref(
+        &self,
+        ctx: ExprContext,
+        enum_constant_id: CEnumConstantId,
+        target_cty: CQualTypeId,
+    ) -> TranslationResult<WithStmts<Box<Expr>>> {
+        let enum_id = self.ast_context.parents[&enum_constant_id];
+        let val = self.enum_constant_expr(enum_id, enum_constant_id);
+
+        // If our target type is this enum type, don't bother with a cast.
+        if matches!(
+            self.ast_context.resolve_type(target_cty.ctype).kind,
+            CTypeKind::Enum(target_enum_id) if target_enum_id == enum_id
+        ) {
+            Ok(WithStmts::new_val(val))
+        } else {
+            self.convert_cast_from_enum(ctx, enum_id, target_cty, val)
+        }
+    }
+
     /// Translate a cast where the source type, but not the target type, is an `enum` type.
     pub fn convert_cast_from_enum(
         &self,
@@ -145,7 +199,7 @@ impl<'c> Translation<'c> {
                     // If this DeclRef expanded to a const macro, we actually need to insert a cast,
                     // because the translation of a const macro skips implicit casts in its context.
                     if !expr_is_macro {
-                        val = self.enum_constant_expr(enum_constant_id);
+                        val = self.enum_constant_expr(enum_id, enum_constant_id);
                         return Ok(WithStmts::new_val(val));
                     }
                 }
@@ -202,14 +256,14 @@ impl<'c> Translation<'c> {
         }
 
         // Construct a new enum value.
-        Ok(val.map(|val| self.enum_constructor_expr(enum_id, val)))
+        Ok(val.map(|val| self.enum_constructor_expr(enum_id, val, false)))
     }
 
     /// Given an integer value this attempts to either generate the corresponding enum
     /// variant directly, otherwise it converts a number to the enum type.
     fn enum_for_i64(&self, enum_id: CEnumId, value: i64) -> Box<Expr> {
         if let Some(enum_constant_id) = self.enum_variant_for_i64(enum_id, value) {
-            return self.enum_constant_expr(enum_constant_id);
+            return self.enum_constant_expr(enum_id, enum_constant_id);
         }
 
         let underlying_type_id = self.enum_integral_type(enum_id);
@@ -219,7 +273,7 @@ impl<'c> Translation<'c> {
             _ => signed_int_expr(value),
         };
 
-        self.enum_constructor_expr(enum_id, value)
+        self.enum_constructor_expr(enum_id, value, false)
     }
 
     /// Returns the id of the variant of `enum_id` whose value matches `value`, if any.
@@ -240,24 +294,65 @@ impl<'c> Translation<'c> {
             })
     }
 
-    fn enum_constructor_expr(&self, enum_id: CEnumId, value: Box<Expr>) -> Box<Expr> {
-        let enum_name = self
-            .type_converter
-            .borrow()
-            .resolve_decl_name(enum_id)
-            .unwrap();
-        self.add_import(enum_id, &enum_name);
-
+    fn enum_constructor_expr(
+        &self,
+        enum_id: CEnumId,
+        value: Box<Expr>,
+        use_self_ty: bool,
+    ) -> Box<Expr> {
         match self.tcfg.enum_mode {
-            EnumMode::NewType => mk().call_expr(mk().ident_expr(enum_name), vec![value]),
-            EnumMode::Consts => mk().cast_expr(value, mk().ident_ty(enum_name)),
+            EnumMode::NewType => {
+                let func = if use_self_ty {
+                    mk().ident_expr("Self")
+                } else {
+                    let enum_name = self
+                        .type_converter
+                        .borrow()
+                        .resolve_decl_name(enum_id)
+                        .unwrap();
+                    self.add_import(enum_id, &enum_name);
+                    mk().ident_expr(enum_name)
+                };
+
+                mk().call_expr(func, vec![value])
+            }
+            EnumMode::Consts => {
+                let enum_name = self
+                    .type_converter
+                    .borrow()
+                    .resolve_decl_name(enum_id)
+                    .unwrap();
+                self.add_import(enum_id, &enum_name);
+
+                mk().cast_expr(value, mk().ident_ty(enum_name))
+            }
         }
     }
 
-    fn enum_constant_expr(&self, enum_constant_id: CEnumConstantId) -> Box<Expr> {
-        let name = self.renamer.borrow().get(&enum_constant_id).unwrap();
-        self.add_import(enum_constant_id, &name);
-        mk().ident_expr(name)
+    fn enum_constant_expr(&self, enum_id: CEnumId, enum_constant_id: CEnumConstantId) -> Box<Expr> {
+        match self.tcfg.enum_mode {
+            EnumMode::NewType => {
+                let enum_name = self
+                    .type_converter
+                    .borrow()
+                    .resolve_decl_name(enum_id)
+                    .unwrap();
+                let name = self
+                    .type_converter
+                    .borrow()
+                    .resolve_field_name(Some(enum_id), enum_constant_id)
+                    .unwrap();
+
+                self.add_import(enum_id, &enum_name);
+                mk().path_expr(vec![enum_name, name])
+            }
+
+            EnumMode::Consts => {
+                let name = self.renamer.borrow().get(&enum_constant_id).unwrap();
+                self.add_import(enum_constant_id, &name);
+                mk().ident_expr(name)
+            }
+        }
     }
 
     fn is_variant_of_enum(&self, enum_id: CEnumId, enum_constant_id: CEnumConstantId) -> bool {

c2rust-transpile/src/translator/mod.rs

@@ -769,7 +769,10 @@ pub fn translate(
                 Union { ref name, .. } => some_type_name(name.as_ref().map(String::as_str)),
                 Typedef { ref name, .. } => Name::Type(name),
                 Function { ref name, .. } => Name::Var(name),
-                EnumConstant { ref name, .. } => Name::Var(name),
+                EnumConstant { ref name, .. } => match t.tcfg.enum_mode {
+                    EnumMode::NewType => Name::None,
+                    EnumMode::Consts => Name::Var(name),
+                },
                 Variable { ref ident, .. } if t.ast_context.c_decls_top.contains(&decl_id) => {
                     Name::Var(ident)
                 }
@@ -847,7 +850,6 @@ pub fn translate(
                 let needs_export = match decl.kind {
                     Struct { .. } => true,
                     Enum { .. } => true,
-                    EnumConstant { .. } => true,
                     Union { .. } => true,
                     Typedef { .. } => {
                         // Only check the key as opposed to `contains`
@@ -1919,11 +1921,13 @@ impl<'c> Translation<'c> {
             )),
 
             Enum {
+                ref variants,
                 integral_type: Some(integral_type),
                 ..
-            } => self.convert_enum(decl_id, span, integral_type),
+            } => self.convert_enum(decl_id, span, integral_type, variants),
 
-            EnumConstant { value, .. } => self.convert_enum_constant(decl_id, span, value),
+            // EnumConstant is translated as part of Enum.
+            EnumConstant { .. } => Ok(ConvertedDecl::NoItem),
 
             // We can allow non top level function declarations (i.e. extern
             // declarations) without any problem. Clang doesn't support nested
@@ -3455,6 +3459,11 @@ impl<'c> Translation<'c> {
         }
 
         let varname = decl.get_name().expect("expected variable name").to_owned();
+
+        if let &CDeclKind::EnumConstant { .. } = decl {
+            return self.convert_enum_constant_decl_ref(ctx, decl_id, qual_ty);
+        }
+
         let rustname = self
             .renamer
             .borrow_mut()
@@ -3472,13 +3481,6 @@ impl<'c> Translation<'c> {
 
         let mut val = mk().path_expr(vec![rustname]);
 
-        // If the variable is actually an `EnumConstant`, we need to add a cast to the
-        // expected integral type.
-        if let &CDeclKind::EnumConstant { .. } = decl {
-            let enum_id = self.ast_context.parents[&decl_id];
-            return self.convert_cast_from_enum(ctx, enum_id, qual_ty, val);
-        }
-
         // If we are referring to a function and need its address, we
         // need to cast it to fn() to ensure that it has a real address.
         let mut set_unsafe = false;