tsrs 0.0.0 → 0.18.0

data/rust/src/session.rs

@@ -0,0 +1,194 @@
+use std::sync::Arc;
+
+use serde::{Deserialize, Serialize};
+use serde_json::value::RawValue;
+use tsrs_api::{Handler, Response, Session, SessionOptions};
+use tsrs_core::context::{with_checker_lifetime, CheckerLifetime, Context};
+use tsrs_core::json::Value;
+use tsrs_core::tspath;
+use tsrs_vfs::{bundled, osvfs, FS};
+
+use tsrs_execute::tsc::ExitStatus;
+
+use crate::result::{TsrsErrorCode, TsrsResult};
+use crate::status::Status;
+
+pub struct TsrsSession {
+  session: Arc<Session>,
+}
+
+#[derive(Deserialize)]
+#[serde(deny_unknown_fields)]
+struct CheckRequest {
+  project: String,
+}
+
+#[derive(Serialize)]
+struct CheckPayload {
+  status: Status,
+  diagnostics: Box<RawValue>,
+}
+
+pub fn new(cwd: &str) -> TsrsSession {
+  let fs: Arc<dyn FS> = Arc::new(bundled::wrap_fs(osvfs::fs()));
+
+  let session = Session::new(SessionOptions::new(
+    tspath::normalize_path(cwd),
+    bundled::default_lib_path(),
+    fs,
+    false,
+  ));
+
+  TsrsSession { session }
+}
+
+impl TsrsSession {
+  pub fn session(&self) -> Arc<Session> {
+    Arc::clone(&self.session)
+  }
+
+  pub fn retain(&self) -> TsrsSession {
+    TsrsSession {
+      session: self.session(),
+    }
+  }
+
+  pub fn close(&self) {
+    self.session.close();
+  }
+}
+
+pub fn check(session: &Session, request_json: &str) -> TsrsResult {
+  let request: CheckRequest = match serde_json::from_str(request_json) {
+    Ok(request) => request,
+    Err(error) => return TsrsResult::error(TsrsErrorCode::Option, error.to_string()),
+  };
+
+  let project = tspath::get_normalized_absolute_path(&request.project, session.current_directory());
+  let params = object("openProjects", Value::Array(vec![Value::String(project.clone())]));
+
+  let created = match call(session, "createSnapshot", &params) {
+    Ok(created) => created,
+    Err(message) => return TsrsResult::error(TsrsErrorCode::Check, message),
+  };
+
+  let Some(snapshot) = number(field(&created, "snapshot")) else {
+    return TsrsResult::error(TsrsErrorCode::Internal, "createSnapshot returned no snapshot");
+  };
+
+  let outcome = diagnostics(session, snapshot, &created, &project);
+
+  let _ = call(session, "release", &object("snapshot", Value::Number(snapshot as f64)));
+
+  match outcome {
+    Ok((status, diagnostics)) => {
+      let payload = CheckPayload {
+        status: status.into(),
+        diagnostics,
+      };
+
+      match serde_json::to_string(&payload) {
+        Ok(json) => TsrsResult::value(json),
+        Err(error) => TsrsResult::error(TsrsErrorCode::Internal, error.to_string()),
+      }
+    }
+    Err(result) => result,
+  }
+}
+
+fn diagnostics(
+  session: &Session,
+  snapshot: u64,
+  created: &Value,
+  project: &str,
+) -> Result<(ExitStatus, Box<RawValue>), TsrsResult> {
+  let id = project_id(created, project)
+    .ok_or_else(|| TsrsResult::error(TsrsErrorCode::Check, format!("no project was loaded from {project}")))?;
+
+  let data = session
+    .snapshot_data(snapshot)
+    .map_err(|error| TsrsResult::error(TsrsErrorCode::Internal, error.to_string()))?;
+
+  let program = data
+    .get_program(&tsrs_project::ID(id))
+    .map_err(|error| TsrsResult::error(TsrsErrorCode::Check, error.to_string()))?;
+
+  // As tsc collects them before emitting (tsrs_execute/src/tsc/emit.rs).
+  let ctx = with_checker_lifetime(&Context::background(), CheckerLifetime::Diagnostics);
+  let all = tsrs_compiler::get_diagnostics_of_any_program(
+    &ctx,
+    program,
+    None,
+    false,
+    &mut |ctx, file| program.get_bind_diagnostics(ctx, file),
+    &mut |ctx, file| program.get_semantic_diagnostics(ctx, file),
+  );
+  let all = tsrs_compiler::sort_and_deduplicate_diagnostics(&all);
+
+  // tsc's rule (tsrs_execute/src/tsc/emit.rs) for a run that did not skip emitting, as with --noEmit.
+  let status = if all.is_empty() {
+    ExitStatus::Success
+  } else {
+    ExitStatus::DiagnosticsPresent_OutputsGenerated
+  };
+
+  let responses = tsrs_api::diagnostics::diagnostic_responses(&all);
+
+  drop(all);
+  drop(data);
+
+  tsrs_core::json::marshal(&responses)
+    .ok()
+    .and_then(|json| RawValue::from_string(json).ok())
+    .map(|diagnostics| (status, diagnostics))
+    .ok_or_else(|| TsrsResult::error(TsrsErrorCode::Internal, "the diagnostics could not be serialized"))
+}
+
+// A snapshot also holds the projects this one references.
+fn project_id(created: &Value, project: &str) -> Option<String> {
+  let Value::Array(projects) = field(created, "projects")? else {
+    return None;
+  };
+
+  projects
+    .iter()
+    .find(|candidate| matches!(field(candidate, "configFileName"), Some(Value::String(name)) if name == project))
+    .or_else(|| projects.first())
+    .and_then(|candidate| match field(candidate, "id") {
+      Some(Value::String(id)) => Some(id.clone()),
+      _ => None,
+    })
+}
+
+fn call(session: &Session, method: &str, params: &Value) -> Result<Value, String> {
+  let params = tsrs_core::json::marshal(params)?;
+
+  match session.handle_request(method, params.as_bytes()) {
+    Ok(Response::Json(text)) => tsrs_core::json::unmarshal(&text),
+    Ok(Response::Binary(_)) => Err(format!("{method} returned a binary response")),
+    Err(error) => Err(error.to_string()),
+  }
+}
+
+fn object(key: &str, value: Value) -> Value {
+  let mut map = tsrs_core::collections::OrderedMap::default();
+
+  map.insert(key.to_string(), value);
+
+  Value::Object(map)
+}
+
+fn field<'a>(value: &'a Value, key: &str) -> Option<&'a Value> {
+  match value {
+    Value::Object(object) => object.get(key),
+    _ => None,
+  }
+}
+
+fn number(value: Option<&Value>) -> Option<u64> {
+  match value? {
+    Value::Number(number) if *number >= 0.0 => Some(*number as u64),
+    Value::Integer(number) => u64::try_from(*number).ok(),
+    _ => None,
+  }
+}

