Add importing strings as JsString

CHANGELOG.md

@@ -72,6 +72,9 @@
 * Added an experimental Node.JS ES module target, in comparison the current `node` target uses CommonJS, with `--target experimental-nodejs-module` or when testing with `wasm_bindgen_test_configure!(run_in_node_experimental)`.
  [#4027](https://github.com/rustwasm/wasm-bindgen/pull/4027)
 
+* Added importing strings as `JsString` through `#[wasm_bindgen(static_string)] static STRING: JsString = "a string literal";`.
+ [#4055](https://github.com/rustwasm/wasm-bindgen/pull/4055)
+
 ### Changed
 
 * Stabilize Web Share API.

crates/backend/src/ast.rs

@@ -29,6 +29,8 @@ pub struct Program {
  pub inline_js: Vec<String>,
  /// Path to wasm_bindgen
  pub wasm_bindgen: Path,
+ /// Path to js_sys
+ pub js_sys: Path,
  /// Path to wasm_bindgen_futures
  pub wasm_bindgen_futures: Path,
 }
@@ -44,6 +46,7 @@ impl Default for Program {
  typescript_custom_sections: Default::default(),
  inline_js: Default::default(),
  wasm_bindgen: syn::parse_quote! { wasm_bindgen },
+ js_sys: syn::parse_quote! { js_sys },
  wasm_bindgen_futures: syn::parse_quote! { wasm_bindgen_futures },
  }
  }
@@ -160,6 +163,8 @@ pub enum ImportKind {
  Function(ImportFunction),
  /// Importing a static value
  Static(ImportStatic),
+ /// Importing a static string
+ String(ImportString),
  /// Importing a type/class
  Type(ImportType),
  /// Importing a JS enum
@@ -272,6 +277,26 @@ pub struct ImportStatic {
  pub wasm_bindgen: Path,
 }
 
+/// The type of a static string being imported
+#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq))]
+#[derive(Clone)]
+pub struct ImportString {
+ /// The visibility of this static string in Rust
+ pub vis: syn::Visibility,
+ /// The type specified by the user, which we only use to show an error if the wrong type is used.
+ pub ty: syn::Type,
+ /// The name of the shim function used to access this static
+ pub shim: Ident,
+ /// The name of this static on the Rust side
+ pub rust_name: Ident,
+ /// Path to wasm_bindgen
+ pub wasm_bindgen: Path,
+ /// Path to js_sys
+ pub js_sys: Path,
+ /// The string to export.
+ pub string: String,
+}
+
 /// The metadata for a type being imported
 #[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq))]
 #[derive(Clone)]
@@ -502,6 +527,7 @@ impl ImportKind {
  match *self {
  ImportKind::Function(_) => true,
  ImportKind::Static(_) => false,
+ ImportKind::String(_) => false,
  ImportKind::Type(_) => false,
  ImportKind::Enum(_) => false,
  }

crates/backend/src/codegen.rs

@@ -9,6 +9,7 @@ use quote::quote_spanned;
 use quote::{quote, ToTokens};
 use std::collections::{HashMap, HashSet};
 use std::sync::Mutex;
+use syn::parse_quote;
 use syn::spanned::Spanned;
 use wasm_bindgen_shared as shared;
 
@@ -846,6 +847,7 @@ impl TryToTokens for ast::ImportKind {
  match *self {
  ast::ImportKind::Function(ref f) => f.try_to_tokens(tokens)?,
  ast::ImportKind::Static(ref s) => s.to_tokens(tokens),
+ ast::ImportKind::String(ref s) => s.to_tokens(tokens),
  ast::ImportKind::Type(ref t) => t.to_tokens(tokens),
  ast::ImportKind::Enum(ref e) => e.to_tokens(tokens),
  }
@@ -1477,6 +1479,7 @@ impl<'a> ToTokens for DescribeImport<'a> {
  let f = match *self.kind {
  ast::ImportKind::Function(ref f) => f,
  ast::ImportKind::Static(_) => return,
+ ast::ImportKind::String(_) => return,
  ast::ImportKind::Type(_) => return,
  ast::ImportKind::Enum(_) => return,
  };
@@ -1641,44 +1644,19 @@ impl ToTokens for ast::Enum {
 
 impl ToTokens for ast::ImportStatic {
  fn to_tokens(&self, into: &mut TokenStream) {
- let name = &self.rust_name;
  let ty = &self.ty;
- let shim_name = &self.shim;
- let vis = &self.vis;
- let wasm_bindgen = &self.wasm_bindgen;
-
- let abi_ret = quote! {
- #wasm_bindgen::convert::WasmRet<<#ty as #wasm_bindgen::convert::FromWasmAbi>::Abi>
- };
- (quote! {
- #[automatically_derived]
- #vis static #name: #wasm_bindgen::JsStatic<#ty> = {
- fn init() -> #ty {
- #[link(wasm_import_module = "__wbindgen_placeholder__")]
- #[cfg(all(target_arch = "wasm32", target_os = "unknown"))]
- extern "C" {
- fn #shim_name() -> #abi_ret;
- }
-
- #[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
- unsafe fn #shim_name() -> #abi_ret {
- panic!("cannot access imported statics on non-wasm targets")
- }
-
- unsafe {
- <#ty as #wasm_bindgen::convert::FromWasmAbi>::from_abi(#shim_name().join())
- }
- }
- thread_local!(static _VAL: #ty = init(););
- #wasm_bindgen::JsStatic {
- __inner: &_VAL,
- }
- };
- })
+ static_import(
+ &self.vis,
+ &self.rust_name,
+ &self.wasm_bindgen,
+ ty,
+ ty,
+ &self.shim,
+ )
  .to_tokens(into);
 
  Descriptor {
- ident: shim_name,
+ ident: &self.shim,
  inner: quote! {
  <#ty as WasmDescribe>::describe();
  },
@@ -1689,6 +1667,61 @@ impl ToTokens for ast::ImportStatic {
  }
 }
 
+impl ToTokens for ast::ImportString {
+ fn to_tokens(&self, into: &mut TokenStream) {
+ let js_sys = &self.js_sys;
+ let actual_ty: syn::Type = parse_quote!(#js_sys::JsString);
+
+ static_import(
+ &self.vis,
+ &self.rust_name,
+ &self.wasm_bindgen,
+ &actual_ty,
+ &self.ty,
+ &self.shim,
+ )
+ .to_tokens(into);
+ }
+}
+
+fn static_import(
+ vis: &syn::Visibility,
+ name: &Ident,
+ wasm_bindgen: &syn::Path,
+ actual_ty: &syn::Type,
+ ty: &syn::Type,
+ shim_name: &Ident,
+) -> TokenStream {
+ let abi_ret = quote! {
+ #wasm_bindgen::convert::WasmRet<<#ty as #wasm_bindgen::convert::FromWasmAbi>::Abi>
+ };
+ quote! {
+ #[automatically_derived]
+ #vis static #name: #wasm_bindgen::JsStatic<#actual_ty> = {
+ fn init() -> #ty {
+ #[link(wasm_import_module = "__wbindgen_placeholder__")]
+ #[cfg(all(target_arch = "wasm32", target_os = "unknown"))]
+ extern "C" {
+ fn #shim_name() -> #abi_ret;
+ }
+
+ #[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
+ unsafe fn #shim_name() -> #abi_ret {
+ panic!("cannot access imported statics on non-wasm targets")
+ }
+
+ unsafe {
+ <#ty as #wasm_bindgen::convert::FromWasmAbi>::from_abi(#shim_name().join())
+ }
+ }
+ thread_local!(static _VAL: #ty = init(););
+ #wasm_bindgen::JsStatic {
+ __inner: &_VAL,
+ }
+ };
+ }
+}
+
 /// Emits the necessary glue tokens for "descriptor", generating an appropriate
 /// symbol name as well as attributes around the descriptor function itself.
 struct Descriptor<'a, T> {

crates/backend/src/encode.rs

@@ -297,6 +297,7 @@ fn shared_import_kind<'a>(
  Ok(match i {
  ast::ImportKind::Function(f) => ImportKind::Function(shared_import_function(f, intern)?),
  ast::ImportKind::Static(f) => ImportKind::Static(shared_import_static(f, intern)),
+ ast::ImportKind::String(f) => ImportKind::String(shared_import_string(f, intern)),
  ast::ImportKind::Type(f) => ImportKind::Type(shared_import_type(f, intern)),
  ast::ImportKind::Enum(f) => ImportKind::Enum(shared_import_enum(f, intern)),
  })
@@ -332,6 +333,13 @@ fn shared_import_static<'a>(i: &'a ast::ImportStatic, intern: &'a Interner) -> I
  }
 }
 
+fn shared_import_string<'a>(i: &'a ast::ImportString, intern: &'a Interner) -> ImportString<'a> {
+ ImportString {
+ shim: intern.intern(&i.shim),
+ string: &i.string,
+ }
+}
+
 fn shared_import_type<'a>(i: &'a ast::ImportType, intern: &'a Interner) -> ImportType<'a> {
  ImportType {
  name: &i.js_name,

crates/cli-support/src/js/mod.rs

@@ -3067,6 +3067,19 @@ impl<'a> Context<'a> {
  self.import_name(js)
  }
 
+ AuxImport::String(string) => {
+ assert!(kind == AdapterJsImportKind::Normal);
+ assert!(!variadic);
+ assert_eq!(args.len(), 0);
+
+ let mut escaped = String::with_capacity(string.len());
+ string.chars().for_each(|c| match c {
+ '`' | '\\' | '$' => escaped.extend(['\\', c]),
+ _ => escaped.extend([c]),
+ });
+ Ok(format!("`{escaped}`"))
+ }
+
  AuxImport::Closure {
  dtor,
  mutable,

crates/cli-support/src/wit/mod.rs

@@ -567,6 +567,7 @@ impl<'a> Context<'a> {
  match &import.kind {
  decode::ImportKind::Function(f) => self.import_function(&import, f),
  decode::ImportKind::Static(s) => self.import_static(&import, s),
+ decode::ImportKind::String(s) => self.import_string(s),
  decode::ImportKind::Type(t) => self.import_type(&import, t),
  decode::ImportKind::Enum(_) => Ok(()),
  }
@@ -803,6 +804,32 @@ impl<'a> Context<'a> {
  Ok(())
  }
 
+ fn import_string(&mut self, string: &decode::ImportString<'_>) -> Result<(), Error> {
+ let (import_id, _id) = match self.function_imports.get(string.shim) {
+ Some(pair) => *pair,
+ None => return Ok(()),
+ };
+
+ // Register the signature of this imported shim
+ let id = self.import_adapter(
+ import_id,
+ Function {
+ arguments: Vec::new(),
+ shim_idx: 0,
+ ret: Descriptor::Externref,
+ inner_ret: None,
+ },
+ AdapterJsImportKind::Normal,
+ )?;
+
+ // And then save off that this function is is an instanceof shim for an
+ // imported item.
+ self.aux
+ .import_map
+ .insert(id, AuxImport::String(string.string.to_owned()));
+ Ok(())
+ }
+
  fn import_type(
  &mut self,
  import: &decode::Import<'_>,

crates/cli-support/src/wit/nonstandard.rs

@@ -220,6 +220,9 @@ pub enum AuxImport {
  /// `JsImport`.
  Static(JsImport),
 
+ /// This import is expected to be a shim that returns an exported `JsString`.
+ String(String),
+
  /// This import is intended to manufacture a JS closure with the given
  /// signature and then return that back to Rust.
  Closure {