[cpp] Merge wit-common and wit-guest, install them when generating bindings (#1322)

* Merge wit-common and wit-guest, install them when generating bindings

* Switch to C++20

* Fix missing headers, compile in C++20 mode, fix std::span usage

* Correct wit.h symlink

* Replace old C++ language tests with new one

* Fix incorrect header name

* Formatting

* Fix crate versions

Author: TartanLlama

crates/cpp/DESIGN.md

@@ -24,31 +24,31 @@
 | Code | mode | WIT Type | Rust type | C++ Type | Lower | Reason |
 | --- | --- | --- | --- | --- | --- | --- |
 | GIA | v | string | &str[^1] | string_view (17) | addr, len | |
-| | | list | &[T] | wit::span [^5] | addr, len | |
+| | | list | &[T] | std::span [^5] | addr, len | |
 | | | tuple | (...) | std::tuple | 0, 1, ...| |
 | | | tuple<string, list> | (&str, &[T]) | std::tuple<...> | a,l,a,l |
 | | | record{string, list} | &T | T const& | a,l,a,l |
 | | | large-struct (>16 args) | &T | T const& | &t |
 | | | result<string,list> | Result<&str, &[]> | std::expected<string_view, span> | d,a,l |
 | | | option\<string> | Option\<&str> | optional<string_view> const& | d,a,l|
 | | | list\<resrc> | &[\&Resrc]? | vector<string_view> const& | a,l|
-| GIR | t | string | String | wit::string[^2] | &(addr, len) [^8] | |
+| GIR | t | string | String | wit::string[^2] | &(addr, len) [^7] | |
 | | | list | Vec | wit::vector | &(a,l) |
 | | | result<string,list> | Result<String, Vec> | std::expected<wit::string, wit::vector> | &(d,a,l) |
 | GEA | t | string | String | 🌓 wit::string | addr, len |
 | | | | | ⚖️ string_view | |
 | | | result<string,list> | Result<String, Vec> | 🌓 std::expected<wit::string, wit::vector> | d,a,l |
 | | | | | ⚖️ std::expected<string_view, wit::span> | |
-| GER | p | string | String | wit::string (or std?) | 📘 -> &(a,l) cabi_post_N:P/I#F [^7] |
+| GER | p | string | String | wit::string (or std?) | 📘 -> &(a,l) cabi_post_N:P/I#F [^6] |
 | | | | | | 🪞 &(a,l) |
 | | | result<string,list> | Result<String, Vec> | std::expected<wit::string, wit::vector> | 📘 -> &(d,a,l) cabi_post |
 | --S | ? | string | String | wit::string | addr, len |
 | HIA | v | string | | string_view | a,l |
 | HIR | t | string | | wit::string[^3] | &(a,l) |
 | HEA | t | string | | 🌓 wit::string[^4] | a,l |
-| | | | | ⚖️ string_view [^6] | |
+| | | | | ⚖️ string_view [^5] | |
 | HER | p | string | | 🌓 wit::guest_owned<string_view> | 📘 -> &(a,l) |
-| | | | | ⚖️ wit::string [^6] | 🪞 &(a,l) |
+| | | | | ⚖️ wit::string [^5] | 🪞 &(a,l) |
 
 [^1]: The host never frees memory (is never passed ownership)!
 
@@ -60,13 +60,11 @@ Complex (non-POD) struct elements on the host will need exec_env to decode or co
 
 [^4]: A host side wit::string doesn't own the data (not free in dtor), thus no move semantics.
 
-[^5]: std::span requires C++-20, this alias should give minimal functionality with older compiler targets.
+[^5]: Not implemented, for now symmetric is priority
 
-[^6]: Not implemented, for now symmetric is priority
+[^6]: Here the callee (guest) allocates the memory for the set on its side
 
-[^7]: Here the callee (guest) allocates the memory for the set on its side
-
-[^8]: Caller passes address of the return object as argument
+[^7]: Caller passes address of the return object as argument
 
 ## [Symmetric ABI](https://github.com/WebAssembly/component-model/issues/386)
 

crates/cpp/helper-types/wit-common.h

@@ -1,15 +1,50 @@
 #pragma once
-#include "wit-common.h"
-#include <malloc.h>
+
+#include <assert.h>
+#include <map>
+#include <optional>
+#include <stddef.h> // size_t
+#include <stdint.h>
 #include <memory> // unique_ptr
 #include <stdint.h>
 #include <string>
 #include <string_view>
 #include <string.h> // memcpy
 #include <stdlib.h> // free
 #include <new>
+#include <span>
 
 namespace wit {
+/// @brief Helper class to map between IDs and resources
+/// @tparam R Type of the Resource
+template <class R> class ResourceTable {
+  static std::map<int32_t, R> resources;
+
+public:
+  static R *lookup_resource(int32_t id) {
+    auto result = resources.find(id);
+    return result == resources.end() ? nullptr : &result->second;
+  }
+  static int32_t store_resource(R &&value) {
+    auto last = resources.rbegin();
+    int32_t id = last == resources.rend() ? 0 : last->first + 1;
+    resources.insert(std::pair<int32_t, R>(id, std::move(value)));
+    return id;
+  }
+  static std::optional<R> remove_resource(int32_t id) {
+    auto iter = resources.find(id);
+    std::optional<R> result;
+    if (iter != resources.end()) {
+      result = std::move(iter->second);
+      resources.erase(iter);
+    }
+    return std::move(result);
+  }
+};
+
+/// @brief Replaces void in the error position of a result
+struct Void {};
+
 /// A string in linear memory, freed unconditionally using free
 ///
 /// A normal C++ string makes no guarantees about where the characters
@@ -112,9 +147,9 @@ template <class T> class vector {
   T* leak() { T*result = data_; data_ = nullptr; return result; }
   // typically called by post
   static void drop_raw(void *ptr) { if (ptr!=empty_ptr()) free(ptr); }
-  wit::span<T> get_view() const { return wit::span<T>(data_, length); }
-  wit::span<const T> get_const_view() const { return wit::span<const T>(data_, length); }
-  template <class U> static vector<T> from_view(wit::span<U> const& a) {
+  std::span<T> get_view() const { return std::span<T>(data_, length); }
+  std::span<const T> get_const_view() const { return std::span<const T>(data_, length); }
+  template <class U> static vector<T> from_view(std::span<U> const& a) {
     auto result = vector<T>::allocate(a.size());
     for (uint32_t i=0;i<a.size();++i) {
       new ((void*)(result.data_+i)) T(a[i]);

crates/cpp/helper-types/wit-guest.h renamed to crates/cpp/helper-types/wit.h

@@ -80,6 +80,8 @@ struct Includes {
     needs_variant: bool,
     needs_tuple: bool,
     needs_assert: bool,
+    needs_bit: bool,
+    needs_span: bool,
     // needs wit types
     needs_wit: bool,
     needs_memory: bool,
@@ -339,20 +341,20 @@ impl Cpp {
     fn perform_cast(&mut self, op: &str, cast: &Bitcast) -> String {
         match cast {
             Bitcast::I32ToF32 | Bitcast::I64ToF32 => {
-                self.dependencies.needs_wit = true;
-                format!("wit::bit_cast<float, int32_t>({})", op)
+                self.dependencies.needs_bit = true;
+                format!("std::bit_cast<float, int32_t>({})", op)
             }
             Bitcast::F32ToI32 | Bitcast::F32ToI64 => {
-                self.dependencies.needs_wit = true;
-                format!("wit::bit_cast<int32_t, float>({})", op)
+                self.dependencies.needs_bit = true;
+                format!("std::bit_cast<int32_t, float>({})", op)
             }
             Bitcast::I64ToF64 => {
-                self.dependencies.needs_wit = true;
-                format!("wit::bit_cast<double, int64_t>({})", op)
+                self.dependencies.needs_bit = true;
+                format!("std::bit_cast<double, int64_t>({})", op)
             }
             Bitcast::F64ToI64 => {
-                self.dependencies.needs_wit = true;
-                format!("wit::bit_cast<int64_t, double>({})", op)
+                self.dependencies.needs_bit = true;
+                format!("std::bit_cast<int64_t, double>({})", op)
             }
             Bitcast::I32ToI64 | Bitcast::LToI64 | Bitcast::PToP64 => {
                 format!("(int64_t) {}", op)
@@ -409,11 +411,14 @@ impl Cpp {
             self.include("<tuple>");
         }
         if self.dependencies.needs_wit {
-            self.include("<wit-guest.h>");
+            self.include("\"wit.h\"");
         }
         if self.dependencies.needs_memory {
             self.include("<memory>");
         }
+        if self.dependencies.needs_bit {
+            self.include("<bit>");
+        }
     }
 
     fn start_new_file(&mut self, condition: Option<bool>) -> FileContext {
@@ -715,6 +720,10 @@ impl WorldGenerator for Cpp {
             .as_slice(),
         );
 
+        if self.dependencies.needs_wit {
+            files.push(&format!("wit.h"), include_bytes!("../helper-types/wit.h"));
+        }
+
         Ok(())
     }
 }
@@ -1520,15 +1529,15 @@ impl CppInterfaceGenerator<'_> {
                     let inner = self.type_name(ty, from_namespace, flavor);
                     match flavor {
                         Flavor::BorrowedArgument => {
-                            self.gen.dependencies.needs_wit = true;
-                            format!("wit::span<{inner} const>")
+                            self.gen.dependencies.needs_span = true;
+                            format!("std::span<{inner} const>")
                         }
                         Flavor::Argument(var)
                             if matches!(var, AbiVariant::GuestImport)
                                 || self.gen.opts.api_style == APIStyle::Symmetric =>
                         {
-                            self.gen.dependencies.needs_wit = true;
-                            format!("wit::span<{inner} const>")
+                            self.gen.dependencies.needs_span = true;
+                            format!("std::span<{inner} const>")
                         }
                         Flavor::Argument(AbiVariant::GuestExport) => {
                             self.gen.dependencies.needs_wit = true;

crates/cpp/src/lib.rs

@@ -0,0 +1 @@
+../helper-types/wit.h

crates/cpp/test_headers/wit-common.h

@@ -8,7 +8,7 @@ use std::process::Command;
 
 // option wasi_sdk_path is inherited from C
 
-pub struct Cpp17;
+pub struct Cpp;
 
 /// C/C++-specific configuration of component files
 #[derive(Default, Deserialize)]
@@ -26,9 +26,9 @@ fn clangpp(runner: &Runner<'_>) -> PathBuf {
     }
 }
 
-impl LanguageMethods for Cpp17 {
+impl LanguageMethods for Cpp {
     fn display(&self) -> &str {
-        "cpp17"
+        "cpp"
     }
 
     fn comment_prefix_for_test_config(&self) -> Option<&str> {
@@ -76,7 +76,7 @@ impl LanguageMethods for Cpp17 {
     ) -> anyhow::Result<()> {
         let mut export_header_dir = bindgen.wit_path.clone();
         export_header_dir.pop();
-        export_header_dir.push("cpp17");
+        export_header_dir.push("cpp");
 
         // copy resource implementation in header files to target dir
         if export_header_dir.is_dir() {
@@ -131,7 +131,7 @@ impl LanguageMethods for Cpp17 {
         .arg("-Wextra")
         .arg("-Werror")
         .arg("-Wno-unused-parameter")
-        .arg("-std=c++17")
+        .arg("-std=c++20")
         .arg("-c")
         .arg("-g")
         .arg("-o")
@@ -159,7 +159,7 @@ impl LanguageMethods for Cpp17 {
             .arg("-Werror")
             .arg("-Wc++-compat")
             .arg("-Wno-unused-parameter")
-            .arg("-std=c++17")
+            .arg("-std=c++20")
             .arg("-g")
             .arg("-o")
             .arg(&compile.output);