Support moving into an rvalue reference argument · dtolnay/cxx#561

2020-12-11T00:22:16.000Z

Consider this code: ```rust // src/lib.rs #[cxx::bridge] mod ffi { unsafe extern "C++" { include!("example/include/example.h"); type Thing; fn f(thing: UniquePtr ); } } ``` ```cpp #pragma once #include struct Thing {}; void f(std::unique_ptr &&); ``` This would currently fail to build, with: ```console example-760540e262f31cef/out/cxxbridge/sources/example/src/main.rs.cc: In function ‘void cxxbridge1$f(Thing*)’: example-760540e262f31cef/out/cxxbridge/sources/example/src/main.rs.cc:34:46: error: invalid conversion from ‘void (*)(std::unique_ptr &&)’ to ‘void (*)(std::unique_ptr )’ [-fpermissive] 34 | void (*f$)(::std::unique_ptr ) = ::f; | ~~^ | | | void (*)(std::unique_ptr && ``` because the cxx C++ code generator is expecting a signature `void f(std::unique_ptr )` whereas the actual signature is `void f(std::unique_ptr &&)`. It would be good to support this better and interoperate between a Rust by-value argument and a C++ rvalue reference argument. Maybe like: ```rust extern "C++" { fn f(thing: #[move] UniquePtr ); } ``` or this bastardization of C++ rvalue syntax: ```rust extern "C++" { fn f(&&thing: UniquePtr ); } ```

(0 comments) (0 reactions) (0 assignees)Rust (4,472 stars) (253 forks)batch import

help wanted

説明

Consider this code:

// src/lib.rs

#[cxx::bridge]
mod ffi {
    unsafe extern "C++" {
        include!("example/include/example.h");
        type Thing;
        fn f(thing: UniquePtr<Thing>);
    }
}

#pragma once
#include <memory>

struct Thing {};

void f(std::unique_ptr<Thing> &&);

This would currently fail to build, with:

example-760540e262f31cef/out/cxxbridge/sources/example/src/main.rs.cc: In function ‘void cxxbridge1$f(Thing*)’:
example-760540e262f31cef/out/cxxbridge/sources/example/src/main.rs.cc:34:46: error: invalid conversion from ‘void (*)(std::unique_ptr<Thing>&&)’ to ‘void (*)(std::unique_ptr<Thing>)’ [-fpermissive]
   34 |   void (*f$)(::std::unique_ptr<::Thing>) = ::f;
      |                                            ~~^
      |                                              |
      |                                              void (*)(std::unique_ptr<Thing>&&

because the cxx C++ code generator is expecting a signature void f(std::unique_ptr<Thing>) whereas the actual signature is void f(std::unique_ptr<Thing> &&).

It would be good to support this better and interoperate between a Rust by-value argument and a C++ rvalue reference argument.

Maybe like:

extern "C++" {
    fn f(thing: #[move] UniquePtr<Thing>);
}

or this bastardization of C++ rvalue syntax:

extern "C++" {
    fn f(&&thing: UniquePtr<Thing>);
}

コントリビューターガイド

技術スタック: rustcpp
領域: api
Issue 種別: feature
難度: 4
推定時間: 3-5 days
活動状況: stale
明確さ: clear
前提条件: RustC++CXX frameworkcode generation concepts
初心者向け度: 25
調査方針: The issue is a feature request to support C++ rvalue reference arguments in CXX bridge functions. The core problem lies in the C++ code generator, likely in files like `src/gen/write.rs` or similar, where function signatures are generated. The current generator expects a by value `std::unique ptr<Thing>` but the actual C++ function takes an rvalue reference `std::unique ptr<Thing>&&`. To implement this, one should examine how the generator handles argument types and consider adding a mechanism to distinguish between by value and rvalue reference, perhaps via a new attribute like `#[move]` or alternative Rust syntax. Look at existing attribute handling in the CXX codebase and the generated C++ code to understand the pattern.