Translate functional casts

Author: lucic71

cpp2rust/converter/converter.cpp

@@ -2579,6 +2579,13 @@ bool Converter::VisitExplicitCastExpr(clang::ExplicitCastExpr *expr) {
     return false;
   }
   switch (expr->getStmtClass()) {
+  case clang::Stmt::CXXFunctionalCastExprClass:
+    if (type->isEnumeralType() && !sub_expr->getType()->isEnumeralType()) {
+      ConvertIntegerToEnumeralCast(expr, sub_expr);
+      return false;
+    }
+    Convert(sub_expr, type);
+    return false;
   case clang::Stmt::CXXReinterpretCastExprClass:
   case clang::Stmt::CXXStaticCastExprClass:
   case clang::Stmt::CStyleCastExprClass:

cpp2rust/converter/models/converter_refcount.cpp

@@ -1482,6 +1482,8 @@ bool ConverterRefCount::VisitExplicitCastExpr(clang::ExplicitCastExpr *expr) {
       return false;
     }
     return Converter::VisitExplicitCastExpr(expr);
+  case clang::Stmt::CXXFunctionalCastExprClass:
+    return Converter::VisitExplicitCastExpr(expr);
   default:
     return Convert(expr->getSubExpr());
   }

tests/unit/cast.cpp

@@ -1,8 +1,21 @@
 #include <cassert>
 #include <cstdlib>
 
+enum E { A, B, C };
+
 int main() {
   size_t size = 1;
   assert(size == 1);
+
+  unsigned long ul = 5;
+  size_t s1 = size_t(ul);
+  assert(s1 == 5);
+  ul = (unsigned long)size_t(7);
+  assert(ul == 7);
+
+  int i = 2;
+  E e = E(i);
+  assert(e == C);
+  assert(int(e) == 2);
   return 0;
 }

tests/unit/out/refcount/byte.rs

@@ -14,24 +14,24 @@ fn main_0() -> i32 {
     let b1: Value<u8> = Rc::new(RefCell::new(1_u8));
     let ushift1: Value<u32> = Rc::new(RefCell::new(3_u32));
     let shl1: Value<u8> = Rc::new(RefCell::new((*b1.borrow()) << (*ushift1.borrow())));
-    assert!(((*shl1.borrow()) == 8));
+    assert!(((*shl1.borrow()) == ((8) as u8)));
     let ushift2: Value<u32> = Rc::new(RefCell::new(2_u32));
     let shr1: Value<u8> = Rc::new(RefCell::new((*shl1.borrow()) >> (*ushift2.borrow())));
-    assert!(((*shr1.borrow()) == 2));
+    assert!(((*shr1.borrow()) == ((2) as u8)));
     let ushift3: Value<u32> = Rc::new(RefCell::new(5_u32));
     {
         let n_ = (*b1.borrow()) << (*ushift3.borrow());
         (*b1.borrow_mut()) = n_;
         (*b1.borrow())
     };
-    assert!(((*b1.borrow()) == 32));
+    assert!(((*b1.borrow()) == ((32) as u8)));
     let ushift4: Value<u32> = Rc::new(RefCell::new(3_u32));
     {
         let n_ = (*b1.borrow()) >> (*ushift4.borrow());
         (*b1.borrow_mut()) = n_;
         (*b1.borrow())
     };
-    assert!(((*b1.borrow()) == 4));
+    assert!(((*b1.borrow()) == ((4) as u8)));
     return 0;
 }
 pub fn __cpp2rust_init_globals() {}

tests/unit/out/refcount/cast.rs

@@ -6,13 +6,26 @@ use std::io::prelude::*;
 use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
+pub type E = u32;
+pub const E_A: E = 0;
+pub const E_B: E = 1;
+pub const E_C: E = 2;
 pub fn main() {
     __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
     let size: Value<usize> = Rc::new(RefCell::new(1_usize));
     assert!(((*size.borrow()) == 1_usize));
+    let ul: Value<u64> = Rc::new(RefCell::new(5_u64));
+    let s1: Value<usize> = Rc::new(RefCell::new(((*ul.borrow()) as usize)));
+    assert!(((*s1.borrow()) == 5_usize));
+    (*ul.borrow_mut()) = (7_usize as u64);
+    assert!(((*ul.borrow()) == 7_u64));
+    let i: Value<i32> = Rc::new(RefCell::new(2));
+    let e: Value<E> = Rc::new(RefCell::new(((*i.borrow()) as E)));
+    assert!((((*e.borrow()) as i32) == (E_C as i32)));
+    assert!((((*e.borrow()) as i32) == 2));
     return 0;
 }
 pub fn __cpp2rust_init_globals() {}

tests/unit/out/unsafe/byte.rs

@@ -16,24 +16,24 @@ unsafe fn main_0() -> i32 {
     let mut b1: u8 = 1_u8;
     let mut ushift1: u32 = 3_u32;
     let mut shl1: u8 = b1 << ushift1;
-    assert!(((shl1) == (8)));
+    assert!(((shl1) == ((8) as u8)));
     let mut ushift2: u32 = 2_u32;
     let mut shr1: u8 = shl1 >> ushift2;
-    assert!(((shr1) == (2)));
+    assert!(((shr1) == ((2) as u8)));
     let mut ushift3: u32 = 5_u32;
     {
         let n_ = b1 << ushift3;
         b1 = n_;
         b1
     };
-    assert!(((b1) == (32)));
+    assert!(((b1) == ((32) as u8)));
     let mut ushift4: u32 = 3_u32;
     {
         let n_ = b1 >> ushift4;
         b1 = n_;
         b1
     };
-    assert!(((b1) == (4)));
+    assert!(((b1) == ((4) as u8)));
     return 0;
 }
 pub unsafe fn __cpp2rust_init_globals() {}

tests/unit/out/unsafe/cast.rs

@@ -6,6 +6,10 @@ use std::collections::BTreeMap;
 use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
+pub type E = u32;
+pub const E_A: E = 0;
+pub const E_B: E = 1;
+pub const E_C: E = 2;
 pub fn main() {
     unsafe {
         __cpp2rust_init_globals();
@@ -15,6 +19,15 @@ pub fn main() {
 unsafe fn main_0() -> i32 {
     let mut size: usize = 1_usize;
     assert!(((size) == (1_usize)));
+    let mut ul: u64 = 5_u64;
+    let mut s1: usize = (ul as usize);
+    assert!(((s1) == (5_usize)));
+    ul = (7_usize as u64);
+    assert!(((ul) == (7_u64)));
+    let mut i: i32 = 2;
+    let mut e: E = ((i) as E);
+    assert!(((e as i32) == (E_C as i32)));
+    assert!(((e as i32) == (2)));
     return 0;
 }
 pub unsafe fn __cpp2rust_init_globals() {}