tsrs 0.18.0-aarch64-linux-gnu

data/rust/Cargo.toml

@@ -0,0 +1,39 @@
+[workspace]
+
+[package]
+name = "tsrs-ruby-ffi"
+edition = "2021"
+authors = ["Marco Roth <marco.roth@intergga.ch>"]
+description = "C FFI bindings for tsrs, used by the tsrs gem"
+license = "MIT"
+repository = "https://github.com/marcoroth/tsrs-ruby"
+publish = false
+
+[lib]
+name = "tsrs_ffi"
+path = "src/lib.rs"
+crate-type = ["cdylib", "staticlib", "rlib"]
+
+# tsrs does not publish its crates, so they come from the release tag. See .github/workflows/upstream.yml.
+[dependencies]
+tsrs_api = { git = "https://github.com/oxc-project/tsrs", tag = "v0.18.0" }
+tsrs_ast = { git = "https://github.com/oxc-project/tsrs", tag = "v0.18.0" }
+tsrs_compiler = { git = "https://github.com/oxc-project/tsrs", tag = "v0.18.0" }
+tsrs_contentmapper = { git = "https://github.com/oxc-project/tsrs", tag = "v0.18.0" }
+tsrs_core = { git = "https://github.com/oxc-project/tsrs", tag = "v0.18.0" }
+tsrs_execute = { git = "https://github.com/oxc-project/tsrs", tag = "v0.18.0" }
+tsrs_project = { git = "https://github.com/oxc-project/tsrs", tag = "v0.18.0" }
+tsrs_tsoptions = { git = "https://github.com/oxc-project/tsrs", tag = "v0.18.0" }
+tsrs_vfs = { git = "https://github.com/oxc-project/tsrs", tag = "v0.18.0" }
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+
+[build-dependencies]
+cbindgen = "0.29"
+
+[profile.release]
+opt-level = 3
+lto = "fat"
+codegen-units = 1
+strip = "symbols"
+panic = "unwind"

data/rust/build.rs

@@ -0,0 +1,77 @@
+use std::env;
+use std::fs;
+use std::path::PathBuf;
+
+fn main() {
+  let crate_dir = env::var("CARGO_MANIFEST_DIR").unwrap();
+  let header_path = PathBuf::from(&crate_dir).join("../ext/tsrs/include/tsrs.h");
+
+  if let Ok(bindings) = cbindgen::generate(&crate_dir) {
+    if let Some(parent) = header_path.parent() {
+      let _ = std::fs::create_dir_all(parent);
+    }
+
+    bindings.write_to_file(&header_path);
+  }
+
+  let lock_path = PathBuf::from(&crate_dir).join("Cargo.lock");
+
+  println!("cargo:rerun-if-changed={}", lock_path.display());
+
+  println!(
+    "cargo:rerun-if-changed={}",
+    PathBuf::from(&crate_dir).join("src").display()
+  );
+
+  println!(
+    "cargo:rerun-if-changed={}",
+    PathBuf::from(&crate_dir).join("cbindgen.toml").display()
+  );
+
+  let version_rb_path = PathBuf::from(&crate_dir).join("../lib/tsrs/version.rb");
+
+  println!("cargo:rerun-if-changed={}", version_rb_path.display());
+
+  println!(
+    "cargo:rustc-env=TSRS_VERSION={}",
+    locked_version(&lock_path, "tsrs_api")
+  );
+
+  println!("cargo:rustc-env=GEM_VERSION={}", gem_version(&version_rb_path));
+}
+
+fn gem_version(version_rb_path: &PathBuf) -> String {
+  let Ok(source) = fs::read_to_string(version_rb_path) else {
+    return "unknown".to_string();
+  };
+
+  for line in source.lines() {
+    let Some(rest) = line.trim().strip_prefix("VERSION = ") else {
+      continue;
+    };
+
+    return rest.trim().trim_matches('"').to_string();
+  }
+
+  "unknown".to_string()
+}
+
+fn locked_version(lock_path: &PathBuf, package: &str) -> String {
+  let Ok(lock) = fs::read_to_string(lock_path) else {
+    return "unknown".to_string();
+  };
+
+  let mut lines = lock.lines();
+
+  while let Some(line) = lines.next() {
+    if line.trim() != format!("name = \"{package}\"") {
+      continue;
+    }
+
+    if let Some(version) = lines.next().and_then(|next| next.trim().strip_prefix("version = ")) {
+      return version.trim_matches('"').to_string();
+    }
+  }
+
+  "unknown".to_string()
+}