data/rust/src/status.rs

@@ -0,0 +1,26 @@
+use serde::Serialize;
+use tsrs_execute::tsc::ExitStatus;
+
+#[derive(Serialize)]
+pub struct Status {
+  code: i32,
+  name: &'static str,
+}
+
+impl From<ExitStatus> for Status {
+  fn from(status: ExitStatus) -> Self {
+    let name = match status {
+      ExitStatus::Success => "success",
+      ExitStatus::DiagnosticsPresent_OutputsSkipped => "diagnostics_present_outputs_skipped",
+      ExitStatus::DiagnosticsPresent_OutputsGenerated => "diagnostics_present_outputs_generated",
+      ExitStatus::InvalidProject_OutputsSkipped => "invalid_project_outputs_skipped",
+      ExitStatus::ProjectReferenceCycle_OutputsSkipped => "project_reference_cycle_outputs_skipped",
+      ExitStatus::NotImplemented => "not_implemented",
+    };
+
+    Status {
+      code: status as i32,
+      name,
+    }
+  }
+}

data/rust/src/transpile.rs

@@ -0,0 +1,66 @@
+use serde::Serialize;
+use serde_json::value::RawValue;
+
+use crate::options::{self, TranspileRequest};
+use crate::result::{TsrsErrorCode, TsrsResult};
+
+#[derive(Serialize)]
+struct TranspilePayload {
+  code: String,
+  map: Option<String>,
+  diagnostics: Box<RawValue>,
+}
+
+pub fn transpile(source: String, request_json: String, declaration: bool) -> TsrsResult {
+  let request: TranspileRequest = match serde_json::from_str(&request_json) {
+    Ok(request) => request,
+    Err(error) => return TsrsResult::error(TsrsErrorCode::Option, error.to_string()),
+  };
+
+  // Option parsing allocates in the thread's arena unless a region is entered.
+  let region = tsrs_core::arena::Region::new(64 << 10);
+  let outcome = {
+    let _scope = region.enter();
+
+    run(&source, &request, declaration)
+  };
+  drop(region);
+
+  outcome
+}
+
+fn run(source: &str, request: &TranspileRequest, declaration: bool) -> TsrsResult {
+  let compiler_options = match options::compiler_options(&request.args) {
+    Ok(compiler_options) => compiler_options,
+    Err(message) => return TsrsResult::error(TsrsErrorCode::Option, message),
+  };
+
+  let output = match tsrs_api::transpile::transpile(
+    source,
+    Some(&compiler_options),
+    &request.file_name,
+    request.report_diagnostics,
+    declaration,
+  ) {
+    Ok(output) => output,
+    Err(error) => return TsrsResult::error(TsrsErrorCode::Transpile, error.to_string()),
+  };
+
+  let diagnostics = tsrs_core::json::Value::Array(output.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 = TranspilePayload {
+    code: output.output_text,
+    map: (!output.source_map_text.is_empty()).then_some(output.source_map_text),
+    diagnostics,
+  };
+
+  match serde_json::to_string(&payload) {
+    Ok(json) => TsrsResult::value(json),
+    Err(error) => TsrsResult::error(TsrsErrorCode::Internal, error.to_string()),
+  }
+}

data/rust/src/worker.rs

@@ -0,0 +1,84 @@
+use std::panic::{catch_unwind, AssertUnwindSafe};
+use std::sync::mpsc::{channel, Receiver, Sender};
+use std::sync::{Arc, Mutex, OnceLock};
+use std::thread;
+
+use crate::result::{TsrsErrorCode, TsrsResult};
+
+// Type checking recurses deeply; tsrs's CLI uses the same stack size.
+const STACK_SIZE: usize = 512 << 20;
+
+type Job = Box<dyn FnOnce() + Send>;
+
+struct Pool {
+  sender: Mutex<Sender<Job>>,
+}
+
+// tsrs allocates into per-thread arenas that are never freed, so a fresh thread per call would leak one each time.
+fn pool() -> &'static Pool {
+  static POOL: OnceLock<Pool> = OnceLock::new();
+
+  POOL.get_or_init(|| {
+    let (sender, receiver) = channel::<Job>();
+    let receiver = Arc::new(Mutex::new(receiver));
+    let threads = thread::available_parallelism().map_or(1, |n| n.get()).clamp(1, 4);
+
+    for index in 0..threads {
+      let receiver = Arc::clone(&receiver);
+
+      thread::Builder::new()
+        .name(format!("tsrs-ruby-{index}"))
+        .stack_size(STACK_SIZE)
+        .spawn(move || work(&receiver))
+        .expect("spawn a tsrs worker thread");
+    }
+
+    Pool {
+      sender: Mutex::new(sender),
+    }
+  })
+}
+
+fn work(receiver: &Mutex<Receiver<Job>>) {
+  loop {
+    let job = match receiver.lock() {
+      Ok(receiver) => receiver.recv(),
+      Err(_) => return,
+    };
+
+    match job {
+      Ok(job) => job(),
+      Err(_) => return,
+    }
+  }
+}
+
+pub fn run<F>(job: F) -> TsrsResult
+where
+  F: FnOnce() -> TsrsResult + Send + 'static,
+{
+  let (reply, result) = channel::<TsrsResult>();
+
+  let task: Job = Box::new(move || {
+    let outcome = match catch_unwind(AssertUnwindSafe(job)) {
+      Ok(result) => result,
+      Err(payload) => TsrsResult::error(TsrsErrorCode::Panic, crate::panic_message(&payload)),
+    };
+
+    let _ = reply.send(outcome);
+  });
+
+  let sent = pool()
+    .sender
+    .lock()
+    .map(|sender| sender.send(task).is_ok())
+    .unwrap_or(false);
+
+  if !sent {
+    return TsrsResult::error(TsrsErrorCode::Internal, "the tsrs worker threads are gone");
+  }
+
+  result
+    .recv()
+    .unwrap_or_else(|_| TsrsResult::error(TsrsErrorCode::Internal, "a tsrs worker thread stopped without replying"))
+}

