fix(cpp): escape cpp keywords

- remove keywords.wit from expected failures
- use std::optional for ResultLift to avoid default constructor issues
  std::expected doesn't have a default constructor when the value type
  lacks one. Use std::optional wrapper to defer construction until the
  result is known.

Fixes #1419

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

Author: ricochet

crates/cpp/src/lib.rs

@@ -721,14 +721,14 @@ fn namespace(resolve: &Resolve, owner: &TypeOwner, guest_export: bool, opts: &Op
         result.push(String::from("exports"));
     }
     match owner {
-        TypeOwner::World(w) => result.push(resolve.worlds[*w].name.to_snake_case()),
+        TypeOwner::World(w) => result.push(to_c_ident(&resolve.worlds[*w].name)),
         TypeOwner::Interface(i) => {
             let iface = &resolve.interfaces[*i];
             let pkg = &resolve.packages[iface.package.unwrap()];
-            result.push(pkg.name.namespace.to_snake_case());
-            result.push(pkg.name.name.to_snake_case());
+            result.push(to_c_ident(&pkg.name.namespace));
+            result.push(to_c_ident(&pkg.name.name));
             if let Some(name) = &iface.name {
-                result.push(name.to_snake_case());
+                result.push(to_c_ident(name));
             }
         }
         TypeOwner::None => (),
@@ -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, "}};");
@@ -1722,7 +1737,7 @@ impl<'a> wit_bindgen_core::InterfaceGenerator<'a> for CppInterfaceGenerator<'a>
             let guest_import = self.gen.imported_interfaces.contains(&intf);
             let definition = !(guest_import);
             let store = self.gen.start_new_file(Some(definition));
-            let mut world_name = self.gen.world.to_snake_case();
+            let mut world_name = to_c_ident(&self.gen.world);
             world_name.push_str("::");
             let namespc = namespace(self.resolve, &type_.owner, !guest_import, &self.gen.opts);
             let pascal = name.to_upper_camel_case();
@@ -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);
             }
@@ -2874,21 +2892,24 @@ impl<'a, 'b> Bindgen for FunctionBindgen<'a, 'b> {
 
                 let tmp = self.tmp();
                 let resultname = self.tempname("result", tmp);
+                // Use std::optional to avoid default constructor issues with std::expected
+                self.gen.gen.dependencies.needs_optional = true;
                 let ok_assign = if result.ok.is_some() {
-                    format!("{resultname}.emplace({ok_result});")
+                    format!("{resultname}_opt.emplace({full_type}({ok_result}));")
                 } else {
-                    String::new()
+                    format!("{resultname}_opt.emplace({full_type}());")
                 };
                 uwriteln!(
                     self.src,
-                    "{full_type} {resultname};
+                    "std::optional<{full_type}> {resultname}_opt;
                     if ({operand}==0) {{
                         {ok}
                         {ok_assign}
                     }} else {{
                         {err}
-                        {resultname}={err_type}{{{err_result}}};
-                    }}"
+                        {resultname}_opt.emplace({err_type}{{{err_result}}});
+                    }}
+                    {full_type} {resultname} = std::move(*{resultname}_opt);"
                 );
                 results.push(resultname);
             }

crates/test/src/cpp.rs

@@ -53,7 +53,6 @@ impl LanguageMethods for Cpp {
             | "import-func.wit"
             | "issue573.wit"
             | "issue929-no-export.wit"
-            | "keywords.wit"
             | "lift-lower-foreign.wit"
             | "lists.wit"
             | "multiversion"
@@ -68,13 +67,8 @@ impl LanguageMethods for Cpp {
             | "return-resource-from-export.wit"
             | "same-names1.wit"
             | "same-names5.wit"
-            | "simple-http.wit"
             | "variants.wit"
             | "variants-unioning-types.wit"
-            | "wasi-cli"
-            | "wasi-filesystem"
-            | "wasi-http"
-            | "wasi-io"
             | "worlds-with-types.wit"
             | "streams.wit" => true,
             _ => false,