data/rust/cbindgen.toml

@@ -0,0 +1,25 @@
+language = "C"
+header = """/* Generated by cbindgen, do not edit manually */
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <stddef.h>"""
+include_guard = "TSRS_H"
+no_includes = true
+
+[export]
+include = [
+  "TsrsResult",
+  "TsrsErrorCode",
+  "TsrsSession",
+]
+
+[enum]
+rename_variants = "ScreamingSnakeCase"
+prefix_with_name = true
+
+[fn]
+sort_by = "None"
+
+[parse]
+parse_deps = false

data/rust/rust-toolchain.toml

@@ -0,0 +1,5 @@
+# tsrs requires the Rust version its workspace pins (rust-version in its Cargo.toml).
+[toolchain]
+channel = "1.99.1"
+components = ["clippy", "rustfmt"]
+profile = "minimal"

data/rust/rustfmt.toml

@@ -0,0 +1,3 @@
+tab_spaces = 2
+max_width = 120
+edition = "2021"

data/rust/src/check.rs

@@ -0,0 +1,136 @@
+use std::io::Write;
+use std::sync::{Arc, Mutex};
+use std::time::{Duration, Instant};
+
+use serde::Serialize;
+use serde_json::value::RawValue;
+use tsrs_ast::Diagnostic;
+use tsrs_core::{tspath, P};
+use tsrs_execute::tsc::{ReadWriteCloser, System};
+use tsrs_vfs::{bundled, osvfs, FS};
+
+use crate::options::CheckRequest;
+use crate::result::{TsrsErrorCode, TsrsResult};
+use crate::status::Status;
+
+#[derive(Serialize)]
+struct CheckPayload {
+  status: Status,
+  output: String,
+  diagnostics: Box<RawValue>,
+}
+
+struct RubySys {
+  output: Mutex<String>,
+  sink: Box<dyn Fn(P<Diagnostic>) + Send + Sync>,
+  fs: Arc<dyn FS>,
+  default_library_path: String,
+  cwd: String,
+  start: Instant,
+}
+
+impl System for RubySys {
+  fn fs(&self) -> Arc<dyn FS> {
+    Arc::clone(&self.fs)
+  }
+
+  fn default_library_path(&self) -> &str {
+    &self.default_library_path
+  }
+
+  fn get_current_directory(&self) -> &str {
+    &self.cwd
+  }
+
+  fn write(&self, text: &str) {
+    if let Ok(mut output) = self.output.lock() {
+      output.push_str(text);
+    }
+  }
+
+  fn flush(&self) {}
+
+  fn write_output_is_tty(&self) -> bool {
+    false
+  }
+
+  fn get_environment_variable(&self, name: &str) -> Option<String> {
+    std::env::var(name).ok()
+  }
+
+  fn spawn(
+    &self,
+    command: &[String],
+    dir: &str,
+    stderr: Option<Box<dyn Write + Send>>,
+  ) -> Result<ReadWriteCloser, String> {
+    tsrs_contentmapper::spawn_process(command, dir, stderr)
+  }
+
+  fn now(&self) -> Instant {
+    Instant::now()
+  }
+
+  fn since_start(&self) -> Duration {
+    self.start.elapsed()
+  }
+
+  fn diagnostic_sink(&self) -> Option<&(dyn Fn(P<Diagnostic>) + Sync)> {
+    Some(&*self.sink as &(dyn Fn(P<Diagnostic>) + Sync))
+  }
+}
+
+pub fn check(request_json: String) -> TsrsResult {
+  let request: CheckRequest = match serde_json::from_str(&request_json) {
+    Ok(request) => request,
+    Err(error) => return TsrsResult::error(TsrsErrorCode::Option, error.to_string()),
+  };
+
+  if request.args.iter().any(|arg| is_build_flag(arg)) {
+    return TsrsResult::error(TsrsErrorCode::Option, "build mode (--build) is not supported");
+  }
+
+  // The parsed command line keeps referring to the system, so it is leaked, as tsrs's CLI does.
+  let collected: Arc<Mutex<Vec<P<Diagnostic>>>> = Arc::new(Mutex::new(Vec::new()));
+  let sink_target = Arc::clone(&collected);
+
+  let sys: &'static RubySys = Box::leak(Box::new(RubySys {
+    output: Mutex::new(String::new()),
+    sink: Box::new(move |diagnostic| {
+      if let Ok(mut list) = sink_target.lock() {
+        list.push(diagnostic);
+      }
+    }),
+    fs: Arc::new(bundled::wrap_fs(osvfs::fs())),
+    default_library_path: bundled::default_lib_path(),
+    cwd: tspath::normalize_path(&request.cwd),
+    start: Instant::now(),
+  }));
+
+  let result = tsrs_execute::execute::command_line(sys, request.args);
+
+  let diagnostics = std::mem::take(&mut *collected.lock().unwrap_or_else(|poisoned| poisoned.into_inner()));
+  let output = std::mem::take(&mut *sys.output.lock().unwrap_or_else(|poisoned| poisoned.into_inner()));
+
+  let diagnostics = tsrs_api::diagnostics::diagnostic_responses(&diagnostics);
+
+  let diagnostics = match tsrs_core::json::marshal(&diagnostics).map(RawValue::from_string) {
+    Ok(Ok(diagnostics)) => diagnostics,
+    _ => return TsrsResult::error(TsrsErrorCode::Internal, "the diagnostics could not be serialized"),
+  };
+
+  let payload = CheckPayload {
+    status: result.status.into(),
+    output,
+    diagnostics,
+  };
+
+  match serde_json::to_string(&payload) {
+    Ok(json) => TsrsResult::value(json),
+    Err(error) => TsrsResult::error(TsrsErrorCode::Internal, error.to_string()),
+  }
+}
+
+fn is_build_flag(arg: &str) -> bool {
+  matches!(arg.to_lowercase().as_str(), "-b" | "--b" | "-build" | "--build")
+}

