Fix operator name collisions

Author: joaotgouveia

cpp2rust/converter/mapper.cpp

@@ -4,6 +4,7 @@
 #include "converter/mapper.h"
 
 #include <clang/AST/ExprCXX.h>
+#include <clang/Basic/OperatorKinds.h>
 #include <clang/Basic/SourceManager.h>
 #include <clang/Lex/Lexer.h>
 #include <llvm/Support/ThreadPool.h>
@@ -922,8 +923,30 @@ std::string ToString(const clang::NamedDecl *decl) {
   }
 
   os << ToString(func_decl->getReturnType()) << ' ';
-  if (const auto *method_decl =
-          llvm::dyn_cast<clang::CXXMethodDecl>(func_decl)) {
+  if (const auto op = func_decl->getOverloadedOperator();
+      op >= clang::OverloadedOperatorKind::OO_LessLess &&
+      op <= clang::OverloadedOperatorKind::OO_GreaterGreaterEqual) {
+    // ensure matchTemplate does not consider these operator names when matching
+    func_decl->getQualifier().print(os, getPrintPolicy());
+    os << "operator ";
+    switch (op) {
+    case clang::OverloadedOperatorKind::OO_LessLess:
+      os << "shl";
+      break;
+    case clang::OverloadedOperatorKind::OO_GreaterGreater:
+      os << "shr";
+      break;
+    case clang::OverloadedOperatorKind::OO_LessLessEqual:
+      os << "shleq";
+      break;
+    case clang::OverloadedOperatorKind::OO_GreaterGreaterEqual:
+      os << "shreq";
+      break;
+    default:
+      std::unreachable();
+    }
+  } else if (const auto *method_decl =
+                 llvm::dyn_cast<clang::CXXMethodDecl>(func_decl)) {
     if (method_decl->getParent()->isLambda() &&
         method_decl->getOverloadedOperator() == clang::OO_Call) {
       func_decl->printName(os, getPrintPolicy());

rules/bitset/src.cpp

@@ -0,0 +1,26 @@
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
+#include <bitset>
+
+template <std::size_t T1> using t1 = std::bitset<T1>;
+
+template <std::size_t T1> std::bitset<T1> f1() { return std::bitset<T1>(); }
+
+template <std::size_t T1> std::bitset<T1> f2(unsigned long long a0) {
+  return std::bitset<T1>(a0);
+}
+
+template <std::size_t T1>
+std::bitset<T1> f3(const std::bitset<T1> &a0, std::size_t a1) {
+  return a0.operator<<(a1);
+}
+
+template <std::size_t T1>
+std::bitset<T1> f4(const std::bitset<T1> &a0, std::size_t a1) {
+  return a0.operator>>(a1);
+}
+
+template <std::size_t T1> unsigned long f5(const std::bitset<T1> &a0) {
+  return a0.to_ulong();
+}

rules/bitset/tgt_unsafe.rs

@@ -0,0 +1,28 @@
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
+fn t1() -> Vec<bool> {
+    Vec::new()
+}
+
+fn f1() -> Vec<bool> {
+    Vec::new()
+}
+
+fn f2(a0: u64) -> Vec<bool> {
+    (0..u64::BITS).map(|i| (a0 >> i) & 1 == 1).collect()
+}
+
+fn f3(a0: Vec<bool>, a1: usize) -> Vec<bool> {
+    let mut bits = vec![false; a1];
+    bits.extend(a0.iter());
+    bits
+}
+
+fn f4(a0: Vec<bool>, a1: usize) -> Vec<bool> {
+    a0.iter().skip(a1).copied().collect()
+}
+
+fn f5(a0: Vec<bool>) -> u64 {
+    a0.iter().rev().fold(0u64, |acc, &b| (acc << 1) | b as u64)
+}

rules/src/modules.rs

@@ -14,6 +14,8 @@ pub mod array_tgt_unsafe;
 pub mod assert_tgt_refcount;
 #[path = r#"../assert/tgt_unsafe.rs"#]
 pub mod assert_tgt_unsafe;
+#[path = r#"../bitset/tgt_unsafe.rs"#]
+pub mod bitset_tgt_unsafe;
 #[path = r#"../brotli/tgt_refcount.rs"#]
 pub mod brotli_tgt_refcount;
 #[path = r#"../brotli/tgt_unsafe.rs"#]

tests/unit/bitset.cpp

@@ -0,0 +1,17 @@
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
+#include <bitset>
+#include <cassert>
+
+int main() {
+  std::bitset<16> b1(5);
+  std::bitset<16> b2 = b1 << 2;
+  std::bitset<16> b3 = b2 >> 1;
+
+  assert(b1.to_ulong() == 5);
+  assert(b2.to_ulong() == 20);
+  assert(b3.to_ulong() == 10);
+
+  return 0;
+}

tests/unit/out/refcount/bitset.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 b1: Value<Vec<bool>> = Rc::new(RefCell::new(
+        (0..u64::BITS).map(|i| (5_u64 >> i) & 1 == 1).collect(),
+    ));
+    let b2: Value<Vec<bool>> = Rc::new(RefCell::new({
+        let mut bits = vec![false; 2_usize];
+        bits.extend((*b1.borrow()).iter());
+        bits
+    }));
+    let b3: Value<Vec<bool>> = Rc::new(RefCell::new(
+        (*b2.borrow()).iter().skip(1_usize).copied().collect(),
+    ));
+    assert!(
+        ((*b1.borrow())
+            .iter()
+            .rev()
+            .fold(0u64, |acc, &b| (acc << 1) | b as u64)
+            == 5_u64)
+    );
+    assert!(
+        ((*b2.borrow())
+            .iter()
+            .rev()
+            .fold(0u64, |acc, &b| (acc << 1) | b as u64)
+            == 20_u64)
+    );
+    assert!(
+        ((*b3.borrow())
+            .iter()
+            .rev()
+            .fold(0u64, |acc, &b| (acc << 1) | b as u64)
+            == 10_u64)
+    );
+    return 0;
+}

tests/unit/out/unsafe/bitset.rs

@@ -0,0 +1,26 @@
+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 {
+        std::process::exit(main_0() as i32);
+    }
+}
+unsafe fn main_0() -> i32 {
+    let mut b1: Vec<bool> = (0..u64::BITS).map(|i| (5_u64 >> i) & 1 == 1).collect();
+    let mut b2: Vec<bool> = {
+        let mut bits = vec![false; 2_usize];
+        bits.extend(b1.iter());
+        bits
+    };
+    let mut b3: Vec<bool> = b2.iter().skip(1_usize).copied().collect();
+    assert!(((b1.iter().rev().fold(0u64, |acc, &b| (acc << 1) | b as u64)) == (5_u64)));
+    assert!(((b2.iter().rev().fold(0u64, |acc, &b| (acc << 1) | b as u64)) == (20_u64)));
+    assert!(((b3.iter().rev().fold(0u64, |acc, &b| (acc << 1) | b as u64)) == (10_u64)));
+    return 0;
+}