D guest bindings generator

.github/workflows/main.yml

@@ -79,7 +79,7 @@ jobs:
       matrix:
         os: [ubuntu-latest, macos-latest, windows-latest]
         # moonbit removed from language matrix for now - causing CI failures
-        lang: [c, rust, csharp, cpp, go]
+        lang: [c, rust, csharp, cpp, go, d]
         exclude:
           # For now csharp doesn't work on macos, so exclude it from testing.
           - os: macos-latest
@@ -121,6 +121,12 @@ jobs:
         go-version: 1.25.4
       if: matrix.lang == 'go' && matrix.os != 'ubuntu-latest'
 
+    - name: Setup D
+      uses: dlang-community/setup-dlang@v2
+      with:
+        compiler: ldc-1.42
+      if: matrix.lang == 'd'
+
       # Hacky work-around for https://github.com/dotnet/runtime/issues/80619
     - run: dotnet new console -o /tmp/foo
       if: matrix.os != 'windows-latest' && matrix.lang == 'csharp'

Cargo.toml

@@ -63,6 +63,7 @@ wit-bindgen-csharp = { path = 'crates/csharp', version = '0.60.0' }
 wit-bindgen-markdown = { path = 'crates/markdown', version = '0.60.0' }
 wit-bindgen-moonbit = { path = 'crates/moonbit', version = '0.60.0' }
 wit-bindgen-go = { path = 'crates/go', version = '0.60.0' }
+wit-bindgen-d = { path = 'crates/d', version = '0.60.0' }
 wit-bindgen = { path = 'crates/guest-rust', version = '0.60.0', default-features = false }
 wit-bindgen-test = { path = 'crates/test', version = '0.60.0' }
 
@@ -95,6 +96,7 @@ wit-bindgen-markdown = { workspace = true, features = ['clap'], optional = true
 wit-bindgen-moonbit = { workspace = true, features = ['clap'], optional = true }
 wit-bindgen-csharp = { workspace = true, features = ['clap'], optional = true }
 wit-bindgen-go = { workspace = true, features = ['clap'], optional = true }
+wit-bindgen-d = { workspace = true, features = ['clap'], optional = true }
 wit-bindgen-test = { workspace = true }
 wit-component = { workspace = true }
 wasm-encoder = { workspace = true }
@@ -109,7 +111,8 @@ default = [
   'csharp',
   'cpp',
   'moonbit',
-  'async',
+  'd',
+  'async'
 ]
 c = ['dep:wit-bindgen-c']
 cpp = ['dep:wit-bindgen-cpp']
@@ -119,4 +122,5 @@ go = ['dep:wit-bindgen-go']
 csharp = ['dep:wit-bindgen-csharp']
 csharp-mono = ['csharp']
 moonbit = ['dep:wit-bindgen-moonbit']
+d = ['dep:wit-bindgen-d']
 async = []

ci/publish.rs

@@ -25,6 +25,7 @@ const CRATES_TO_PUBLISH: &[&str] = &[
     "wit-bindgen-markdown",
     "wit-bindgen-moonbit",
     "wit-bindgen-go",
+    "wit-bindgen-d",
     "wit-bindgen-rust-macro",
     "wit-bindgen-rt",
     "wit-bindgen",

crates/d/Cargo.toml

@@ -0,0 +1,33 @@
+[package]
+name = "wit-bindgen-d"
+authors = ["Demetrius Kanios <demetrius@kanios.net>"]
+version = { workspace = true }
+edition = { workspace = true }
+repository = { workspace = true }
+license = { workspace = true }
+rust-version = { workspace = true }
+homepage = 'https://github.com/bytecodealliance/wit-bindgen'
+description = """
+D bindings generator for WIT and the component model, typically used through the
+`wit-bindgen-cli` crate.
+"""
+
+[lints]
+workspace = true
+
+[lib]
+doctest = false
+test = false
+
+[dependencies]
+wit-bindgen-core = { workspace = true }
+wit-component = { workspace = true }
+wasm-encoder = { workspace = true }
+wasm-metadata = { workspace = true }
+anyhow = { workspace = true }
+heck = { workspace = true }
+clap = { workspace = true, optional = true }
+indexmap = { workspace = true }
+
+[features]
+clap = ['dep:clap', 'wit-bindgen-core/clap']

crates/d/LICENSE-APACHE

@@ -0,0 +1 @@
+../../LICENSE-APACHE

crates/d/LICENSE-Apache-2.0_WITH_LLVM-exception

@@ -0,0 +1 @@
+../../LICENSE-Apache-2.0_WITH_LLVM-exception

crates/d/LICENSE-MIT

@@ -0,0 +1 @@
+../../LICENSE-MIT

crates/d/README.md

@@ -0,0 +1,47 @@
+# `wit-bindgen` D Bindings Generator
+
+This tool generates [D](https://dlang.org) bindings for a chosen WIT world.
+
+## Usage
+
+To generate bindings with this crate, issue the `d` subcommand to `wit-bindgen`:
+
+```bash
+$ wit-bindgen d [OPTIONS] <WIT>
+```
+
+See the output of `wit-bindgen help d` for available options.
+
+## Output Structure
+
+Running `wit-bindgen d` on a WIT world will produce a full package structure mirroring the organization of the WIT world and the interfaces it uses. The default output directory and root package are both `wit`.
+
+`wit.common` holds some definitions used across the generated bindings (for e.g. `result`, `option`, `list`, etc.).
+
+The generated file for the world will by default, `public import` all relavent definitions. More selective imports can be made by importing the appropriate modules corresponding to particular interfaces.
+
+The module for the world `foo:bar/world` will be placed in `wit/foo/bar/world/package.d`. Anonymous interface import and exports for the world will emitted in `wit/foo/bar/world/{imports|exports}`.
+
+Top-level interfaces will be output similarly to worlds. `foo:bar/interface` gets split across multiple modules in `wit/foo/bar/interface/*.d`. Type definitions that are agnostic to import or export (any records, tuples, lists, etc. that do not contain resource handles) will go in `/common.d`. Function imports and import-specific types go in `/imports.d`, and exports go in `/exports.d`
+
+## Memory/Resource Management
+
+Currently, all imports take in parameters as "borrowing" and return memory "owning", with some caveats due to resource handles.
+
+Memory is managed on the C `malloc` heap. This assumption can be used in some cases to reduce copies when unecessary.
+
+When giving parameters to imports, any `list` or `string` memory is NOT freed, and the caller retains ownership/responibility for it. However, the ownership rules of WIT mean that any owning resource handles are invalidated. The bindings will not automatically "consume" these for you, and you will have to zero them out (default init) yourself after the call to prevent double-free.
+
+When receiving parameters to exports, `list` and `string` memory is automatically freed. You must copy this memory elsewhere to retain it past the end of the call. Resource handles are not dropped however, and BOTH owning and borrowing handles (e.g. `Res` and `Res.Borrow`) must be dropped. To drop a handle, use `witDrop`.
+
+When receiving values from imports, you are in charge of freeing the memory and dropping resource handles after you are finished with it/them. `witFree` deeply frees all such memory, and `witDrop` is also deep.
+
+When return values from exports, all memory must be on the WIT/C heap, so it can be reliably `free`d by the bindings. `witClone` deeply copies all `list`s and `string`s.
+
+`scope(exit)` is a valuable tool in helping keep track of this.
+
+In the future, changes may be made to help make this more automatic.
+
+## Examples
+
+It is recommended to peruse `tests/runtime` to find concrete examples of how to use the bindings.