transpile: propagate expected types down to translation of literals

this removes lots of ugly extra casts

Author: fw-immunant

c2rust-transpile/src/translator/literals.rs

@@ -72,6 +72,17 @@ impl<'c> Translation<'c> {
         mk().cast_expr(value, target_ty)
     }
 
+    /// Return whether the literal can be directly translated as this type
+    pub fn literal_matches_ty(&self, kind: &CLiteral, ty: CQualTypeId) -> bool {
+        let ty_kind = &self.ast_context.resolve_type(ty.ctype).kind;
+        match *kind {
+            CLiteral::Integer(..) if ty_kind.is_integral_type() && !ty_kind.is_bool() => true,
+            CLiteral::Character(..) if ty_kind.is_integral_type() && !ty_kind.is_bool() => true,
+            CLiteral::Floating(..) if ty_kind.is_floating_type() => true,
+            _ => false,
+        }
+    }
+
     /// Convert a C literal expression to a Rust expression
     pub fn convert_literal(
         &self,

c2rust-transpile/src/translator/mod.rs

@@ -3485,7 +3485,7 @@ impl<'c> Translation<'c> {
                 }
             },
 
-            Literal(ty, ref kind) => self.convert_literal(ctx, ty, kind),
+            Literal(ty, ref kind) => self.convert_literal(ctx, override_ty.unwrap_or(ty), kind),
 
             ImplicitCast(ty, expr, kind, opt_field_id, _)
             | ExplicitCast(ty, expr, kind, opt_field_id, _) => {
@@ -3513,6 +3513,18 @@ impl<'c> Translation<'c> {
                     val.prepend_stmts(stmts);
                     val
                 } else {
+                    // In general, if we are casting the result of an expression, then the inner
+                    // expression should be translated to whatever type it normally would.
+                    // But for literals, if we don't absolutely have to cast, we would rather the
+                    // literal is translated according to the type we're expecting, and then we can
+                    // skip the cast entirely.
+                    if let (Some(ty), CExprKind::Literal(_ty, lit)) =
+                        (override_ty, &self.ast_context[expr].kind)
+                    {
+                        if self.literal_matches_ty(lit, ty) {
+                            return self.convert_expr(ctx, expr, override_ty);
+                        }
+                    }
                     self.convert_expr(ctx, expr, None)?
                 };
                 // Shuffle Vector "function" builtins will add a cast to the output of the

c2rust-transpile/tests/snapshots/factorial.rs

@@ -9,8 +9,8 @@
 )]
 #[no_mangle]
 pub unsafe extern "C" fn factorial(mut n: std::ffi::c_ushort) -> std::ffi::c_ushort {
-    let mut result: std::ffi::c_ushort = 1 as std::ffi::c_int as std::ffi::c_ushort;
-    let mut i: std::ffi::c_ushort = 1 as std::ffi::c_int as std::ffi::c_ushort;
+    let mut result: std::ffi::c_ushort = 1 as std::ffi::c_ushort;
+    let mut i: std::ffi::c_ushort = 1 as std::ffi::c_ushort;
     while (i as std::ffi::c_int) < n as std::ffi::c_int {
         result = (result as std::ffi::c_int * i as std::ffi::c_int)
             as std::ffi::c_ushort;

c2rust-transpile/tests/snapshots/[email protected]

@@ -14,8 +14,8 @@ input_file: c2rust-transpile/tests/snapshots/factorial.c
 )]
 #[no_mangle]
 pub unsafe extern "C" fn factorial(mut n: std::ffi::c_ushort) -> std::ffi::c_ushort {
-    let mut result: std::ffi::c_ushort = 1 as std::ffi::c_int as std::ffi::c_ushort;
-    let mut i: std::ffi::c_ushort = 1 as std::ffi::c_int as std::ffi::c_ushort;
+    let mut result: std::ffi::c_ushort = 1 as std::ffi::c_ushort;
+    let mut i: std::ffi::c_ushort = 1 as std::ffi::c_ushort;
     while (i as std::ffi::c_int) < n as std::ffi::c_int {
         result = (result as std::ffi::c_int * i as std::ffi::c_int)
             as std::ffi::c_ushort;