Translate scopes (#326)

Each C++ scope:

```cpp
int foo() {
  int a;
  {
    int a;
  }
}
```

Becomes a proper Rust scope:

```rust
fn foo() {
  let a: i32;
  {
    let a: i32;
  }
}
```

Author: lucic71

cpp2rust/converter/converter.cpp

@@ -435,25 +435,17 @@ void Converter::ConvertGotoBlock(clang::CompoundStmt *body) {
 }
 
 void Converter::ConvertFunctionBody(clang::FunctionDecl *decl) {
-  if (auto compound = clang::dyn_cast<clang::CompoundStmt>(decl->getBody())) {
-    if (CompoundHasTopLevelLabel(compound)) {
-      ConvertGotoBlock(compound);
-      if (!decl->getReturnType()->isVoidType()) {
-        StrCat(R"(panic!("ub: non-void function does not return a value"))");
-      }
-      return;
-    }
+  ConvertBodyStmts(decl->getBody());
+  if (decl->getReturnType()->isVoidType()) {
+    return;
   }
-
-  Convert(decl->getBody());
-  if (!decl->getReturnType()->isVoidType()) {
-    if (auto compound = clang::dyn_cast<clang::CompoundStmt>(decl->getBody())) {
-      if (!compound->body_empty()) {
-        if (!clang::isa<clang::ReturnStmt>(compound->body_back())) {
-          StrCat(R"(panic!("ub: non-void function does not return a value"))");
-        }
-      }
-    }
+  auto compound = clang::dyn_cast<clang::CompoundStmt>(decl->getBody());
+  if (!compound || compound->body_empty()) {
+    return;
+  }
+  if (CompoundHasTopLevelLabel(compound) ||
+      !clang::isa<clang::ReturnStmt>(compound->body_back())) {
+    StrCat(R"(panic!("ub: non-void function does not return a value"))");
   }
 }
 
@@ -1057,7 +1049,7 @@ void Converter::ConvertCXXConstructorBody(clang::CXXConstructorDecl *decl) {
   }
 
   StrCat(token::kSemiColon);
-  Convert(decl->getBody());
+  ConvertBodyStmts(decl->getBody());
   StrCat("this");
 }
 
@@ -1127,14 +1119,28 @@ bool Converter::Convert(clang::Stmt *stmt) {
   return exited_visit;
 }
 
-bool Converter::VisitCompoundStmt(clang::CompoundStmt *stmt) {
-  if (CompoundHasTopLevelLabel(stmt)) {
-    ConvertGotoBlock(stmt);
-    return false;
+void Converter::ConvertBody(clang::Stmt *body) {
+  PushBrace brace(*this);
+  ConvertBodyStmts(body);
+}
+
+void Converter::ConvertBodyStmts(clang::Stmt *body) {
+  auto *compound = clang::dyn_cast_or_null<clang::CompoundStmt>(body);
+  if (!compound) {
+    Convert(body);
+    return;
   }
-  for (auto *child : stmt->body()) {
+  if (CompoundHasTopLevelLabel(compound)) {
+    ConvertGotoBlock(compound);
+    return;
+  }
+  for (auto *child : compound->body()) {
     Convert(child);
   }
+}
+
+bool Converter::VisitCompoundStmt(clang::CompoundStmt *stmt) {
+  ConvertBody(stmt);
   return false;
 }
 
@@ -1172,17 +1178,13 @@ void Converter::ConvertCondition(clang::Expr *cond) {
 bool Converter::VisitIfStmt(clang::IfStmt *stmt) {
   StrCat(keyword::kIf);
   ConvertCondition(stmt->getCond());
-  {
-    PushBrace brace(*this);
-    Convert(stmt->getThen());
-  }
+  ConvertBody(stmt->getThen());
   if (stmt->hasElseStorage()) {
     StrCat(keyword::kElse);
     if (clang::isa<clang::IfStmt>(stmt->getElse())) {
       Convert(stmt->getElse());
     } else {
-      PushBrace brace(*this);
-      Convert(stmt->getElse());
+      ConvertBody(stmt->getElse());
     }
   }
   return false;
@@ -1193,12 +1195,9 @@ bool Converter::VisitWhileStmt(clang::WhileStmt *stmt) {
   StrCat("'loop_:");
   StrCat(keyword::kWhile);
   ConvertCondition(stmt->getCond());
-  {
-    PushBrace brace(*this);
-    curr_for_inc_.emplace_back(nullptr);
-    Convert(stmt->getBody());
-    curr_for_inc_.pop_back();
-  }
+  curr_for_inc_.emplace_back(nullptr);
+  ConvertBody(stmt->getBody());
+  curr_for_inc_.pop_back();
   return false;
 }
 
@@ -1216,7 +1215,7 @@ bool Converter::VisitDoStmt(clang::DoStmt *stmt) {
     PushBrace loop_brace(*this);
     StrCat(control_var, token::kAssign, keyword::kFalse, token::kSemiColon);
     curr_for_inc_.emplace_back(nullptr);
-    Convert(stmt->getBody());
+    ConvertBodyStmts(stmt->getBody());
     curr_for_inc_.pop_back();
   }
   return false;
@@ -1235,7 +1234,7 @@ bool Converter::VisitForStmt(clang::ForStmt *stmt) {
   {
     PushBrace brace(*this);
     curr_for_inc_.emplace_back(stmt->getInc());
-    Convert(stmt->getBody());
+    ConvertBodyStmts(stmt->getBody());
     curr_for_inc_.pop_back();
     Convert(stmt->getInc());
     StrCat(token::kSemiColon);
@@ -1273,7 +1272,7 @@ void Converter::ConvertForRangeBody(clang::CXXForRangeStmt *stmt,
   if (map_iter_decl)
     skip.emplace(*this, map_iter_decl);
   curr_for_inc_.emplace_back(nullptr);
-  Convert(stmt->getBody());
+  ConvertBodyStmts(stmt->getBody());
   curr_for_inc_.pop_back();
 }
 

cpp2rust/converter/converter.h

@@ -86,6 +86,10 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
 
   void ConvertGotoBlock(clang::CompoundStmt *body);
 
+  void ConvertBody(clang::Stmt *body);
+
+  void ConvertBodyStmts(clang::Stmt *body);
+
   void EmitHoistedDecls(clang::CompoundStmt *body);
 
   virtual bool VisitFunctionTemplateDecl(clang::FunctionTemplateDecl *decl);

cpp2rust/converter/models/converter_refcount.cpp

@@ -585,9 +585,8 @@ void ConverterRefCount::AddDropTrait(const clang::CXXRecordDecl *decl) {
   auto record_name = GetRecordName(decl);
 
   StrCat(keyword::kImpl, "Drop for", record_name, '{');
-  StrCat("fn drop(&mut self) {");
-  Convert(body);
-  StrCat('}');
+  StrCat("fn drop(&mut self)");
+  ConvertBody(body);
   StrCat('}');
 }
 

tests/unit/nested_block_scope.cpp

@@ -0,0 +1,37 @@
+#include <assert.h>
+
+int main() {
+  int x = 1;
+  {
+    int x = 2;
+    assert(x == 2);
+    {
+      int x = 3;
+      assert(x == 3);
+    }
+    assert(x == 2);
+  }
+  assert(x == 1);
+
+  int sum = 0;
+  for (int i = 0; i < 3; i++) {
+    int y = i;
+    {
+      int y = 10;
+      sum += y;
+    }
+    sum += y;
+  }
+  assert(sum == 33);
+
+  if (x == 1) {
+    int x = 5;
+    {
+      int x = 6;
+      assert(x == 6);
+    }
+    assert(x == 5);
+  }
+  assert(x == 1);
+  return 0;
+}

tests/unit/out/refcount/nested_block_scope.rs

@@ -0,0 +1,46 @@
+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() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    let x: Value<i32> = Rc::new(RefCell::new(1));
+    {
+        let x: Value<i32> = Rc::new(RefCell::new(2));
+        assert!(((*x.borrow()) == 2));
+        {
+            let x: Value<i32> = Rc::new(RefCell::new(3));
+            assert!(((*x.borrow()) == 3));
+        }
+        assert!(((*x.borrow()) == 2));
+    }
+    assert!(((*x.borrow()) == 1));
+    let sum: Value<i32> = Rc::new(RefCell::new(0));
+    let i: Value<i32> = Rc::new(RefCell::new(0));
+    'loop_: while ((*i.borrow()) < 3) {
+        let y: Value<i32> = Rc::new(RefCell::new((*i.borrow())));
+        {
+            let y: Value<i32> = Rc::new(RefCell::new(10));
+            (*sum.borrow_mut()) += (*y.borrow());
+        }
+        (*sum.borrow_mut()) += (*y.borrow());
+        (*i.borrow_mut()).postfix_inc();
+    }
+    assert!(((*sum.borrow()) == 33));
+    if ((*x.borrow()) == 1) {
+        let x: Value<i32> = Rc::new(RefCell::new(5));
+        {
+            let x: Value<i32> = Rc::new(RefCell::new(6));
+            assert!(((*x.borrow()) == 6));
+        }
+        assert!(((*x.borrow()) == 5));
+    }
+    assert!(((*x.borrow()) == 1));
+    return 0;
+}

tests/unit/out/refcount/pointer_add_assign.rs

@@ -11,29 +11,45 @@ pub fn main() {
 }
 fn main_0() -> i32 {
     let arr: Value<Box<[u8]>> = Rc::new(RefCell::new(Box::new([1_u8, 2_u8, 3_u8])));
-    let p: Value<Ptr<u8>> = Rc::new(RefCell::new(((arr.as_pointer() as Ptr<u8>).offset(0))));
-    (*p.borrow_mut()) += (1_u8 as i32);
-    assert!(((((*p.borrow()).read()) as i32) == 2));
-    let p: Value<Ptr<u8>> = Rc::new(RefCell::new(((arr.as_pointer() as Ptr<u8>).offset(0))));
-    (*p.borrow_mut()) += (1_i8 as i32);
-    assert!(((((*p.borrow()).read()) as i32) == 2));
-    let p: Value<Ptr<u8>> = Rc::new(RefCell::new(((arr.as_pointer() as Ptr<u8>).offset(0))));
-    (*p.borrow_mut()) += (1_u16 as i32);
-    assert!(((((*p.borrow()).read()) as i32) == 2));
-    let p: Value<Ptr<u8>> = Rc::new(RefCell::new(((arr.as_pointer() as Ptr<u8>).offset(0))));
-    (*p.borrow_mut()) += (1_i16 as i32);
-    assert!(((((*p.borrow()).read()) as i32) == 2));
-    let p: Value<Ptr<u8>> = Rc::new(RefCell::new(((arr.as_pointer() as Ptr<u8>).offset(0))));
-    (*p.borrow_mut()) += 1_u32;
-    assert!(((((*p.borrow()).read()) as i32) == 2));
-    let p: Value<Ptr<u8>> = Rc::new(RefCell::new(((arr.as_pointer() as Ptr<u8>).offset(0))));
-    (*p.borrow_mut()) += (1 as i32);
-    assert!(((((*p.borrow()).read()) as i32) == 2));
-    let p: Value<Ptr<u8>> = Rc::new(RefCell::new(((arr.as_pointer() as Ptr<u8>).offset(0))));
-    (*p.borrow_mut()) += 1_u64;
-    assert!(((((*p.borrow()).read()) as i32) == 2));
-    let p: Value<Ptr<u8>> = Rc::new(RefCell::new(((arr.as_pointer() as Ptr<u8>).offset(0))));
-    (*p.borrow_mut()) += 1_i64;
-    assert!(((((*p.borrow()).read()) as i32) == 2));
+    {
+        let p: Value<Ptr<u8>> = Rc::new(RefCell::new(((arr.as_pointer() as Ptr<u8>).offset(0))));
+        (*p.borrow_mut()) += (1_u8 as i32);
+        assert!(((((*p.borrow()).read()) as i32) == 2));
+    }
+    {
+        let p: Value<Ptr<u8>> = Rc::new(RefCell::new(((arr.as_pointer() as Ptr<u8>).offset(0))));
+        (*p.borrow_mut()) += (1_i8 as i32);
+        assert!(((((*p.borrow()).read()) as i32) == 2));
+    }
+    {
+        let p: Value<Ptr<u8>> = Rc::new(RefCell::new(((arr.as_pointer() as Ptr<u8>).offset(0))));
+        (*p.borrow_mut()) += (1_u16 as i32);
+        assert!(((((*p.borrow()).read()) as i32) == 2));
+    }
+    {
+        let p: Value<Ptr<u8>> = Rc::new(RefCell::new(((arr.as_pointer() as Ptr<u8>).offset(0))));
+        (*p.borrow_mut()) += (1_i16 as i32);
+        assert!(((((*p.borrow()).read()) as i32) == 2));
+    }
+    {
+        let p: Value<Ptr<u8>> = Rc::new(RefCell::new(((arr.as_pointer() as Ptr<u8>).offset(0))));
+        (*p.borrow_mut()) += 1_u32;
+        assert!(((((*p.borrow()).read()) as i32) == 2));
+    }
+    {
+        let p: Value<Ptr<u8>> = Rc::new(RefCell::new(((arr.as_pointer() as Ptr<u8>).offset(0))));
+        (*p.borrow_mut()) += (1 as i32);
+        assert!(((((*p.borrow()).read()) as i32) == 2));
+    }
+    {
+        let p: Value<Ptr<u8>> = Rc::new(RefCell::new(((arr.as_pointer() as Ptr<u8>).offset(0))));
+        (*p.borrow_mut()) += 1_u64;
+        assert!(((((*p.borrow()).read()) as i32) == 2));
+    }
+    {
+        let p: Value<Ptr<u8>> = Rc::new(RefCell::new(((arr.as_pointer() as Ptr<u8>).offset(0))));
+        (*p.borrow_mut()) += 1_i64;
+        assert!(((((*p.borrow()).read()) as i32) == 2));
+    }
     return 0;
 }

tests/unit/out/refcount/stdcopy_ostream.rs

@@ -17,18 +17,20 @@ fn main_0() -> i32 {
             .collect::<Vec<u8>>(),
     ));
     let file: Value<Box<[u8]>> = Rc::new(RefCell::new(Box::from(*b"test_stdcopy_ostream.txt\0")));
-    let ofs: Value<::std::fs::File> = Rc::new(RefCell::new(
-        ::std::fs::File::create((file.as_pointer() as Ptr<u8>).to_string())
-            .expect("Failed to open file"),
-    ));
     {
-        (*ofs.borrow_mut()).write_all(
-            (str.as_pointer() as Ptr<u8>)
-                .slice_until(&(str.as_pointer() as Ptr<u8>).to_last())
-                .as_slice(),
-        );
-        (*ofs.borrow_mut()).try_clone().unwrap()
-    };
+        let ofs: Value<::std::fs::File> = Rc::new(RefCell::new(
+            ::std::fs::File::create((file.as_pointer() as Ptr<u8>).to_string())
+                .expect("Failed to open file"),
+        ));
+        {
+            (*ofs.borrow_mut()).write_all(
+                (str.as_pointer() as Ptr<u8>)
+                    .slice_until(&(str.as_pointer() as Ptr<u8>).to_last())
+                    .as_slice(),
+            );
+            (*ofs.borrow_mut()).try_clone().unwrap()
+        };
+    }
     match nix::unistd::unlink((file.as_pointer() as Ptr<u8>).to_rust_string().as_str()) {
         Ok(()) => 0,
         Err(__e) => {

tests/unit/out/refcount/switch_fallthrough_into_block.rs

@@ -14,9 +14,11 @@ pub fn fallthrough_into_block_0(x: i32) -> i32 {
             (*r.borrow_mut()) += 1;
         }
         __v if __v == 2 => {
-            let tmp: Value<i32> = Rc::new(RefCell::new(((*r.borrow()) * 10)));
-            (*r.borrow_mut()) = ((*tmp.borrow()) + 5);
-            break;
+            {
+                let tmp: Value<i32> = Rc::new(RefCell::new(((*r.borrow()) * 10)));
+                (*r.borrow_mut()) = ((*tmp.borrow()) + 5);
+                break;
+            }
         }
         _ => {
             (*r.borrow_mut()) = -1_i32;