data/sig/tsrs/backend.rbs

@@ -0,0 +1,44 @@
+# Generated from lib/tsrs/backend.rb with RBS::Inline
+
+module Tsrs
+  module Backend
+    module Unavailable
+      # : (String, String) -> String
+      def transpile: (String, String) -> String
+
+      # : (String, String) -> String
+      def transpile_declaration: (String, String) -> String
+
+      # : (String) -> String
+      def check: (String) -> String
+
+      # : (String) -> untyped
+      def session_new: (String) -> untyped
+
+      # : (untyped, String) -> String
+      def session_check: (untyped, String) -> String
+
+      # : (untyped) -> nil
+      def session_close: (untyped) -> nil
+
+      # : () -> String
+      def panic_for_test: () -> String
+
+      # : () -> String
+      def version: () -> String
+
+      # : () -> String
+      def tsrs_version: () -> String
+
+      # : () -> String
+      def typescript_version: () -> String
+
+      private
+
+      # : (Symbol?) -> bot
+      def unavailable: (Symbol?) -> bot
+    end
+
+    extend Unavailable
+  end
+end

data/sig/tsrs/check_result.rbs

@@ -0,0 +1,33 @@
+# Generated from lib/tsrs/check_result.rb with RBS::Inline
+
+module Tsrs
+  class CheckResult
+    include Diagnosed
+
+    attr_reader status: Integer
+
+    attr_reader exit_status: Symbol
+
+    attr_reader diagnostics: Array[Tsrs::Diagnostic]
+
+    attr_reader output: String
+
+    # : (String) -> Tsrs::CheckResult
+    def self.from_json: (String) -> Tsrs::CheckResult
+
+    # : (status: Integer, exit_status: Symbol, ?output: String, ?diagnostics: Array[Tsrs::Diagnostic]) -> void
+    def initialize: (status: Integer, exit_status: Symbol, ?output: String, ?diagnostics: Array[Tsrs::Diagnostic]) -> void
+
+    # : () -> bool
+    def success?: () -> bool
+
+    # : (?strict: bool) -> self
+    def validate!: (?strict: bool) -> self
+
+    # : () -> String
+    def to_s: () -> String
+
+    # : () -> String
+    def inspect: () -> String
+  end
+end