data/rust/src/lib.rs

@@ -0,0 +1,213 @@
+use std::ffi::{CStr, CString};
+use std::os::raw::c_char;
+use std::panic::{catch_unwind, AssertUnwindSafe};
+
+mod check;
+mod options;
+mod result;
+mod session;
+mod status;
+mod transpile;
+mod worker;
+
+use result::{TsrsErrorCode, TsrsResult};
+use session::TsrsSession;
+
+/// # Safety
+///
+/// `source` and `options_json` must be valid, nul-terminated UTF-8 strings.
+#[no_mangle]
+pub unsafe extern "C" fn tsrs_transpile(source: *const c_char, options_json: *const c_char) -> TsrsResult {
+  transpile_with(source, options_json, false)
+}
+
+/// # Safety
+///
+/// `source` and `options_json` must be valid, nul-terminated UTF-8 strings.
+#[no_mangle]
+pub unsafe extern "C" fn tsrs_transpile_declaration(source: *const c_char, options_json: *const c_char) -> TsrsResult {
+  transpile_with(source, options_json, true)
+}
+
+/// # Safety
+///
+/// `options_json` must be a valid, nul-terminated UTF-8 string.
+#[no_mangle]
+pub unsafe extern "C" fn tsrs_check(options_json: *const c_char) -> TsrsResult {
+  let Some(options) = borrow(options_json) else {
+    return TsrsResult::error(TsrsErrorCode::Encoding, "options were not valid UTF-8");
+  };
+
+  let options = options.to_string();
+
+  guard(move || worker::run(move || check::check(options)))
+}
+
+/// # Safety
+///
+/// `cwd` must be a valid, nul-terminated UTF-8 string.
+#[no_mangle]
+pub unsafe extern "C" fn tsrs_session_new(cwd: *const c_char) -> *mut TsrsSession {
+  let Some(cwd) = borrow(cwd) else {
+    return std::ptr::null_mut();
+  };
+
+  let cwd = cwd.to_string();
+
+  catch_unwind(AssertUnwindSafe(|| Box::into_raw(Box::new(session::new(&cwd))))).unwrap_or(std::ptr::null_mut())
+}
+
+/// Taken before a check that runs without the GVL, so that freeing the original meanwhile cannot free the session.
+///
+/// # Safety
+///
+/// `session` must be a live pointer from `tsrs_session_new` or `tsrs_session_retain`.
+#[no_mangle]
+pub unsafe extern "C" fn tsrs_session_retain(session: *const TsrsSession) -> *mut TsrsSession {
+  match session.as_ref() {
+    Some(session) => Box::into_raw(Box::new(session.retain())),
+    None => std::ptr::null_mut(),
+  }
+}
+
+/// # Safety
+///
+/// `session` must be a live pointer from `tsrs_session_new` or `tsrs_session_retain`, and `options_json` a valid,
+/// nul-terminated UTF-8 string.
+#[no_mangle]
+pub unsafe extern "C" fn tsrs_session_check(session: *const TsrsSession, options_json: *const c_char) -> TsrsResult {
+  let Some(session) = session.as_ref() else {
+    return TsrsResult::error(TsrsErrorCode::Internal, "the session is gone");
+  };
+
+  let Some(options) = borrow(options_json) else {
+    return TsrsResult::error(TsrsErrorCode::Encoding, "options were not valid UTF-8");
+  };
+
+  let options = options.to_string();
+  let session = session.session();
+
+  guard(move || worker::run(move || session::check(&session, &options)))
+}
+
+/// The pointer stays valid until `tsrs_session_free`.
+///
+/// # Safety
+///
+/// `session` must be a live pointer from `tsrs_session_new` or `tsrs_session_retain`, or null.
+#[no_mangle]
+pub unsafe extern "C" fn tsrs_session_close(session: *const TsrsSession) {
+  if let Some(session) = session.as_ref() {
+    let _ = catch_unwind(AssertUnwindSafe(|| session.close()));
+  }
+}
+
+/// # Safety
+///
+/// `session` must be a pointer from `tsrs_session_new` or `tsrs_session_retain` that is not used afterwards, or null.
+#[no_mangle]
+pub unsafe extern "C" fn tsrs_session_free(session: *mut TsrsSession) {
+  if session.is_null() {
+    return;
+  }
+
+  let _ = catch_unwind(AssertUnwindSafe(|| drop(Box::from_raw(session))));
+}
+
+#[no_mangle]
+pub extern "C" fn tsrs_version() -> *mut c_char {
+  into_c_string(env!("GEM_VERSION"))
+}
+
+#[no_mangle]
+pub extern "C" fn tsrs_tsrs_version() -> *mut c_char {
+  into_c_string(env!("TSRS_VERSION"))
+}
+
+#[no_mangle]
+pub extern "C" fn tsrs_typescript_version() -> *mut c_char {
+  into_c_string(tsrs_core::version())
+}
+
+/// # Safety
+///
+/// `value` must be a pointer this library returned, and must not be used afterwards.
+#[no_mangle]
+pub unsafe extern "C" fn tsrs_string_free(value: *mut c_char) {
+  if value.is_null() {
+    return;
+  }
+
+  drop(CString::from_raw(value));
+}
+
+/// # Safety
+///
+/// `result` must be one this library returned, and must not be used afterwards.
+#[no_mangle]
+pub unsafe extern "C" fn tsrs_result_free(result: TsrsResult) {
+  if !result.value.is_null() {
+    drop(CString::from_raw(result.value));
+  }
+
+  if !result.error.is_null() {
+    drop(CString::from_raw(result.error));
+  }
+}
+
+#[no_mangle]
+pub extern "C" fn tsrs_panic_for_test() -> TsrsResult {
+  let previous = std::panic::take_hook();
+
+  std::panic::set_hook(Box::new(|_| {}));
+
+  let caught = worker::run(|| -> TsrsResult { panic!("a deliberate panic") });
+
+  std::panic::set_hook(previous);
+
+  caught
+}
+
+unsafe fn transpile_with(source: *const c_char, options_json: *const c_char, declaration: bool) -> TsrsResult {
+  let Some(source) = borrow(source) else {
+    return TsrsResult::error(TsrsErrorCode::Encoding, "source was not valid UTF-8");
+  };
+
+  let Some(options) = borrow(options_json) else {
+    return TsrsResult::error(TsrsErrorCode::Encoding, "options were not valid UTF-8");
+  };
+
+  let source = source.to_string();
+  let options = options.to_string();
+
+  guard(move || worker::run(move || transpile::transpile(source, options, declaration)))
+}
+
+fn guard(call: impl FnOnce() -> TsrsResult) -> TsrsResult {
+  match catch_unwind(AssertUnwindSafe(call)) {
+    Ok(result) => result,
+    Err(payload) => TsrsResult::error(TsrsErrorCode::Panic, panic_message(&payload)),
+  }
+}
+
+unsafe fn borrow<'a>(value: *const c_char) -> Option<&'a str> {
+  if value.is_null() {
+    return None;
+  }
+
+  CStr::from_ptr(value).to_str().ok()
+}
+
+pub(crate) fn panic_message(payload: &Box<dyn std::any::Any + Send>) -> String {
+  payload
+    .downcast_ref::<&str>()
+    .map(|message| (*message).to_string())
+    .or_else(|| payload.downcast_ref::<String>().cloned())
+    .unwrap_or_else(|| "tsrs panicked".to_string())
+}
+
+fn into_c_string(value: &str) -> *mut c_char {
+  CString::new(value)
+    .unwrap_or_else(|_| CString::new("unknown").expect("a string with no interior nul"))
+    .into_raw()
+}

