fix(cpp): escape cpp keywords

Fixes #1419

Signed-off-by: Bailey Hayes <[email protected]>

Author: ricochet

crates/cpp/src/lib.rs

@@ -797,8 +797,23 @@ struct CppInterfaceGenerator<'a> {
 
 impl CppInterfaceGenerator<'_> {
     fn types(&mut self, iface: InterfaceId) {
-        let iface = &self.resolve().interfaces[iface];
-        for (name, id) in iface.types.iter() {
+        let iface_data = &self.resolve().interfaces[iface];
+
+        // First pass: emit forward declarations for all resources
+        // This ensures resources can reference each other in method signatures
+        for (name, id) in iface_data.types.iter() {
+            let ty = &self.resolve().types[*id];
+            if matches!(&ty.kind, TypeDefKind::Resource) {
+                let pascal = name.to_upper_camel_case();
+                let guest_import = self.gen.imported_interfaces.contains(&iface);
+                let namespc = namespace(self.resolve, &ty.owner, !guest_import, &self.gen.opts);
+                self.gen.h_src.change_namespace(&namespc);
+                uwriteln!(self.gen.h_src.src, "class {pascal};");
+            }
+        }
+
+        // Second pass: emit full type definitions
+        for (name, id) in iface_data.types.iter() {
             self.define_type(name, *id);
         }
     }
@@ -1055,7 +1070,7 @@ impl CppInterfaceGenerator<'_> {
                 ""
             };
             res.arguments.push((
-                name.to_snake_case(),
+                to_c_ident(name),
                 self.type_name(param, &res.namespace, Flavor::Argument(abi_variant)) + is_pointer,
             ));
         }
@@ -1662,7 +1677,7 @@ impl CppInterfaceGenerator<'_> {
             uwriteln!(self.gen.h_src.src, "struct {pascal} {{");
             for field in record.fields.iter() {
                 let typename = self.type_name(&field.ty, namespc, flavor);
-                let fname = field.name.to_snake_case();
+                let fname = to_c_ident(&field.name);
                 uwriteln!(self.gen.h_src.src, "{typename} {fname};");
             }
             uwriteln!(self.gen.h_src.src, "}};");
@@ -1703,7 +1718,7 @@ impl<'a> wit_bindgen_core::InterfaceGenerator<'a> for CppInterfaceGenerator<'a>
             for field in record.fields.iter() {
                 Self::docs(&mut self.gen.h_src.src, &field.docs);
                 let typename = self.type_name(&field.ty, &namespc, Flavor::InStruct);
-                let fname = field.name.to_snake_case();
+                let fname = to_c_ident(&field.name);
                 uwriteln!(self.gen.h_src.src, "{typename} {fname};");
             }
             uwriteln!(self.gen.h_src.src, "}};");
@@ -1884,7 +1899,7 @@ impl<'a> wit_bindgen_core::InterfaceGenerator<'a> for CppInterfaceGenerator<'a>
             uwriteln!(self.gen.h_src.src, "k_None = 0,");
             for (n, field) in flags.flags.iter().enumerate() {
                 Self::docs(&mut self.gen.h_src.src, &field.docs);
-                let fname = field.name.to_pascal_case();
+                let fname = to_c_ident(&field.name).to_pascal_case();
                 uwriteln!(self.gen.h_src.src, "k{fname} = (1ULL<<{n}),");
             }
             uwriteln!(self.gen.h_src.src, "}};");
@@ -1926,7 +1941,7 @@ impl<'a> wit_bindgen_core::InterfaceGenerator<'a> for CppInterfaceGenerator<'a>
             let mut all_types = String::new();
             for case in variant.cases.iter() {
                 Self::docs(&mut self.gen.h_src.src, &case.docs);
-                let case_pascal = case.name.to_pascal_case();
+                let case_pascal = to_c_ident(&case.name).to_pascal_case();
                 if !all_types.is_empty() {
                     all_types += ", ";
                 }
@@ -1985,7 +2000,7 @@ impl<'a> wit_bindgen_core::InterfaceGenerator<'a> for CppInterfaceGenerator<'a>
                 uwriteln!(
                     self.gen.h_src.src,
                     " k{} = {i},",
-                    case.name.to_pascal_case(),
+                    to_c_ident(&case.name).to_pascal_case(),
                 );
             }
             uwriteln!(self.gen.h_src.src, "}};\n");