data/sig/tsrs/diagnosed.rbs

@@ -0,0 +1,15 @@
+# Generated from lib/tsrs/diagnosed.rb with RBS::Inline
+
+module Tsrs
+  # @rbs module-self _Diagnosed
+  module Diagnosed : _Diagnosed
+    # : () -> Array[Tsrs::Diagnostic]
+    def errors: () -> Array[Tsrs::Diagnostic]
+
+    # : () -> Array[Tsrs::Diagnostic]
+    def warnings: () -> Array[Tsrs::Diagnostic]
+
+    # : () -> bool
+    def errors?: () -> bool
+  end
+end

data/sig/tsrs/diagnostic.rbs

@@ -0,0 +1,66 @@
+# Generated from lib/tsrs/diagnostic.rb with RBS::Inline
+
+module Tsrs
+  # Lines and columns are 1-based. `start` and `finish` are offsets in UTF-16 code units, as TypeScript counts.
+  class Diagnostic
+    CATEGORIES: Array[Symbol]
+
+    attr_reader code: Integer
+
+    attr_reader category: Symbol
+
+    attr_reader message: String
+
+    attr_reader file: String?
+
+    attr_reader line: Integer?
+
+    attr_reader column: Integer?
+
+    attr_reader end_line: Integer?
+
+    attr_reader end_column: Integer?
+
+    attr_reader start: Integer?
+
+    attr_reader finish: Integer?
+
+    attr_reader source: String?
+
+    attr_reader message_chain: Array[Tsrs::Diagnostic]
+
+    attr_reader related_information: Array[Tsrs::Diagnostic]
+
+    # : (Hash[String, untyped]) -> Tsrs::Diagnostic
+    def self.from_hash: (Hash[String, untyped]) -> Tsrs::Diagnostic
+
+    # : (untyped) -> Integer?
+    def self.offset: (untyped) -> Integer?
+
+    # : (code: Integer, category: Symbol, message: String, ?file: String?, ?line: Integer?, ?column: Integer?, ?end_line: Integer?, ?end_column: Integer?, ?start: Integer?, ?finish: Integer?, ?source: String?, ?message_chain: Array[Tsrs::Diagnostic], ?related_information: Array[Tsrs::Diagnostic]) -> void
+    def initialize: (code: Integer, category: Symbol, message: String, ?file: String?, ?line: Integer?, ?column: Integer?, ?end_line: Integer?, ?end_column: Integer?, ?start: Integer?, ?finish: Integer?, ?source: String?, ?message_chain: Array[Tsrs::Diagnostic], ?related_information: Array[Tsrs::Diagnostic]) -> void
+
+    # : () -> bool
+    def error?: () -> bool
+
+    # : () -> bool
+    def warning?: () -> bool
+
+    # : () -> String
+    def location: () -> String
+
+    # : () -> String
+    def full_message: () -> String
+
+    # : () -> String
+    def to_s: () -> String
+
+    # : () -> String
+    def inspect: () -> String
+
+    private
+
+    # : (Array[Tsrs::Diagnostic], Integer) -> Array[String]
+    def chain_lines: (Array[Tsrs::Diagnostic], Integer) -> Array[String]
+  end
+end

