Respect signedness for integer literals (#446)

Author: lucic71

cpp2rust/converter/converter.cpp

@@ -2252,7 +2252,9 @@ static std::string getTypedLiteral(const char *num, std::string_view type) {
 std::string Converter::getIntegerLiteral(clang::IntegerLiteral *expr,
                                          bool incl_type,
                                          const clang::QualType *type) {
-  auto num_as_string = GetNumAsString(expr->getValue());
+  auto value = GetIntegerLiteralValue(ctx_, expr, type, CharRustTypeIsSigned());
+  llvm::SmallString<16> num_as_string;
+  value.toString(num_as_string, 10);
   if (num_as_string[0] != '-' && !incl_type) {
     if (type && (*type)->isFloatingType() &&
         num_as_string.find('.') == llvm::StringRef::npos) {
@@ -2265,7 +2267,7 @@ std::string Converter::getIntegerLiteral(clang::IntegerLiteral *expr,
   auto type_as_string = GetUnsafeTypeAsString(ty);
 
   if (ty->isFloatingType() || incl_type) {
-    if (expr->getValue().isZero()) {
+    if (value.isZero()) {
       if (auto init = Mapper::MapInitializer(ctx_, ty); !init.empty()) {
         return init;
       }
@@ -2956,6 +2958,15 @@ bool Converter::VisitUnaryOperator(clang::UnaryOperator *expr) {
       computed_expr_type_ = ComputedExprType::FreshValue;
       break;
     }
+    if (expr->getType()->isUnsignedIntegerType()) {
+      {
+        PushParen paren(*this);
+        Convert(sub_expr);
+      }
+      StrCat(".wrapping_neg()");
+      SetFreshType(expr->getType());
+      break;
+    }
     [[fallthrough]];
   default:
     StrCat(expr->getOpcodeStr(opcode));

cpp2rust/converter/converter.h

@@ -129,8 +129,12 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
 
   virtual bool EmitsReprCForRecords() const { return true; }
 
+  // CharRustType and CharRustTypeIsSigned should disappear after
+  // https://github.com/Cpp2Rust/cpp2rust/issues/246
   virtual const char *CharRustType() const { return "libc::c_char"; }
 
+  virtual bool CharRustTypeIsSigned() const { return true; }
+
   virtual bool VisitCXXMethodDecl(clang::CXXMethodDecl *decl);
 
   virtual bool ShouldConvertMethod(const clang::CXXMethodDecl *decl);

cpp2rust/converter/converter_lib.cpp

@@ -246,6 +246,24 @@ bool RefersToUserDefinedDecl(const clang::Expr *expr) {
   return decl && IsUserDefinedDecl(decl);
 }
 
+llvm::APSInt GetIntegerLiteralValue(const clang::ASTContext &ctx,
+                                    const clang::IntegerLiteral *expr,
+                                    const clang::QualType *type,
+                                    bool char_is_signed) {
+  auto value = expr->getValue();
+  bool is_signed = false;
+  if (type && (*type)->isBuiltinType() && (*type)->isIntegerType() &&
+      !(*type)->isBooleanType()) {
+    value = value.zextOrTrunc(ctx.getIntWidth(*type));
+    is_signed =
+        (*type)->isSpecificBuiltinType(clang::BuiltinType::Char_S) ||
+                (*type)->isSpecificBuiltinType(clang::BuiltinType::Char_U)
+            ? char_is_signed
+            : (*type)->isSignedIntegerType();
+  }
+  return llvm::APSInt(value, !is_signed);
+}
+
 bool IsUnsignedArithOp(const clang::BinaryOperator *expr) {
   clang::QualType lhs_type;
   clang::QualType rhs_type;

cpp2rust/converter/converter_lib.h

@@ -9,6 +9,7 @@
 #include <clang/AST/Expr.h>
 #include <clang/AST/StmtCXX.h>
 #include <clang/AST/Type.h>
+#include <llvm/ADT/APSInt.h>
 #include <llvm/ADT/STLFunctionalExtras.h>
 
 #include <optional>
@@ -65,6 +66,11 @@ bool RefersToUserDefinedDecl(const clang::Expr *expr);
 
 bool IsUnsignedArithOp(const clang::BinaryOperator *expr);
 
+llvm::APSInt GetIntegerLiteralValue(const clang::ASTContext &ctx,
+                                    const clang::IntegerLiteral *expr,
+                                    const clang::QualType *type,
+                                    bool char_is_signed);
+
 bool IsMut(clang::QualType qual_type);
 
 bool RustSizeDivergesFromC(clang::QualType qt);

cpp2rust/converter/models/converter_refcount.h

@@ -37,6 +37,7 @@ class ConverterRefCount final : public Converter {
   bool EmitsReprCForRecords() const override { return false; }
 
   const char *CharRustType() const override { return "u8"; }
+  bool CharRustTypeIsSigned() const override { return false; }
 
   std::string GetComparisonReferenceArg(const clang::CXXRecordDecl *decl,
                                         std::string_view value) override;

tests/unit/out/refcount/signed_integer.rs

@@ -0,0 +1,25 @@
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::cell::RefCell;
+use std::collections::BTreeMap;
+use std::io::prelude::*;
+use std::io::{Read, Seek, Write};
+use std::os::fd::AsFd;
+use std::rc::{Rc, Weak};
+pub fn main() {
+    __cpp2rust_init_globals();
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    let x1: Value<i32> = Rc::new(RefCell::new(-1_i32));
+    assert!(((((*x1.borrow()) == -1_i32) as i32) != 0));
+    let x2: Value<i8> = Rc::new(RefCell::new(-1_i8));
+    assert!((((((*x2.borrow()) as i32) == -1_i32) as i32) != 0));
+    let u1: Value<u32> = Rc::new(RefCell::new(5_u32));
+    let u2: Value<u32> = Rc::new(RefCell::new((*u1.borrow()).wrapping_neg()));
+    assert!(((((*u2.borrow()) == 4294967291_u32) as i32) != 0));
+    let c1: Value<u8> = Rc::new(RefCell::new(255_u8));
+    assert!(((((((*c1.borrow()) as u8) as i32) == 255) as i32) != 0));
+    return 0;
+}
+pub fn __cpp2rust_init_globals() {}

tests/unit/out/unsafe/signed_integer.rs

@@ -0,0 +1,27 @@
+extern crate libc;
+use libc::*;
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::collections::BTreeMap;
+use std::io::{Read, Seek, Write};
+use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
+use std::rc::Rc;
+pub fn main() {
+    unsafe {
+        __cpp2rust_init_globals();
+        std::process::exit(main_0() as i32);
+    }
+}
+unsafe fn main_0() -> i32 {
+    let mut x1: i32 = -1_i32;
+    assert!(((((x1) == (-1_i32)) as i32) != 0));
+    let mut x2: i8 = -1_i8;
+    assert!(((((x2 as i32) == (-1_i32)) as i32) != 0));
+    let mut u1: u32 = 5_u32;
+    let mut u2: u32 = (u1).wrapping_neg();
+    assert!(((((u2) == (4294967291_u32)) as i32) != 0));
+    let mut c1: libc::c_char = (-1 as libc::c_char);
+    assert!((((((c1 as u8) as i32) == (255)) as i32) != 0));
+    return 0;
+}
+pub unsafe fn __cpp2rust_init_globals() {}

tests/unit/signed_integer.c

@@ -0,0 +1,16 @@
+#include <assert.h>
+
+int main() {
+  int x1 = 0xFFFFFFFF;
+  assert(x1 == -1);
+  signed char x2 = 0xFF;
+  assert(x2 == -1);
+
+  unsigned int u1 = 5;
+  unsigned int u2 = -u1;
+  assert(u2 == 4294967291u);
+
+  char c1 = 0xFF;
+  assert((unsigned char)c1 == 0xFF);
+  return 0;
+}