Strip r# prefix from raw identifiers in generated C++ names

extern "C++" parameters/fields named with a raw identifier (e.g.
r#type, used only to dodge a Rust keyword) were emitted verbatim
into generated C++, producing invalid code like
`void foo(::std::int32_t r#type) noexcept`.

ForeignName::parse is the single place that turns a Rust identifier
into its C++-facing name, both for the implicit default name and for
explicit #[cxx_name = ...] attributes, so strip the r# prefix there.
This mirrors the existing precedent in QualifiedName::parse_unquoted
(syntax/qualified.rs) for namespace segments.

Fixes #1324

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

Author: HarnageaGabriel

syntax/names.rs

@@ -40,7 +40,10 @@ impl ForeignName {
         // non-alphanumeric characters (`operator++`).
         match Ident::parse_any.parse_str(text) {
             Ok(ident) => {
-                let text = ident.to_string();
+                let mut text = ident.to_string();
+                if let Some(unraw) = text.strip_prefix("r#") {
+                    text = unraw.to_owned();
+                }
                 Ok(ForeignName { text })
             }
             Err(err) => Err(Error::new(span, err)),

tests/cxx_gen.rs

@@ -12,6 +12,15 @@ const BRIDGE0: &str = r#"
     }
 "#;
 
+const BRIDGE_RAW_IDENTIFIER: &str = r#"
+    #[cxx::bridge]
+    mod ffi {
+        unsafe extern "C++" {
+            pub fn highlight(r#type: i32);
+        }
+    }
+"#;
+
 #[test]
 fn test_extern_c_function() {
     let opt = Opt::default();
@@ -23,6 +32,21 @@ fn test_extern_c_function() {
     assert!(output.contains(&format!("void {CXXPREFIX}$do_cpp_thing(::rust::Str foo)")));
 }
 
+#[test]
+fn test_raw_identifier_param() {
+    let opt = Opt::default();
+    let source = BRIDGE_RAW_IDENTIFIER.parse().unwrap();
+    let generated = generate_header_and_cc(source, &opt).unwrap();
+    let header = str::from_utf8(&generated.header).unwrap();
+    let implementation = str::from_utf8(&generated.implementation).unwrap();
+
+    assert!(!header.contains("r#"));
+    assert!(!implementation.contains("r#"));
+    assert!(implementation.contains(&format!(
+        "void {CXXPREFIX}$highlight(::std::int32_t type) noexcept",
+    )));
+}
+
 #[test]
 fn test_impl_annotation() {
     let mut opt = Opt::default();