data/sig/tsrs/errors.rbs

@@ -0,0 +1,37 @@
+# Generated from lib/tsrs/errors.rb with RBS::Inline
+
+module Tsrs
+  class Error < StandardError
+  end
+
+  class OptionError < Error
+  end
+
+  class EncodingError < Error
+  end
+
+  class TranspileError < Error
+  end
+
+  class InternalError < Error
+  end
+
+  class PanicError < InternalError
+  end
+
+  class CheckError < Error
+  end
+
+  class DiagnosticError < Error
+    attr_reader diagnostics: Array[Tsrs::Diagnostic]
+
+    # : (Array[Tsrs::Diagnostic]) -> void
+    def initialize: (Array[Tsrs::Diagnostic]) -> void
+  end
+
+  class SyntaxError < DiagnosticError
+  end
+
+  class TypeError < DiagnosticError
+  end
+end

data/sig/tsrs/options.rbs

@@ -0,0 +1,19 @@
+# Generated from lib/tsrs/options.rb with RBS::Inline
+
+module Tsrs
+  module Options
+    REFUSED: Hash[String, String]
+
+    # : (Hash[Symbol | String, untyped]) -> Array[String]
+    def self.arguments: (Hash[Symbol | String, untyped]) -> Array[String]
+
+    # : (Symbol | String) -> String
+    def self.option_name: (Symbol | String) -> String
+
+    # : (String) -> void
+    def self.refuse!: (String) -> void
+
+    # : (String, untyped) -> Array[String]
+    def self.flag: (String, untyped) -> Array[String]
+  end
+end

data/sig/tsrs/session.rbs

