Add inline attribute on inline-able methods

cpp2rust/converter/converter.cpp

@@ -402,7 +402,7 @@ bool Converter::VisitFunctionDecl(clang::FunctionDecl *decl) {
   }
   // main_0 should be static
   if (!decl->isMain()) {
-    StrCat(AccessSpecifierAsString(decl->getAccess()));
+    StrCat(InlineAttribute(decl), AccessSpecifierAsString(decl->getAccess()));
   }
   StrCat(keyword_unsafe_, keyword::kFn, std::move(function_name));
   {
@@ -1143,11 +1143,20 @@ Converter::GetConversionName(const clang::CXXConversionDecl *decl) const {
                                                  : name;
 }
 
+std::string Converter::InlineAttribute(const clang::FunctionDecl *decl) {
+  return decl->isInlined() && decl->doesThisDeclarationHaveABody()
+             ? "#[inline] "
+             : "";
+}
+
 bool Converter::ConvertCXXMethodDecl(clang::CXXMethodDecl *decl) {
   if (auto *ctor = clang::dyn_cast<clang::CXXConstructorDecl>(decl)) {
     return VisitCXXConstructorDecl(ctor);
   }
 
+  if (method_target_ != MethodTarget::TraitDecl) {
+    StrCat(InlineAttribute(decl));
+  }
   if (method_target_ == MethodTarget::ValueImpl &&
       (decl->isStatic() ||
        (!decl->isVirtual() && !decl->getParent()->isAbstract()))) {
@@ -1204,8 +1213,8 @@ bool Converter::VisitCXXConstructorDecl(clang::CXXConstructorDecl *decl) {
     return false;
   }
 
-  StrCat(AccessSpecifierAsString(decl->getAccess()), keyword_unsafe_,
-         keyword::kFn, GetCtorName(decl));
+  StrCat(InlineAttribute(decl), AccessSpecifierAsString(decl->getAccess()),
+         keyword_unsafe_, keyword::kFn, GetCtorName(decl));
   {
     PushParen paren(*this);
     ConvertFunctionParameters(decl);

cpp2rust/converter/converter.h

@@ -197,6 +197,8 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
 
   virtual bool ConvertOutOfLineMethod(clang::CXXMethodDecl *decl);
 
+  std::string InlineAttribute(const clang::FunctionDecl *decl);
+
   bool ConvertCXXMethodDecl(clang::CXXMethodDecl *decl);
 
   std::string GetMethodName(const clang::CXXMethodDecl *decl);

tests/multi-file/defaulted_move_cross_tu/out/refcount/defaulted_move_cross_tu.rs

@@ -18,12 +18,14 @@ pub struct S {
     pub n: Box<[i32]>,
 }
 impl S {
+    #[inline]
     pub fn new(mut x: i32) -> Self {
         Self {
             v: vec![x; (x as usize) as usize],
             n: Box::new([x, (x + 1)]),
         }
     }
+    #[inline]
     pub fn move_from(_a0: Ptr<S>) -> Self {
         Self {
             v: field!(_a0, v).with_mut(std::mem::take),
@@ -51,6 +53,7 @@ pub struct T {
     pub v: Vec<i32>,
 }
 impl T {
+    #[inline]
     pub fn move_from(_a0: Ptr<T>) -> Self {
         Self {
             v: field!(_a0, v).with_mut(std::mem::take),
@@ -96,6 +99,7 @@ pub trait SImpl {
     fn move_assign(&self, _a0: Ptr<S>) -> Ptr<S>;
 }
 impl SImpl for Ptr<S> {
+    #[inline]
     fn move_assign(&self, _a0: Ptr<S>) -> Ptr<S> {
         field_ref!((*self), v)
             .as_pointer()
@@ -117,9 +121,11 @@ pub trait TImpl {
     fn move_assign(&self, _a0: Ptr<T>) -> Ptr<T>;
 }
 impl TImpl for Ptr<T> {
+    #[inline]
     fn size(&self) -> i32 {
         return ((*(*self).upgrade().deref()).v.len() as i32);
     }
+    #[inline]
     fn move_assign(&self, _a0: Ptr<T>) -> Ptr<T> {
         field_ref!((*self), v)
             .as_pointer()

tests/multi-file/defaulted_move_cross_tu/out/unsafe/defaulted_move_cross_tu.rs

@@ -14,20 +14,23 @@ pub struct S {
     pub n: [i32; 2],
 }
 impl S {
+    #[inline]
     pub unsafe fn new(mut x: i32) -> Self {
         let mut this = Self {
             v: vec![x; (x as usize) as usize],
             n: [x, ((x) + (1))],
         };
         this
     }
+    #[inline]
     pub unsafe fn move_from(_a0: *mut S) -> Self {
         let mut this = Self {
             v: std::mem::take(&mut (*_a0).v),
             n: std::array::from_fn::<_, 2, _>(|__i: usize| (*_a0).n[(__i)]),
         };
         this
     }
+    #[inline]
     pub unsafe fn move_assign(&mut self, _a0: *mut S) -> *mut S {
         self.v = std::mem::take(&mut (*_a0).v);
         match (
@@ -50,15 +53,18 @@ pub struct T {
     pub v: Vec<i32>,
 }
 impl T {
+    #[inline]
     pub unsafe fn size(&self) -> i32 {
         return (self.v.len() as i32);
     }
+    #[inline]
     pub unsafe fn move_from(_a0: *mut T) -> Self {
         let mut this = Self {
             v: std::mem::take(&mut (*_a0).v),
         };
         this
     }
+    #[inline]
     pub unsafe fn move_assign(&mut self, _a0: *mut T) -> *mut T {
         self.v = std::mem::take(&mut (*_a0).v);
         return &mut (*(self as *mut T));

tests/multi-file/out_of_line_methods_cross_tu/out/refcount/out_of_line_methods_cross_tu.rs

@@ -31,6 +31,7 @@ pub struct Pair {
     #[offset(4)]
     pub second: i32,
 }
+#[inline]
 pub fn pair_diff_0(mut p: Ptr<Pair>) -> i32 {
     return ({ p.with(|__s| __s.first) } - { p.with(|__s| __s.second) });
 }
@@ -88,6 +89,7 @@ pub trait SImpl {
     }
 }
 impl SImpl for Ptr<S> {
+    #[inline]
     fn get(&self) -> i32 {
         return (*self).with(|__s| __s.v);
     }

tests/multi-file/out_of_line_methods_cross_tu/out/unsafe/out_of_line_methods_cross_tu.rs

@@ -12,6 +12,7 @@ pub struct S {
     pub v: i32,
 }
 impl S {
+    #[inline]
     pub unsafe fn get(&self) -> i32 {
         return self.v;
     }
@@ -31,6 +32,7 @@ pub struct Pair {
     pub first: i32,
     pub second: i32,
 }
+#[inline]
 pub unsafe fn pair_diff_0(mut p: *const Pair) -> i32 {
     return (((*p).first) - ((*p).second));
 }

tests/multi-file/template_method_late_instantiation/out/refcount/template_method_late_instantiation.rs

@@ -37,9 +37,11 @@ pub trait S_int_Impl {
     }
 }
 impl S_int_Impl for Ptr<S_int_> {
+    #[inline]
     fn set(&self, mut v: i32) {
         field!((*self), x).write(v);
     }
+    #[inline]
     fn get(&self) -> i32 {
         return (*self).with(|__s| __s.x);
     }

tests/multi-file/template_method_late_instantiation/out/unsafe/template_method_late_instantiation.rs

@@ -12,6 +12,7 @@ pub struct S_int_ {
     pub x: i32,
 }
 impl S_int_ {
+    #[inline]
     pub unsafe fn set(&mut self, mut v: i32) {
         self.x = v;
     }
@@ -34,6 +35,7 @@ unsafe fn main_0() -> i32 {
     return 0;
 }
 impl S_int_ {
+    #[inline]
     pub unsafe fn get(&mut self) -> i32 {
         return self.x;
     }

tests/ub/out/refcount/ctor_ref_member.rs

@@ -15,6 +15,7 @@ pub struct S {
     pub r: Ptr<i32>,
 }
 impl S {
+    #[inline]
     pub fn new(x: Ptr<i32>) -> Self {
         Self { r: (x).clone() }
     }

tests/ub/out/unsafe/ctor_ref_member.rs

@@ -13,6 +13,7 @@ pub struct S {
     pub r: *const i32,
 }
 impl S {
+    #[inline]
     pub unsafe fn new(x: *const i32) -> Self {
         let mut this = Self { r: x };
         this

tests/unit/inline_functions.cpp

@@ -0,0 +1,65 @@
+#include <cassert>
+
+inline int inlined_free(int a) { return a + 1; }
+
+constexpr int inlined_constexpr_free(int a) { return a + 2; }
+
+inline int inlined_declared_free(int a);
+
+int inlined_declared_free(int a) { return a + 3; }
+
+int not_inlined_free(int a) { return a + 4; }
+
+static int not_inlined_static_free(int a) { return a + 5; }
+
+class Base {
+public:
+  virtual int inlined_override(int a) const = 0;
+};
+
+class Derived : public Base {
+public:
+  explicit Derived(int v) : v_(v) {}
+
+  int inlined_override(int a) const override { return v_ + a; }
+
+  int inlined_in_class() const { return v_ * 2; }
+
+  static int inlined_static_in_class(int a) { return a * 3; }
+
+  inline int inlined_declared_in_class() const;
+
+  int inlined_defined_out_of_line() const;
+
+  int not_inlined_out_of_line() const;
+
+  static int not_inlined_static_out_of_line(int a);
+
+private:
+  int v_;
+};
+
+int Derived::inlined_declared_in_class() const { return v_ * 4; }
+
+inline int Derived::inlined_defined_out_of_line() const { return v_ * 5; }
+
+int Derived::not_inlined_out_of_line() const { return v_ * 6; }
+
+int Derived::not_inlined_static_out_of_line(int a) { return a * 7; }
+
+int main() {
+  Derived d(3);
+  assert(inlined_free(1) == 2);
+  assert(inlined_constexpr_free(1) == 3);
+  assert(inlined_declared_free(1) == 4);
+  assert(not_inlined_free(1) == 5);
+  assert(not_inlined_static_free(1) == 6);
+  assert(d.inlined_override(1) == 4);
+  assert(d.inlined_in_class() == 6);
+  assert(Derived::inlined_static_in_class(2) == 6);
+  assert(d.inlined_declared_in_class() == 12);
+  assert(d.inlined_defined_out_of_line() == 15);
+  assert(d.not_inlined_out_of_line() == 18);
+  assert(Derived::not_inlined_static_out_of_line(2) == 14);
+  return 0;
+}

tests/unit/out/refcount/05_new.rs

@@ -34,6 +34,7 @@ pub trait DImpl {
     fn operator_call(&self, ptr: Ptr<A>);
 }
 impl DImpl for Ptr<D> {
+    #[inline]
     fn operator_call(&self, mut ptr: Ptr<A>) {
         ptr.delete();
     }

tests/unit/out/refcount/10_struct.rs

@@ -32,6 +32,7 @@ pub struct Partial {
     pub p: Ptr<i32>,
 }
 impl Partial {
+    #[inline]
     pub fn new_1(mut q: Ptr<i32>) -> Self {
         Self { p: (q).clone() }
     }
@@ -89,6 +90,7 @@ pub trait GraphImpl {
     fn push(&self, src: u32, dst: u32);
 }
 impl GraphImpl for Ptr<Graph> {
+    #[inline]
     fn push(&self, mut src: u32, mut dst: u32) {
         let __rhs = Ptr::alloc(GraphNode {
             dst: dst,

tests/unit/out/refcount/any.rs

@@ -15,6 +15,7 @@ pub struct Point {
     pub y: i32,
 }
 impl Point {
+    #[inline]
     pub fn new(mut x: i32, mut y: i32) -> Self {
         Self { x: x, y: y }
     }

tests/unit/out/refcount/array_of_noncopy_struct.rs

@@ -16,6 +16,7 @@ pub struct NonCopy {
     pub tag: i32,
 }
 impl NonCopy {
+    #[inline]
     pub fn move_from(_a0: Ptr<NonCopy>) -> Self {
         Self {
             data: field!(_a0, data).with_mut(std::mem::take),
@@ -55,6 +56,7 @@ pub trait NonCopyImpl {
     fn move_assign(&self, _a0: Ptr<NonCopy>) -> Ptr<NonCopy>;
 }
 impl NonCopyImpl for Ptr<NonCopy> {
+    #[inline]
     fn move_assign(&self, _a0: Ptr<NonCopy>) -> Ptr<NonCopy> {
         field_ref!((*self), data)
             .as_pointer()

tests/unit/out/refcount/as_const.rs

@@ -50,15 +50,19 @@ pub trait SImpl {
     fn value_ref_4(&self) -> Ptr<i32>;
 }
 impl SImpl for Ptr<S> {
+    #[inline]
     fn f_1(&self) -> Overload {
         return Overload_kMutableOverload;
     }
+    #[inline]
     fn f_2(&self) -> Overload {
         return Overload_kConstOverload;
     }
+    #[inline]
     fn value_ref_3(&self) -> Ptr<i32> {
         return field_ptr!((*self), v);
     }
+    #[inline]
     fn value_ref_4(&self) -> Ptr<i32> {
         return field_ptr!((*self), v);
     }