Prevent compilation errors with CtorNew when the arguments have lifetimes.

This doesn't actually give the functions bindings -- that's harder and requires multiple releases. But it stops compilation from outright failing, by disabling bindings.

PiperOrigin-RevId: 896733406

Author: ssbr

rs_bindings_from_cc/generate_bindings/generate_function.rs

@@ -785,11 +785,18 @@ fn api_func_shape_for_constructor(
 
     if !record.is_unpin() {
         let func_name = make_rs_ident("ctor_new");
+
         let [_this, params @ ..] = param_types else {
-            panic!("Missing `__this` parameter in a constructor: {:?}", func)
+            errors.add(anyhow!(
+                "This is a bug in Crubit. Could not find `__this` parameter in a constructor: {:?}",
+                func
+            ));
+            return None;
         };
         // Elided lifetimes won't "just work" when split across the `Ctor` trait impl, so we replace
         // them with a single named lifetime.
+        // TODO(b/331685208): instead, return `impl Ctor` from `ctor_new`. It's infeasible (and
+        // expensive) to deep-copy the RsTypeKind and mutate all sublifetimes.
         for param in &mut params[..] {
             if let RsTypeKind::Reference { lifetime, .. }
             | RsTypeKind::RvalueReference { lifetime, .. } = param
@@ -799,6 +806,14 @@ fn api_func_shape_for_constructor(
                 }
             }
         }
+        // Check if there's still any elided lifetimes after the minimal transform above:
+        for param in &params[..] {
+            for lifetime in param.lifetimes() {
+                if lifetime.is_elided() {
+                    errors.add(anyhow!("b/331685208: Found a lifetime in a function parameter type {}, which prevents CtorNew bindings", param.display(db)));
+                }
+            }
+        }
         let impl_kind = ImplKind::Trait {
             record: record.clone(),
             trait_name: TraitName::CtorNew(params.iter().cloned().collect()),
@@ -814,7 +829,13 @@ fn api_func_shape_for_constructor(
         return Some((func_name, impl_kind));
     }
     match func.params.len() {
-        0 => panic!("Missing `__this` parameter in a constructor: {:?}", func),
+        0 => {
+            errors.add(anyhow!(
+                "This is a bug in Crubit. Could not find `__this` parameter in a constructor: {:?}",
+                func
+            ));
+            None
+        }
         1 => {
             let func_name = make_rs_ident("default");
             let impl_kind = ImplKind::new_trait(

rs_bindings_from_cc/test/struct/constructors/BUILD

@@ -17,6 +17,14 @@ crubit_test_cc_library(
     aspect_hints = ["//features:experimental"],
 )
 
+crubit_test_cc_library(
+    name = "span_constructors",
+    hdrs = ["span_constructors.h"],
+    # operator lifetime inference and ctor
+    aspect_hints = ["//features:experimental"],
+    deps = ["@abseil-cpp//absl/types:span"],
+)
+
 golden_test(
     name = "constructors_golden_test",
     basename = "constructors",
@@ -30,6 +38,7 @@ crubit_rust_test(
     srcs = ["test.rs"],
     cc_deps = [
         ":constructors",
+        ":span_constructors",
     ],
     deps = [
         "//support:ctor",

rs_bindings_from_cc/test/struct/constructors/span_constructors.h

@@ -0,0 +1,17 @@
+// Part of the Crubit project, under the Apache License v2.0 with LLVM
+// Exceptions. See /LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef THIRD_PARTY_CRUBIT_RS_BINDINGS_FROM_CC_TEST_STRUCT_CONSTRUCTORS_SPAN_CONSTRUCTORS_H_
+#define THIRD_PARTY_CRUBIT_RS_BINDINGS_FROM_CC_TEST_STRUCT_CONSTRUCTORS_SPAN_CONSTRUCTORS_H_
+
+#include "absl/types/span.h"
+
+struct MyStruct {
+  explicit MyStruct(absl::Span<const int> values) {}
+  ~MyStruct() {
+    // Nontrivial so that the constructor must return an `impl Ctor`.
+  }
+};
+
+#endif  // THIRD_PARTY_CRUBIT_RS_BINDINGS_FROM_CC_TEST_STRUCT_CONSTRUCTORS_SPAN_CONSTRUCTORS_H_

rs_bindings_from_cc/test/struct/constructors/test.rs

@@ -131,3 +131,12 @@ fn test_nontrivial_struct() {
     let s_clone = emplace!(ctor::copy(&*s));
     assert_eq!(s_clone.int_field, 123);
 }
+
+// Ideally, this test would work.
+//
+// // TODO(b/331685208): make this test compile and pass.
+//
+// #[gest]
+// fn test_span_constructors() {
+//     let _ = span_constructors::MyStruct::new(...);
+// }