@@ -0,0 +1,26 @@
+# Generated from lib/tsrs/session.rb with RBS::Inline
+
+module Tsrs
+  # Unlike Tsrs.check, a session gives a check's memory back. Compiler options come from the tsconfig.json only.
+  class Session
+    attr_reader cwd: String
+
+    # : [T] (?cwd: String) { (Tsrs::Session) -> T } -> T
+    def self.open: [T] (?cwd: String) { (Tsrs::Session) -> T } -> T
+
+    # : (?cwd: String) -> void
+    def initialize: (?cwd: String) -> void
+
+    # : (?String) -> Tsrs::CheckResult
+    def check: (?String) -> Tsrs::CheckResult
+
+    # : () -> void
+    def close: () -> void
+
+    # : () -> bool
+    def closed?: () -> bool
+
+    # : () -> String
+    def inspect: () -> String
+  end
+end

data/sig/tsrs/transpile_result.rbs

@@ -0,0 +1,29 @@
+# Generated from lib/tsrs/transpile_result.rb with RBS::Inline
+
+module Tsrs
+  # A transpile ignores imports, so its diagnostics never include type errors.
+  class TranspileResult
+    include Diagnosed
+
+    attr_reader code: String
+
+    attr_reader map: String?
+
+    attr_reader diagnostics: Array[Tsrs::Diagnostic]
+
+    # : (String) -> Tsrs::TranspileResult
+    def self.from_json: (String) -> Tsrs::TranspileResult
+
+    # : (code: String, ?map: String?, ?diagnostics: Array[Tsrs::Diagnostic]) -> void
+    def initialize: (code: String, ?map: String?, ?diagnostics: Array[Tsrs::Diagnostic]) -> void
+
+    # : (?strict: bool) -> self
+    def validate!: (?strict: bool) -> self
+
+    # : () -> String
+    def to_s: () -> String
+
+    # : () -> String
+    def inspect: () -> String
+  end
+end

data/sig/tsrs/types.rbs

@@ -0,0 +1,5 @@
+module Tsrs
+  interface _Diagnosed
+    def diagnostics: () -> Array[Tsrs::Diagnostic]
+  end
+end

data/sig/tsrs/version.rbs

@@ -0,0 +1,5 @@
+# Generated from lib/tsrs/version.rb with RBS::Inline
+
+module Tsrs
+  VERSION: ::String
+end

data/sig/tsrs.rbs

@@ -0,0 +1,27 @@
+# Generated from lib/tsrs.rb with RBS::Inline
+
+module Tsrs
+  # : (String, ?file_name: String?, ?report_diagnostics: bool, ?strict: bool, **untyped) -> Tsrs::TranspileResult
+  def self.transpile: (String, ?file_name: String?, ?report_diagnostics: bool, ?strict: bool, **untyped) -> Tsrs::TranspileResult
+
+  # : (String, ?file_name: String?, ?report_diagnostics: bool, ?strict: bool, **untyped) -> Tsrs::TranspileResult
+  def self.transpile_declaration: (String, ?file_name: String?, ?report_diagnostics: bool, ?strict: bool, **untyped) -> Tsrs::TranspileResult
+
+  # : (*String, ?project: String?, ?cwd: String, **untyped) -> Tsrs::CheckResult
+  def self.check: (*String, ?project: String?, ?cwd: String, **untyped) -> Tsrs::CheckResult
+
+  # : (*String, ?project: String?, ?cwd: String, **untyped) -> Tsrs::CheckResult
+  def self.compile: (*String, ?project: String?, ?cwd: String, **untyped) -> Tsrs::CheckResult
+
+  # : (*String, ?cwd: String) -> Tsrs::CheckResult
+  def self.tsc: (*String, ?cwd: String) -> Tsrs::CheckResult
+
+  # : () -> String
+  def self.tsrs_version: () -> String
+
+  # : () -> String
+  def self.typescript_version: () -> String
+
+  # : (String?, bool, Hash[Symbol, untyped]) -> String
+  def self.transpile_request: (String?, bool, Hash[Symbol, untyped]) -> String
+end