Update tests

Author: lucic71

cpp2rust/converter/converter.cpp

@@ -9,6 +9,7 @@
 #include <llvm/Support/ConvertUTF.h>
 
 #include <format>
+#include <utility>
 
 #include "compiler.h"
 #include "converter/converter_lib.h"
@@ -1060,7 +1061,7 @@ void Converter::ConvertLoopVariable(clang::VarDecl *decl,
     }
   } else {
     {
-      PushAutorefReceiver autoref(*this, /*is_mut=*/false);
+      PushExplicitAutoref autoref(*this, /*is_mut=*/false);
       Convert(range_init);
     }
     StrCat(std::format("[{}]", loop_var_name));
@@ -2224,20 +2225,22 @@ bool Converter::VisitConditionalOperator(clang::ConditionalOperator *expr) {
   bool branch_is_addr =
       expr->isLValue() && !isRValue() && !expr->getType()->isFunctionType();
   {
-    PushBrace then_brace(*this);
+    PushBrace brace(*this);
     if (branch_is_addr) {
       StrCat(token::kRef, keyword_mut_);
-      autoref_receiver_ = false;
     }
+    PushExplicitAutoref no_autoref(*this, branch_is_addr ? std::optional<bool>{}
+                                                         : autoref_mut_);
     Convert(expr->getTrueExpr());
   }
   StrCat(keyword::kElse);
   {
-    PushBrace else_brace(*this);
+    PushBrace brace(*this);
     if (branch_is_addr) {
       StrCat(token::kRef, keyword_mut_);
-      autoref_receiver_ = false;
     }
+    PushExplicitAutoref no_autoref(*this, branch_is_addr ? std::optional<bool>{}
+                                                         : autoref_mut_);
     Convert(expr->getFalseExpr());
   }
   return false;
@@ -2292,8 +2295,7 @@ bool Converter::VisitDeclRefExpr(clang::DeclRefExpr *expr) {
 
   if (decl->getType()->getAs<clang::ReferenceType>() && !isAddrOf() &&
       !map_iter_decls_.contains(clang::dyn_cast<clang::VarDecl>(decl))) {
-    EmitMaybeWrappedDeref(std::move(str),
-                          decl->getType().getNonReferenceType());
+    EmitDeref(std::move(str), decl->getType().getNonReferenceType());
     SetValueFreshness(expr->getType());
     return false;
   }
@@ -2373,7 +2375,7 @@ bool Converter::ConvertCXXOperatorCallExpr(clang::CXXOperatorCallExpr *expr) {
         is_mut = !method->isConst();
       }
     }
-    PushAutorefReceiver autoref(*this, is_mut);
+    PushExplicitAutoref autoref(*this, is_mut);
     ConvertArraySubscript(expr->getArg(0), expr->getArg(1), expr->getType());
     break;
   }
@@ -2442,8 +2444,7 @@ bool Converter::VisitMemberExpr(clang::MemberExpr *expr) {
   }
 
   if (!isAddrOf() && member->getType()->isReferenceType()) {
-    EmitMaybeWrappedDeref(std::move(str),
-                          member->getType().getNonReferenceType());
+    EmitDeref(std::move(str), member->getType().getNonReferenceType());
     return false;
   }
 
@@ -2471,19 +2472,18 @@ void Converter::ConvertMemberExpr(clang::MemberExpr *expr) {
   auto *base = expr->getBase();
   bool base_is_this = clang::isa<clang::CXXThisExpr>(base->IgnoreCasts());
   PushExprKind push(*this, isLValue() ? ExprKind::LValue : ExprKind::RValue);
-  std::optional<PushAutorefReceiver> autoref;
-  if (auto *method = clang::dyn_cast<clang::CXXMethodDecl>(member);
-      method && !method->isStatic() && isCallee() && !base_is_this) {
-    autoref.emplace(*this, !method->isConst());
-  }
+  auto *method = clang::dyn_cast<clang::CXXMethodDecl>(member);
+  PushExplicitAutoref autoref(*this, method && !method->isStatic() &&
+                                             isCallee() && !base_is_this
+                                         ? std::optional{!method->isConst()}
+                                         : autoref_mut_);
   if (expr->isArrow() && !base_is_this) {
     ConvertArrow(base);
   } else {
     Convert(base);
   }
 
-  if (auto *method = clang::dyn_cast<clang::CXXMethodDecl>(member);
-      method && IsOverloadedMethod(method)) {
+  if (method && IsOverloadedMethod(method)) {
     StrCat(token::kDot);
     StrCat(GetOverloadedFunctionName(method));
   } else {
@@ -3217,15 +3217,14 @@ void Converter::ConvertPointerOffset(clang::Expr *base, clang::Expr *idx,
 
 void Converter::ConvertArraySubscript(clang::Expr *base, clang::Expr *idx,
                                       clang::QualType type) {
-  bool is_unique_ptr = IsUniquePtr(base->getType());
-  if (is_unique_ptr) {
-    autoref_receiver_ = false;
-  }
-  Convert(base->IgnoreImplicit());
-  if (is_unique_ptr) {
+  if (IsUniquePtr(base->getType())) {
+    PushExplicitAutoref no_autoref(*this, std::nullopt);
+    Convert(base->IgnoreImplicit());
     StrCat(".as_mut().unwrap()");
+  } else {
+    Convert(base->IgnoreImplicit());
   }
-  autoref_receiver_ = false;
+  PushExplicitAutoref no_autoref(*this, std::nullopt);
   PushBracket bracket(*this);
   {
     PushParen paren(*this);
@@ -3531,26 +3530,19 @@ void Converter::ConvertAddrOf(clang::Expr *expr, clang::QualType pointer_type) {
   }
 }
 
-void Converter::EmitMaybeWrappedDeref(std::string inner,
-                                      clang::QualType pointee_type) {
-  bool wrap = autoref_receiver_;
-  bool wrap_mut = autoref_receiver_mut_;
-  autoref_receiver_ = false;
+void Converter::EmitDeref(std::string inner, clang::QualType pointee_type) {
+  auto wrap = std::exchange(autoref_mut_, std::nullopt);
+  PushParen outer(*this, wrap.has_value());
   if (wrap) {
-    StrCat("(", wrap_mut ? "&mut " : "&");
-  }
-  {
-    PushParen paren(*this);
-    StrCat(GetPointerDerefPrefix(pointee_type), std::move(inner));
-  }
-  if (wrap) {
-    StrCat(")");
+    StrCat(*wrap ? "&mut" : "&");
   }
+  PushParen paren(*this);
+  StrCat(GetPointerDerefPrefix(pointee_type), std::move(inner));
 }
 
 void Converter::ConvertDeref(clang::Expr *expr) {
   if (!isAddrOf()) {
-    EmitMaybeWrappedDeref(ToString(expr), expr->getType()->getPointeeType());
+    EmitDeref(ToString(expr), expr->getType()->getPointeeType());
   } else {
     Convert(expr);
   }

cpp2rust/converter/converter.h

@@ -474,7 +474,7 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
 
   virtual void ConvertDeref(clang::Expr *expr);
 
-  void EmitMaybeWrappedDeref(std::string inner, clang::QualType pointee_type);
+  void EmitDeref(std::string inner, clang::QualType pointee_type);
 
   virtual void ConvertArrow(clang::Expr *expr);
 
@@ -517,23 +517,16 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
   clang::ASTContext &ctx_;
   clang::FunctionDecl *curr_function_ = nullptr;
   bool in_function_formals_ = false;
-  bool autoref_receiver_ = false;
-  bool autoref_receiver_mut_ = false;
+  std::optional<bool> autoref_mut_;
 
-  struct PushAutorefReceiver {
+  struct PushExplicitAutoref {
     Converter &c;
-    bool prev_active;
-    bool prev_mut;
-    PushAutorefReceiver(Converter &c, bool is_mut)
-        : c(c), prev_active(c.autoref_receiver_),
-          prev_mut(c.autoref_receiver_mut_) {
-      c.autoref_receiver_ = true;
-      c.autoref_receiver_mut_ = is_mut;
-    }
-    ~PushAutorefReceiver() {
-      c.autoref_receiver_ = prev_active;
-      c.autoref_receiver_mut_ = prev_mut;
+    std::optional<bool> prev;
+    PushExplicitAutoref(Converter &c, std::optional<bool> v)
+        : c(c), prev(c.autoref_mut_) {
+      c.autoref_mut_ = v;
     }
+    ~PushExplicitAutoref() { c.autoref_mut_ = prev; }
   };
   std::stack<clang::Expr *> curr_for_inc_;
   std::stack<clang::QualType> curr_init_type_;

tests/lit/lit/formats/Cpp2RustTest.py

@@ -29,7 +29,7 @@ def __init__(self):
     self.regex_translation_fail = re.compile(r"//\s*translation-fail\s*(?::\s*(.*))?$", re.MULTILINE)
     self.regex_nondet_result = re.compile(r"//\s*nondet-result\s*(?::\s*(.*))?$", re.MULTILINE)
     self.rust_version = read_rust_version()
-    os.environ['RUSTFLAGS'] = '-Awarnings -A dangerous-implicit-autorefs'
+    os.environ['RUSTFLAGS'] = '-Awarnings'
 
   def updateExpected(self, generated, expected_path):
     os.makedirs(os.path.dirname(expected_path), exist_ok=True)

tests/unit/out/unsafe/vector2.rs

@@ -14,15 +14,15 @@ pub unsafe fn fn_0(v: *mut Vec<i32>, mut v3: Vec<i32>) {
     v2.push(0);
     v2.push(1);
     v2.push(3);
-    x = (*v)[(2_u64) as usize];
+    x = (&mut (*v))[(2_u64) as usize];
     v2[(0_u64) as usize] = 1;
     (if true { &mut v3 } else { &mut (*v) })[(0_u64) as usize] = 7;
     v2 = (*v).clone();
-    (*v4)[(1_u64) as usize] = 13;
+    (&mut (*v4))[(1_u64) as usize] = 13;
     assert!(((x) == (6)));
     assert!(((*((*v).first_mut().unwrap())) == (4)));
-    assert!((((*v)[(1_u64) as usize]) == (5)));
-    assert!((((*v)[(2_u64) as usize]) == (6)));
+    assert!((((&mut (*v))[(1_u64) as usize]) == (5)));
+    assert!((((&mut (*v))[(2_u64) as usize]) == (6)));
     assert!(((*((*v).last_mut().unwrap())) == (20)));
     assert!(((v2[(0_u64) as usize]) == (4)));
     assert!(((v2[(1_u64) as usize]) == (5)));

tests/unit/out/unsafe/vector3.rs

@@ -35,7 +35,7 @@ unsafe fn main_0() -> i32 {
     'loop_: for v2 in 0..(v.len()) {
         let mut v2 = v.as_mut_ptr().add(v2);
         'loop_: for i in 0..((*v2).len()) {
-            let mut i = (*v2)[i].clone();
+            let mut i = (&(*v2))[i].clone();
             printf(b"%d\n\0".as_ptr() as *const i8, ((i) + (3)));
         }
     }