@@ -2655,7 +2670,8 @@ impl<'a, 'b> Bindgen for FunctionBindgen<'a, 'b> {
                     uwriteln!(self.src, "case {}: {{", i);
                     if let Some(ty) = case.ty.as_ref() {
                         let ty = self.gen.type_name(ty, &self.namespace, Flavor::InStruct);
-                        let case = format!("{elem_ns}::{}", case.name.to_pascal_case());
+                        let case =
+                            format!("{elem_ns}::{}", to_c_ident(&case.name).to_pascal_case());
                         uwriteln!(
                             self.src,
                             "{} &{} = std::get<{case}>({}.variants).value;",
@@ -2686,24 +2702,26 @@ impl<'a, 'b> Bindgen for FunctionBindgen<'a, 'b> {
                 let resultno = self.tmp();
                 let result = format!("variant{resultno}");
 
-                uwriteln!(self.src, "{ty} {result};");
-
                 let op0 = &operands[0];
 
+                // Use std::optional to avoid default constructor issues
+                self.gen.gen.dependencies.needs_optional = true;
+                uwriteln!(self.src, "std::optional<{ty}> {result}_opt;");
                 uwriteln!(self.src, "switch ({op0}) {{");
                 for (i, (case, (block, block_results))) in
                     variant.cases.iter().zip(blocks).enumerate()
                 {
-                    let tp = case.name.clone().to_pascal_case();
+                    let tp = to_c_ident(&case.name).to_pascal_case();
                     uwriteln!(self.src, "case {i}: {{ {block}");
                     uwriteln!(
                         self.src,
-                        "{result}.variants = {ty}::{tp}{{{}}};",
+                        "{result}_opt = {ty}{{{{{ty}::{tp}{{{}}}}}}};",
                         move_if_necessary(&block_results.first().cloned().unwrap_or_default())
                     );
                     uwriteln!(self.src, "}} break;");
                 }
                 uwriteln!(self.src, "}}");
+                uwriteln!(self.src, "{ty} {result} = std::move(*{result}_opt);");
 
                 results.push(result);
             }

tests/codegen/cpp-http-owned.wit

@@ -0,0 +1,86 @@
+// Test file for C++ code generation fixes:
+// 1. C++ keyword escaping (parameter named 'this')
+// 2. Forward declarations for resources
+
+package test:cpp-http-owned;
+
+world cpp-http-owned {
+  // Test 1: Resource with forward reference
+  // IncomingBody returns FutureTrailers (forward declaration needed)
+  import test-interface: interface {
+    resource incoming-body {
+      // Static method with 'this' parameter (C++ keyword)
+      finish: static func(this: incoming-body) -> future-trailers;
+    }
+
+    resource future-trailers {
+      get: func() -> option<string>;
+    }
+
+    resource request {
+      // Method that returns another resource (forward declaration test)
+      consume: func() -> incoming-body;
+    }
+  }
+
+  // Test 2: Export interface with Owned types
+  export test-exports: interface {
+    resource request-data {
+      constructor();
+    }
+
+    resource response {
+      constructor();
+    }
+
+    // Function requiring ::Owned syntax
+    handle: func(req: request-data, resp: response);
+  }
+
+  // More C++ keywords as parameters
+  export keyword-test: func(this: string, class: u32, template: bool) -> string;
+
+  // Test 3: C++ keywords in records, enums, flags, and variants
+  export keyword-types: interface {
+    // Record with C++ keyword field names
+    record field-keywords {
+      class: string,
+      return: u32,
+      default: bool,
+      case: s64,
+      namespace: string,
+    }
+
+    // Enum with C++ keyword case names
+    enum case-keywords {
+      class,
+      return,
+      default,
+      case,
+      template,
+    }
+
+    // Flags with C++ keyword names
+    flags flag-keywords {
+      class,
+      return,
+      default,
+      case,
+      namespace,
+    }
+
+    // Variant with C++ keyword case names
+    variant variant-keywords {
+      class(string),
+      return(u32),
+      default,
+      case(bool),
+    }
+
+    // Functions using these types
+    test-record: func(input: field-keywords) -> field-keywords;
+    test-enum: func(input: case-keywords) -> case-keywords;
+    test-flags: func(input: flag-keywords) -> flag-keywords;
+    test-variant: func(input: variant-keywords) -> variant-keywords;
+  }
+}