[rust] bindgen path supports env!() macro (#1569)

* [rust] bindgen path supports env!() macro

This makes it possible to refer to a wit path by a path that includes
things like OUT_DIR or CARGO_MANIFEST_DIR. Relative paths that navigate
up, like `../wit/`, don't work well with cargo publish, and symlinks
have difficulties between git and cargo.

Using [macro-string](https://github.com/dtolnay/macro-string), this
replaces the `path` option's `syn::LitStr` with MacroString.

* add macro-string feature to wit-bindgen-rust-macro

gates the macro-string dependency on the new default feature macro-string.

* lift macro-string feature toggle to wit-bindgen

Author: kvcache

Cargo.lock

@@ -45,6 +45,7 @@ indexmap = "2.0.0"
 prettyplease = "0.2.20"
 syn = { version = "2.0.89", features = ["printing"] }
 futures = "0.3.31"
+macro-string = "0.2.0"
 
 wat = "1.245.1"
 wasmparser = "0.245.1"

Cargo.toml

@@ -19,7 +19,7 @@ workspace = true
 all-features = true
 
 [dependencies]
-wit-bindgen-rust-macro = { path = "./macro", optional = true, version = "0.54.0" }
+wit-bindgen-rust-macro = { path = "./macro", optional = true, default-features = false, version = "0.54.0" }
 bitflags = { workspace = true, optional = true }
 futures = { version = "0.3.30", optional = true }
 
@@ -28,13 +28,14 @@ core = { version = "1.0", optional = true, package = "rustc-std-workspace-core"
 alloc = { version = "1.0", optional = true, package = "rustc-std-workspace-alloc" }
 
 [features]
-default = ["macros", "realloc", "async", "std", "bitflags"]
+default = ["macros", "realloc", "async", "std", "bitflags", "macro-string"]
 macros = ["dep:wit-bindgen-rust-macro"]
 realloc = []
 std = []
 async = ["std", "wit-bindgen-rust-macro?/async"]
 bitflags = ["dep:bitflags"]
 async-spawn = ['async', 'dep:futures']
+macro-string = ["wit-bindgen-rust-macro?/macro-string"]
 
 # Unstable feature to support being a libstd dependency
 rustc-dep-of-std = ["dep:core", "dep:alloc"]

crates/guest-rust/Cargo.toml

@@ -23,6 +23,9 @@ wit-bindgen-rust = { workspace = true }
 anyhow = { workspace = true }
 syn = { workspace = true }
 prettyplease = { workspace = true }
+macro-string = { workspace = true, optional = true }
 
 [features]
+default = ["macro-string"]
 async = []
+macro-string = ["dep:macro-string"]

crates/guest-rust/macro/Cargo.toml

@@ -5,8 +5,7 @@ use std::path::{Path, PathBuf};
 use std::sync::atomic::{AtomicUsize, Ordering::Relaxed};
 use syn::parse::{Error, Parse, ParseStream, Result};
 use syn::punctuated::Punctuated;
-use syn::spanned::Spanned;
-use syn::{LitStr, Token, braced, token};
+use syn::{Token, braced, token};
 use wit_bindgen_core::AsyncFilterSet;
 use wit_bindgen_core::WorldGenerator;
 use wit_bindgen_core::wit_parser::{PackageId, Resolve, UnresolvedPackageGroup, WorldId};
@@ -76,7 +75,13 @@ impl Parse for Config {
             for field in fields.into_pairs() {
                 match field.into_value() {
                     Opt::Path(span, p) => {
-                        let paths = p.into_iter().map(|f| PathBuf::from(f.value())).collect();
+                        let paths = p
+                            .into_iter()
+                            .map(|f| f.evaluate_string())
+                            .collect::<Result<Vec<_>>>()?
+                            .into_iter()
+                            .map(PathBuf::from)
+                            .collect();
 
                         source = Some(match source {
                             Some(Source::Paths(_)) | Some(Source::Inline(_, Some(_))) => {
@@ -346,9 +351,32 @@ impl From<ExportKey> for wit_bindgen_rust::ExportKey {
     }
 }
 
+#[cfg(feature = "macro-string")]
+type PathType = macro_string::MacroString;
+#[cfg(not(feature = "macro-string"))]
+type PathType = syn::LitStr;
+
+trait EvaluateString {
+    fn evaluate_string(&self) -> Result<String>;
+}
+
+#[cfg(feature = "macro-string")]
+impl EvaluateString for macro_string::MacroString {
+    fn evaluate_string(&self) -> Result<String> {
+        self.eval()
+    }
+}
+
+#[cfg(not(feature = "macro-string"))]
+impl EvaluateString for syn::LitStr {
+    fn evaluate_string(&self) -> Result<String> {
+        Ok(self.value())
+    }
+}
+
 enum Opt {
     World(syn::LitStr),
-    Path(Span, Vec<syn::LitStr>),
+    Path(Span, Vec<PathType>),
     Inline(syn::LitStr),
     UseStdFeature,
     RawStrings,
@@ -387,11 +415,13 @@ impl Parse for Opt {
             if input.peek(token::Bracket) {
                 let contents;
                 syn::bracketed!(contents in input);
-                let list = Punctuated::<_, Token![,]>::parse_terminated(&contents)?;
-                Ok(Opt::Path(list.span(), list.into_iter().collect()))
+                let span = input.span();
+                let list = Punctuated::<PathType, Token![,]>::parse_terminated(&contents)?;
+                Ok(Opt::Path(span, list.into_iter().collect()))
             } else {
-                let path: LitStr = input.parse()?;
-                Ok(Opt::Path(path.span(), vec![path]))
+                let span = input.span();
+                let path: PathType = input.parse()?;
+                Ok(Opt::Path(span, vec![path]))
             }
         } else if l.peek(kw::inline) {
             input.parse::<kw::inline>()?;

crates/guest-rust/macro/src/lib.rs

@@ -53,3 +53,12 @@ pub mod _3_world_exports;
 #[doc = include_str!("./examples/_4_exported_resources.rs")]
 /// ```
 pub mod _4_exported_resources;
+
+/// An example of importing a compile-time directory of wit files.
+///
+/// The code used to generate this module is:
+///
+/// ```rust
+#[doc = include_str!("./examples/_5_import_directory.rs")]
+/// ```
+pub mod _5_import_directory;

crates/guest-rust/src/examples.rs

@@ -0,0 +1,6 @@
+crate::generate!({
+    path: concat!(
+        env!("CARGO_MANIFEST_DIR"),
+        "/wit/"
+    ),
+});

crates/guest-rust/src/examples/_5_import_directory.rs

@@ -0,0 +1,5 @@
+package example:import-directory;
+
+world import-directory {
+    import hello: func() -> string;
+}