feat(target): use --target [native, wasm, all]

Author: stackmystack

CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+- Add support for `--target`:
+  - `native` for native shared libraries, `dylib` or `so` (default).
+  - `wasm` for web assembly.
+  - `all` for all of the above.
+
 ## [1.4.0] - 2025-03-22
 
 ### Features

Cargo.toml

@@ -8,7 +8,7 @@ build = "build.rs"
 description = "A downloader/builder of many tree-sitter parsers"
 edition = "2021"
 name = "tsdl"
-version = "1.4.0" # managed by release.sh
+version = "1.4.0"                                                # managed by release.sh
 license = "MIT"
 
 [lib]

src/args.rs

@@ -107,6 +107,35 @@ impl Command {
     }
 }
 
+#[derive(clap::ValueEnum, Clone, Copy, Debug, Deserialize, Diff, PartialEq, Eq, Serialize)]
+#[diff(attr(
+    #[derive(Debug, PartialEq)]
+))]
+#[serde(rename_all = "kebab-case")]
+pub enum Target {
+    Native,
+    Wasm,
+    All,
+}
+
+impl Default for Target {
+    fn default() -> Self {
+        Self::Native
+    }
+}
+
+impl Target {
+    #[must_use]
+    pub fn native(&self) -> bool {
+        matches!(self, Self::All | Self::Native)
+    }
+
+    #[must_use]
+    pub fn wasm(&self) -> bool {
+        matches!(self, Self::All | Self::Wasm)
+    }
+}
+
 #[allow(clippy::struct_excessive_bools)]
 #[derive(clap::Args, Clone, Debug, Deserialize, Diff, PartialEq, Eq, Serialize)]
 #[diff(attr(
