transpile: change negated: bool to is_null: bool in fn convert_pointer_is_null

Co-authored-by: Rua <ruawhitepaw@gmail.com>

Author: kkysen

c2rust-transpile/src/translator/mod.rs

@@ -2715,39 +2715,39 @@ impl<'c> Translation<'c> {
             .ok_or_else(|| format_err!("bad condition type"))?;
 
         let null_pointer_case =
-            |negated: bool, ptr: CExprId| -> TranslationResult<WithStmts<Box<Expr>>> {
+            |is_null: bool, ptr: CExprId| -> TranslationResult<WithStmts<Box<Expr>>> {
                 let val = self.convert_expr(ctx.used().decay_ref(), ptr, None)?;
                 let ptr_type = self.ast_context[ptr]
                     .kind
                     .get_type()
                     .ok_or_else(|| format_err!("bad pointer type for condition"))?;
 
-                val.result_map(|val| self.convert_pointer_is_null(ctx, ptr_type, val, negated))
+                val.result_map(|val| self.convert_pointer_is_null(ctx, ptr_type, val, is_null))
             };
 
         match self.ast_context[cond_id].kind {
             CExprKind::Binary(_, c_ast::BinOp::EqualEqual, null_expr, ptr, _, _)
                 if self.ast_context.is_null_expr(null_expr) =>
             {
-                null_pointer_case(!target, ptr)
+                null_pointer_case(target, ptr)
             }
 
             CExprKind::Binary(_, c_ast::BinOp::EqualEqual, ptr, null_expr, _, _)
                 if self.ast_context.is_null_expr(null_expr) =>
             {
-                null_pointer_case(!target, ptr)
+                null_pointer_case(target, ptr)
             }
 
             CExprKind::Binary(_, c_ast::BinOp::NotEqual, null_expr, ptr, _, _)
                 if self.ast_context.is_null_expr(null_expr) =>
             {
-                null_pointer_case(target, ptr)
+                null_pointer_case(!target, ptr)
             }
 
             CExprKind::Binary(_, c_ast::BinOp::NotEqual, ptr, null_expr, _, _)
                 if self.ast_context.is_null_expr(null_expr) =>
             {
-                null_pointer_case(target, ptr)
+                null_pointer_case(!target, ptr)
             }
 
             CExprKind::Unary(_, c_ast::UnOp::Not, subexpr_id, _) => {
@@ -4829,7 +4829,7 @@ impl<'c> Translation<'c> {
         let ty = &self.ast_context.resolve_type(ty_id).kind;
 
         Ok(if ty.is_pointer() {
-            self.convert_pointer_is_null(ctx, ty_id, val, target)?
+            self.convert_pointer_is_null(ctx, ty_id, val, !target)?
         } else if ty.is_bool() {
             if target {
                 val

c2rust-transpile/src/translator/operators.rs

@@ -620,17 +620,17 @@ impl<'c> Translation<'c> {
                 // Using `.is_none()` and `.is_some()` for null comparison means
                 // we don't have to rely on `trait PartialEq` as much
                 // and it is also more idiomatic.
-                let (negated, bin_op) = match op {
-                    c_ast::BinOp::EqualEqual => (false, BinOp::Eq(Default::default())),
-                    c_ast::BinOp::NotEqual => (true, BinOp::Ne(Default::default())),
+                let (is_null, bin_op) = match op {
+                    c_ast::BinOp::EqualEqual => (true, BinOp::Eq(Default::default())),
+                    c_ast::BinOp::NotEqual => (false, BinOp::Ne(Default::default())),
                     _ => unreachable!(),
                 };
                 let expr = match lhs_rhs_ids {
                     Some((lhs_expr_id, _)) if self.ast_context.is_null_expr(lhs_expr_id) => {
-                        self.convert_pointer_is_null(ctx, rhs_type.ctype, rhs, negated)?
+                        self.convert_pointer_is_null(ctx, rhs_type.ctype, rhs, is_null)?
                     }
                     Some((_, rhs_expr_id)) if self.ast_context.is_null_expr(rhs_expr_id) => {
-                        self.convert_pointer_is_null(ctx, lhs_type.ctype, lhs, negated)?
+                        self.convert_pointer_is_null(ctx, lhs_type.ctype, lhs, is_null)?
                     }
                     _ => mk().binary_expr(bin_op, lhs, rhs),
                 };

c2rust-transpile/src/translator/pointers.rs

@@ -570,10 +570,10 @@ impl<'c> Translation<'c> {
         ctx: ExprContext,
         ptr_type: CTypeId,
         e: Box<Expr>,
-        negated: bool,
+        is_null: bool,
     ) -> TranslationResult<Box<Expr>> {
         Ok(if self.ast_context.is_function_pointer(ptr_type) {
-            let method = if negated { "is_some" } else { "is_none" };
+            let method = if is_null { "is_none" } else { "is_some" };
             mk().method_call_expr(e, method, vec![])
         } else {
             // TODO: `pointer::is_null` becomes stably const in Rust 1.84.
@@ -583,11 +583,11 @@ impl<'c> Translation<'c> {
                     "cannot check nullity of pointer in `const` context",
                 ));
             }
-            let is_null = mk().method_call_expr(e, "is_null", vec![]);
-            if negated {
-                mk().unary_expr(UnOp::Not(Default::default()), is_null)
+            let is_null_val = mk().method_call_expr(e, "is_null", vec![]);
+            if !is_null {
+                mk().unary_expr(UnOp::Not(Default::default()), is_null_val)
             } else {
-                is_null
+                is_null_val
             }
         })
     }