data/rust/src/options.rs

@@ -0,0 +1,60 @@
+use serde::Deserialize;
+use tsrs_core::CompilerOptions;
+use tsrs_tsoptions::ParseConfigHost;
+use tsrs_vfs::FS;
+
+#[derive(Deserialize)]
+#[serde(deny_unknown_fields, rename_all = "camelCase")]
+pub struct TranspileRequest {
+  #[serde(default)]
+  pub file_name: String,
+  #[serde(default)]
+  pub args: Vec<String>,
+  #[serde(default = "yes")]
+  pub report_diagnostics: bool,
+}
+
+#[derive(Deserialize)]
+#[serde(deny_unknown_fields, rename_all = "camelCase")]
+pub struct CheckRequest {
+  pub cwd: String,
+  #[serde(default)]
+  pub args: Vec<String>,
+}
+
+fn yes() -> bool {
+  true
+}
+
+struct OptionsHost;
+
+impl ParseConfigHost for OptionsHost {
+  fn fs(&self) -> &dyn FS {
+    tsrs_vfs::osvfs::fs()
+  }
+
+  fn get_current_directory(&self) -> &str {
+    "/"
+  }
+}
+
+static OPTIONS_HOST: OptionsHost = OptionsHost;
+
+pub fn compiler_options(args: &[String]) -> Result<CompilerOptions, String> {
+  let parsed = tsrs_tsoptions::parse_command_line(args, &OPTIONS_HOST);
+
+  if let Some(error) = parsed.errors.first() {
+    return Err(error.localize());
+  }
+
+  if let Some(file) = parsed.file_names().first() {
+    return Err(format!("{file:?} is a file name, not a compiler option"));
+  }
+
+  Ok(
+    parsed
+      .compiler_options()
+      .map(|options| (*options).clone())
+      .unwrap_or_default(),
+  )
+}