@@ -153,6 +182,9 @@ pub struct BuildCommand {
     #[serde(default)]
     pub show_config: bool,
 
+    #[arg(short, long, value_enum, default_value_t = Target::default())]
+    pub target: Target,
+
     #[command(flatten)]
     #[serde(default)]
     pub tree_sitter: TreeSitter,
@@ -161,14 +193,15 @@ pub struct BuildCommand {
 impl Default for BuildCommand {
     fn default() -> Self {
         Self {
-            languages: None,
-            parsers: None,
             build_dir: PathBuf::from(TSDL_BUILD_DIR),
             fresh: TSDL_FRESH,
+            languages: None,
             ncpus: num_cpus::get(),
             out_dir: PathBuf::from(TSDL_OUT_DIR),
+            parsers: None,
             prefix: String::from(TSDL_PREFIX),
             show_config: TSDL_SHOW_CONFIG,
+            target: Target::default(),
             tree_sitter: TreeSitter::default(),
         }
     }

src/build.rs

@@ -10,7 +10,7 @@ use tokio::time;
 use url::Url;
 
 use crate::{
-    args::{BuildCommand, ParserConfig},
+    args::{BuildCommand, ParserConfig, Target},
     config,
     consts::TSDL_FROM,
     display::{Handle, Progress, ProgressState, TICK_CHARS},
@@ -65,6 +65,7 @@ fn build(command: &BuildCommand, progress: Progress) -> Result<()> {
         command.build_dir.clone(),
         command.out_dir.clone(),
         &command.prefix,
+        command.target,
     )?;
     create_dir_all(&command.out_dir)
         .into_diagnostic()
@@ -87,6 +88,7 @@ async fn update_screen(progress: Arc<Mutex<Progress>>) {
     }
 }
 
+#[allow(clippy::too_many_arguments)]
 fn collect_languages(
     ts_cli: PathBuf,
     progress: Arc<Mutex<Progress>>,
@@ -95,12 +97,14 @@ fn collect_languages(
     build_dir: PathBuf,
     out_dir: PathBuf,
     prefix: &str,
+    target: Target,
 ) -> Result<Vec<Language>, error::LanguageCollection> {
     let (res, errs) = unique_languages(
         ts_cli,
         build_dir,
         out_dir,
         prefix,
+        target,
         requested_languages,
         defined_parsers,
         progress,
@@ -120,11 +124,13 @@ type Languages = (
 );
 
 #[allow(clippy::needless_pass_by_value)]
+#[allow(clippy::too_many_arguments)]
 fn unique_languages(
     ts_cli: PathBuf,
     build_dir: PathBuf,
     out_dir: PathBuf,
     prefix: &str,
+    target: Target,
     requested_languages: Option<&Vec<String>>,
     defined_parsers: Option<&BTreeMap<String, ParserConfig>>,
     progress: Arc<Mutex<Progress>>,
@@ -155,6 +161,7 @@ fn unique_languages(
                     out_dir.canon().unwrap(),
                     prefix.into(),
                     repo,
+                    target,
                     ts_cli.clone(),
                 )
             })

src/parser.rs

@@ -11,6 +11,7 @@ use tracing::warn;
 use url::Url;
 
 use crate::{
+    args::Target,
     display::{Handle, ProgressHandle},
     error,
     git::{clone_fast, Ref},
@@ -19,6 +20,7 @@ use crate::{
 };
 
 pub const NUM_STEPS: usize = 3;
+const WASM_EXTENSION: &str = "wasm";
 
 pub async fn build_languages(languages: Vec<Language>) -> Result<()> {
     let buffer = if languages.is_empty() {
@@ -57,6 +59,7 @@ pub struct Language {
     out_dir: PathBuf,
     prefix: String,
     repo: Url,
+    target: Target,
     ts_cli: Arc<PathBuf>,
 }
 
@@ -72,6 +75,7 @@ impl Language {
         out_dir: PathBuf,
         prefix: String,
         repo: Url,
+        target: Target,
         ts_cli: Arc<PathBuf>,
     ) -> Self {
         Language {
@@ -83,6 +87,7 @@ impl Language {
             out_dir,
             prefix,
             repo,
+            target,
             ts_cli,
         }
     }
@@ -124,7 +129,24 @@ impl Language {
         } else {
             warn!("I don't know how to generate parsers when a script/cmd is specified (it's typescript's fault)");
         }
-        self.build(&dir).await?;
+
+        if self.target.native() {
+            self.handle.msg(format!(
+                "Building {} native parser: {}",
+                self.git_ref,
+                dir.file_name().unwrap().to_str().unwrap(),
+            ));
+            self.build(&dir, DLL_EXTENSION).await?;
+        }
+
+        if self.target.wasm() {
+            self.handle.msg(format!(
+                "Building {} wasm parser: {}",
+                self.git_ref,
+                dir.file_name().unwrap().to_str().unwrap(),
+            ));
+            self.build(&dir, WASM_EXTENSION).await?;
+        }
         self.handle.msg(format!(
             "Copying {} parser: {}",
             self.git_ref,
@@ -134,13 +156,25 @@ impl Language {
         Ok(())
     }
 
-    async fn build(&self, dir: &Path) -> Result<()> {
+    async fn build(&self, dir: &Path, ext: &str) -> Result<()> {
+        let effective_name = dir
+            .file_name()
+            .map(|n| {
+                n.to_string_lossy()
+                    .strip_prefix("tree-sitter-")
+                    .map_or_else(|| n.to_string_lossy().to_string(), str::to_string)
+            })
+            .unwrap();
         self.build_script
             .as_ref()
             .map_or_else(
                 || {
                     let mut cmd = Command::new(&*self.ts_cli);
                     cmd.arg("build");
+                    if ext == WASM_EXTENSION {
+                        cmd.arg("--wasm");
+                    }
+                    cmd.args(["--output", &format!("{effective_name}.{ext}")]);
                     cmd
                 },
                 |script| Command::from_str(script),
@@ -197,22 +231,27 @@ impl Language {
             .collect()
     }
 
-    async fn copy(&self, dir: impl Into<PathBuf>) -> Result<()> {
-        let dir = dir.into();
-        let prefix = &self.prefix;
-        let dll = self.find_dll_files(&dir).await?;
-        let name = Self::extract_parser_name(&dll);
-        let dst = self
-            .out_dir
-            .clone()
-            .join(format!("{prefix}{name}.{DLL_EXTENSION}"));
+    async fn copy(&self, dir: &Path) -> Result<()> {
+        if self.target.native() {
+            self.do_copy(dir, DLL_EXTENSION).await?;
+        }
+        if self.target.wasm() {
+            self.do_copy(dir, WASM_EXTENSION).await?;
+        }
+        Ok(())
+    }
 
+    async fn do_copy(&self, dir: &Path, ext: &str) -> Result<(), miette::Error> {
+        let dll = self.find_dll_files(dir, ext).await?;
+        let name = Self::extract_parser_name(&dll, ext);
+        let prefix = &self.prefix;
+        let dst = self.out_dir.clone().join(format!("{prefix}{name}.{ext}"));
         fs::copy(&dll, &dst)
             .await
             .into_diagnostic()
             .wrap_err_with(|| format!("cp {} {}", &dll.display(), dst.display()))
-            .map_err(|err| self.create_copy_error(&dll, err.to_string()).into())
-            .and(Ok(()))
+            .map_err(|err| self.create_copy_error(&dll, err.to_string()))?;
+        Ok(())
     }
 
     async fn clone(&self) -> Result<()> {
@@ -249,37 +288,35 @@ impl Language {
             .and(Ok(()))
     }
 
-    async fn find_dll_files(&self, dir: &Path) -> Result<PathBuf> {
+    async fn find_dll_files(&self, dir: &Path, ext: &str) -> Result<PathBuf> {
         let mut files = fs::read_dir(&dir).await.unwrap();
         let mut dlls = Vec::with_capacity(1);
         while let Ok(Some(entry)) = files.next_entry().await {
             let file_name = entry.file_name();
             let name = file_name.as_os_str().to_str().unwrap();
-            if entry.file_type().await.unwrap().is_file()
-                && name.ends_with(&format!(".{DLL_EXTENSION}"))
-            {
+            if entry.file_type().await.unwrap().is_file() && name.ends_with(&format!(".{ext}")) {
                 dlls.push(dir.join(name));
             }
         }
         // Error handling for no DLLs or too many DLLs
         match dlls.len() {
             0 => Err(self
-                .create_copy_error(dir, format!("Couldn't find any {DLL_EXTENSION} file"))
+                .create_copy_error(dir, format!("Couldn't find any {ext} file"))
                 .into()),
             n if n > 1 => Err(self
-                .create_copy_error(dir, format!("Found many {DLL_EXTENSION} files: {dlls:?}"))
+                .create_copy_error(dir, format!("Found many {ext} files: {dlls:?}"))
                 .into()),
             _ => Ok(dlls[0].clone()),
         }
     }
 
-    fn extract_parser_name(dll_path: &Path) -> String {
+    fn extract_parser_name(dll_path: &Path, ext: &str) -> String {
         let mut name = dll_path
             .file_name()
             .and_then(|n| n.to_str())
             .map(String::from)
             .unwrap();
-        if name == format!("parser.{DLL_EXTENSION}") {
+        if name == format!("parser.{ext}") {
             name = dll_path
                 .parent()
                 .and_then(|p| p.file_name())
@@ -290,10 +327,8 @@ impl Language {
         if name.starts_with("libtree-sitter-") {
             name = name.trim_start_matches("libtree-sitter-").to_string();
         }
-        if name.ends_with(&format!(".{DLL_EXTENSION}")) {
-            name = name
-                .trim_end_matches(&format!(".{DLL_EXTENSION}"))
-                .to_string();
+        if name.ends_with(&format!(".{ext}")) {
+            name = name.trim_end_matches(&format!(".{ext}")).to_string();
         }
         name
     }