Partial conversion to CppRef<T> everywhere

Cargo.toml

@@ -26,7 +26,7 @@ rust-version = "1.77"
 resolver = "2"
 
 [features]
-arbitrary_self_types_pointers = []
+arbitrary_self_types = []
 
 [dependencies]
 autocxx-macro = { path="macro", version="0.29.0" }

demo/src/main.rs

@@ -6,6 +6,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(arbitrary_self_types)]
+
 use autocxx::prelude::*;
 include_cpp! {
     #include "input.h"
@@ -16,9 +18,9 @@ include_cpp! {
 
 fn main() {
     println!("Hello, world! - C++ math should say 12={}", ffi::DoMath(4));
-    let mut goat = ffi::Goat::new().within_box();
-    goat.as_mut().add_a_horn();
-    goat.as_mut().add_a_horn();
+    let goat = ffi::Goat::new().within_cpp_pin();
+    goat.add_a_horn();
+    goat.add_a_horn();
     assert_eq!(
         goat.describe().as_ref().unwrap().to_string_lossy(),
         "This goat has 2 horns."

engine/src/conversion/analysis/fun/mod.rs

@@ -1541,13 +1541,15 @@ impl<'a> FnAnalyzer<'a> {
                 let from_type = self_ty.as_ref().unwrap();
                 let from_type_path = from_type.to_type_path();
                 let to_type = to_type.to_type_path();
-                let (trait_signature, ty, method_name) = match *mutable {
+                let (trait_signature, ty, method_name): (_, Type, _) = match *mutable {
                     CastMutability::ConstToConst => (
                         parse_quote! {
-                            AsRef < #to_type >
+                            autocxx::AsCppRef < #to_type >
                         },
-                        Type::Path(from_type_path),
-                        "as_ref",
+                        parse_quote! {
+                            autocxx::CppRef< #from_type_path >
+                        },
+                        "as_cpp_ref",
                     ),
                     CastMutability::MutToConst => (
                         parse_quote! {

engine/src/conversion/codegen_rs/function_wrapper_rs.rs

@@ -172,9 +172,12 @@ impl TypeConversionPolicy {
                     _ => panic!("Not a pointer"),
                 };
                 let (ty, wrapper_name) = if is_mut {
-                    (parse_quote! { autocxx::CppMutRef<'a, #ty> }, "CppMutRef")
+                    (
+                        parse_quote! { autocxx::CppMutLtRef<'a, #ty> },
+                        "CppMutLtRef",
+                    )
                 } else {
-                    (parse_quote! { autocxx::CppRef<'a, #ty> }, "CppRef")
+                    (parse_quote! { autocxx::CppLtRef<'a, #ty> }, "CppLtRef")
                 };
                 let wrapper_name = make_ident(wrapper_name);
                 RustParamConversion::Param {
@@ -194,9 +197,9 @@ impl TypeConversionPolicy {
                     _ => panic!("Not a pointer"),
                 };
                 let ty = if is_mut {
-                    parse_quote! { &mut autocxx::CppMutRef<'a, #ty> }
+                    parse_quote! { autocxx::CppMutRef<#ty> }
                 } else {
-                    parse_quote! { &autocxx::CppRef<'a, #ty> }
+                    parse_quote! { autocxx::CppRef<#ty> }
                 };
                 RustParamConversion::Param {
                     ty,

engine/src/conversion/codegen_rs/mod.rs

@@ -18,7 +18,7 @@ mod utils;
 use indexmap::map::IndexMap as HashMap;
 use indexmap::set::IndexSet as HashSet;
 
-use autocxx_parser::{ExternCppType, IncludeCppConfig, RustFun, UnsafePolicy};
+use autocxx_parser::{ExternCppType, IncludeCppConfig, RustFun};
 
 use itertools::Itertools;
 use proc_macro2::{Span, TokenStream};
@@ -121,7 +121,6 @@ fn get_string_items() -> Vec<Item> {
 /// In practice, much of the "generation" involves connecting together
 /// existing lumps of code within the Api structures.
 pub(crate) struct RsCodeGenerator<'a> {
-    unsafe_policy: &'a UnsafePolicy,
     include_list: &'a [String],
     bindgen_mod: ItemMod,
     original_name_map: CppNameMap,
@@ -133,14 +132,12 @@ impl<'a> RsCodeGenerator<'a> {
     /// Generate code for a set of APIs that was discovered during parsing.
     pub(crate) fn generate_rs_code(
         all_apis: ApiVec<FnPhase>,
-        unsafe_policy: &'a UnsafePolicy,
         include_list: &'a [String],
         bindgen_mod: ItemMod,
         config: &'a IncludeCppConfig,
         header_name: Option<String>,
     ) -> Vec<Item> {
         let c = Self {
-            unsafe_policy,
             include_list,
             bindgen_mod,
             original_name_map: CppNameMap::new_from_apis(&all_apis),
@@ -515,11 +512,8 @@ impl<'a> RsCodeGenerator<'a> {
                 name, superclass, ..
             } => {
                 let methods = associated_methods.get(&superclass);
-                let generate_peer_constructor = subclasses_with_a_single_trivial_constructor.contains(&name.0.name) &&
-                    // TODO: Create an UnsafeCppPeerConstructor trait for calling an unsafe
-                    // constructor instead? Need to create unsafe versions of everything that uses
-                    // it too.
-                    matches!(self.unsafe_policy, UnsafePolicy::AllFunctionsSafe);
+                let generate_peer_constructor =
+                    subclasses_with_a_single_trivial_constructor.contains(&name.0.name);
                 self.generate_subclass(name, &superclass, methods, generate_peer_constructor)
             }
             Api::ExternCppType {

engine/src/conversion/conversion_tests.rs

@@ -33,7 +33,7 @@ fn do_test(input: ItemMod) {
     bc.convert(
         input,
         parse_callback_results,
-        UnsafePolicy::AllFunctionsSafe,
+        UnsafePolicy::ReferencesWrappedAllFunctionsSafe,
         inclusions,
         &CodegenOptions::default(),
         "",

engine/src/conversion/mod.rs

@@ -196,7 +196,6 @@ impl<'a> BridgeConverter<'a> {
                 .map_err(ConvertError::Cpp)?;
                 let rs = RsCodeGenerator::generate_rs_code(
                     analyzed_apis,
-                    &unsafe_policy,
                     self.include_list,
                     bindgen_mod,
                     self.config,

examples/reference-wrappers/src/main.rs

@@ -25,7 +25,7 @@
 
 // Necessary to be able to call methods on reference wrappers.
 // For that reason, this example only builds on nightly Rust.
-#![feature(arbitrary_self_types_pointers)]
+#![feature(arbitrary_self_types)]
 
 use autocxx::prelude::*;
 use std::pin::Pin;

integration-tests/src/lib.rs

@@ -380,6 +380,7 @@ pub fn do_run_test(
     let safety_policy = format_ident!("{}", safety_policy);
     let unexpanded_rust = quote! {
             #module_attributes
+            #![feature(arbitrary_self_types)]
 
             use autocxx::prelude::*;
 

integration-tests/tests/cpprefs_test.rs

@@ -27,7 +27,7 @@ fn run_cpprefs_test(
     generate_pods: &[&str],
 ) {
     if !arbitrary_self_types_supported() {
-        // "unsafe_references_wrapped" requires arbitrary_self_types_pointers, which requires nightly.
+        // "unsafe_references_wrapped" requires arbitrary_self_types, which requires nightly.
         return;
     }
     do_run_test(
@@ -127,7 +127,7 @@ fn test_return_reference_cpprefs() {
     let rs = quote! {
         let b = CppPin::new(ffi::Bob { a: 3, b: 4 });
         let b_ref = b.as_cpp_ref();
-        let bob = ffi::give_bob(&b_ref);
+        let bob = ffi::give_bob(b_ref);
         let val = unsafe { bob.as_ref() };
         assert_eq!(val.b, 4);
     };