transpile: Move ctx modifications down in cast handling code

Author: Rua

c2rust-transpile/src/translator/mod.rs

@@ -3078,14 +3078,26 @@ impl<'c> Translation<'c> {
             ImplicitCast(ty, expr, kind, opt_field_id, _)
             | ExplicitCast(ty, expr, kind, opt_field_id, _) => {
                 let is_explicit = matches!(expr_kind, CExprKind::ExplicitCast(..));
-                // A reference must be decayed if a bitcast is required. Const casts in
-                // LLVM 8 are now NoOp casts, so we need to include it as well.
+                let target_ty = override_ty.unwrap_or(ty);
+
+                // 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 some expression types, if we don't absolutely have to cast,
+                // we would rather the expression is translated according to the type we're
+                // expecting, and then we can skip the cast entirely.
+                if self.can_propagate_cast(expr, target_ty, is_explicit) {
+                    return self.convert_expr(ctx, expr, Some(target_ty));
+                }
+
                 match kind {
                     CastKind::IntegralToBoolean
                     | CastKind::FloatingToBoolean
                     | CastKind::PointerToBoolean => {
                         return self.convert_condition(ctx, true, expr);
                     }
+
+                    // A reference must be decayed if a bitcast is required. Const casts in
+                    // LLVM 8 are now NoOp casts, so we need to include it as well.
                     CastKind::BitCast | CastKind::PointerToIntegral | CastKind::NoOp => {
                         ctx.decay_ref = DecayRef::Yes
                     }
@@ -3097,17 +3109,6 @@ impl<'c> Translation<'c> {
                     _ => {}
                 }
 
-                let target_ty = override_ty.unwrap_or(ty);
-
-                // 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 some expression types, if we don't absolutely have to cast,
-                // we would rather the expression is translated according to the type we're
-                // expecting, and then we can skip the cast entirely.
-                if self.can_propagate_cast(expr, target_ty, is_explicit) {
-                    return self.convert_expr(ctx, expr, Some(target_ty));
-                }
-
                 let mut val = self.convert_expr(ctx, expr, None)?;
 
                 if is_explicit {