data/rust/src/result.rs

@@ -0,0 +1,52 @@
+use std::ffi::CString;
+use std::os::raw::c_char;
+
+#[repr(C)]
+pub enum TsrsErrorCode {
+  None = 0,
+  Option,
+  Encoding,
+  Transpile,
+  Check,
+  Internal,
+  Panic,
+}
+
+#[repr(C)]
+pub struct TsrsResult {
+  pub value: *mut c_char,
+  pub value_len: usize,
+  pub error: *mut c_char,
+  pub code: TsrsErrorCode,
+}
+
+// SAFETY: the pointers are owned CStrings that nothing else refers to.
+unsafe impl Send for TsrsResult {}
+
+impl TsrsResult {
+  pub fn value(payload: String) -> Self {
+    let len = payload.len();
+
+    match CString::new(payload) {
+      Ok(value) => Self {
+        value: value.into_raw(),
+        value_len: len,
+        error: std::ptr::null_mut(),
+        code: TsrsErrorCode::None,
+      },
+      Err(_) => Self::error(TsrsErrorCode::Encoding, "the payload contained a null byte"),
+    }
+  }
+
+  pub fn error(code: TsrsErrorCode, message: impl Into<String>) -> Self {
+    let message = CString::new(message.into())
+      .unwrap_or_else(|_| CString::new("an error with no printable message").expect("no interior nul"));
+
+    Self {
+      value: std::ptr::null_mut(),
+      value_len: 0,
+      error: message.into_raw(),
+      code,
+    }
+  }
+}