oxc 0.1.0-arm-linux-gnu

data/rust/Cargo.toml

@@ -0,0 +1,32 @@
+[workspace]
+
+[package]
+name = "oxc-ruby-ffi"
+version = "0.1.0"
+edition = "2021"
+authors = ["Marco Roth <marco.roth@intergga.ch>"]
+description = "C FFI bindings for oxc, used by the oxc gem"
+license = "MIT"
+repository = "https://github.com/marcoroth/oxc-ruby"
+publish = false
+
+[lib]
+name = "oxc_ffi"
+path = "src/lib.rs"
+crate-type = ["cdylib", "staticlib", "rlib"]
+
+[dependencies]
+oxc = { version = "=0.147.0", features = ["full", "serialize"] }
+oxc_sourcemap = "8"
+serde = { version = "1", features = ["derive"] }
+serde_json = { version = "1", features = ["raw_value"] }
+
+[build-dependencies]
+cbindgen = "0.28"
+
+[profile.release]
+opt-level = 3
+lto = "fat"
+codegen-units = 1
+strip = "symbols"
+panic = "unwind"

data/rust/build.rs

@@ -0,0 +1,52 @@
+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/oxc/include/oxc.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()
+  );
+
+  println!("cargo:rustc-env=OXC_VERSION={}", locked_version(&lock_path, "oxc"));
+}
+
+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,24 @@
+language = "C"
+header = """/* Generated by cbindgen — do not edit manually */
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <stddef.h>"""
+include_guard = "OXC_H"
+no_includes = true
+
+[export]
+include = [
+  "OxcResult",
+  "OxcErrorCode",
+]
+
+[enum]
+rename_variants = "ScreamingSnakeCase"
+prefix_with_name = true
+
+[fn]
+sort_by = "None"
+
+[parse]
+parse_deps = false

data/rust/rustfmt.toml

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

data/rust/src/diagnostic.rs

@@ -0,0 +1,75 @@
+use std::sync::Arc;
+
+use oxc::diagnostics::{LabeledSpan, NamedSource, OxcDiagnostic};
+use serde::Serialize;
+
+#[derive(Debug, Serialize)]
+pub struct Diagnostic {
+  pub severity: &'static str,
+  pub message: String,
+  pub labels: Vec<Label>,
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub help: Option<String>,
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub codeframe: Option<String>,
+}
+
+#[derive(Debug, Serialize)]
+pub struct Label {
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub message: Option<String>,
+  pub start: u32,
+  pub end: u32,
+}
+
+impl Diagnostic {
+  pub fn from_diagnostics(
+    filename: &str,
+    source_text: &str,
+    diagnostics: impl IntoIterator<Item = OxcDiagnostic>,
+  ) -> Vec<Self> {
+    let diagnostics = diagnostics.into_iter().collect::<Vec<_>>();
+
+    if diagnostics.is_empty() {
+      return Vec::new();
+    }
+
+    let source = Arc::new(NamedSource::new(filename, source_text.to_string()));
+
+    diagnostics
+      .into_iter()
+      .map(|diagnostic| Self::from_diagnostic(&source, diagnostic))
+      .collect()
+  }
+
+  fn from_diagnostic(source: &Arc<NamedSource<String>>, diagnostic: OxcDiagnostic) -> Self {
+    let severity = match diagnostic.severity {
+      oxc::diagnostics::Severity::Error => "error",
+      oxc::diagnostics::Severity::Warning => "warning",
+      oxc::diagnostics::Severity::Advice => "advice",
+    };
+
+    let labels = diagnostic.labels.iter().map(Label::from).collect::<Vec<_>>();
+    let message = diagnostic.message.to_string();
+    let help = diagnostic.help.as_ref().map(ToString::to_string);
+    let codeframe = Some(diagnostic.render_with_source_code(Arc::clone(source)));
+
+    Self {
+      severity,
+      message,
+      labels,
+      help,
+      codeframe,
+    }
+  }
+}
+
+impl From<&LabeledSpan> for Label {
+  fn from(label: &LabeledSpan) -> Self {
+    Self {
+      message: label.label().map(ToString::to_string),
+      start: label.offset(),
+      end: label.offset() + label.len(),
+    }
+  }
+}

data/rust/src/lib.rs

@@ -0,0 +1,288 @@
+//! C FFI bindings for oxc.
+//!
+//! # Safety
+//!
+//! Every function here requires that pointer arguments are valid, NUL-terminated C strings unless
+//! documented as nullable. Returned pointers are owned by the caller and must be released with
+//! `oxc_string_free` or `oxc_result_free`.
+
+#![allow(clippy::missing_safety_doc)]
+
+mod diagnostic;
+mod module_record;
+mod options;
+mod parse;
+mod result;
+mod source_type;
+mod symbols;
+mod transform;
+
+use std::any::Any;
+use std::ffi::{CStr, CString};
+use std::os::raw::c_char;
+use std::panic::{self, AssertUnwindSafe};
+use std::ptr;
+
+use oxc::allocator::Allocator;
+use oxc::codegen::Codegen;
+use oxc::minifier::Minifier;
+use oxc::parser::Parser;
+use oxc::CompilerInterface;
+use serde::de::DeserializeOwned;
+
+use crate::diagnostic::Diagnostic;
+use crate::options::{MinifyOptions, ParseOptions, TransformOptions};
+use crate::parse::parse_source;
+use crate::result::{MinifyPayload, TransformPayload};
+use crate::source_type::source_type_for;
+use crate::transform::Compiler;
+
+pub const VERSION: &str = env!("CARGO_PKG_VERSION");
+pub const OXC_VERSION: &str = env!("OXC_VERSION");
+
+#[repr(C)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum OxcErrorCode {
+  None = 0,
+  Option,
+  Encoding,
+  Transform,
+  Internal,
+  Panic,
+}
+
+#[repr(C)]
+pub struct OxcResult {
+  pub value: *mut c_char,
+  pub value_len: usize,
+  pub error: *mut c_char,
+  pub code: OxcErrorCode,
+}
+
+impl OxcResult {
+  pub fn ok(value: String) -> Self {
+    let len = value.len();
+
+    Self {
+      value: into_c_string(value),
+      value_len: len,
+      error: ptr::null_mut(),
+      code: OxcErrorCode::None,
+    }
+  }
+
+  pub fn err(code: OxcErrorCode, message: impl AsRef<str>) -> Self {
+    Self {
+      value: ptr::null_mut(),
+      value_len: 0,
+      error: into_c_string(message.as_ref()),
+      code,
+    }
+  }
+}
+
+pub struct Failure {
+  code: OxcErrorCode,
+  message: String,
+}
+
+impl Failure {
+  pub fn option(message: impl Into<String>) -> Self {
+    Self {
+      code: OxcErrorCode::Option,
+      message: message.into(),
+    }
+  }
+
+  pub fn encoding(message: impl Into<String>) -> Self {
+    Self {
+      code: OxcErrorCode::Encoding,
+      message: message.into(),
+    }
+  }
+}
+
+fn into_c_string(value: impl Into<Vec<u8>>) -> *mut c_char {
+  CString::new(value).unwrap_or_default().into_raw()
+}
+
+unsafe fn borrow_str<'a>(pointer: *const c_char, label: &str) -> Result<&'a str, Failure> {
+  if pointer.is_null() {
+    return Err(Failure::encoding(format!("{label} is null")));
+  }
+
+  CStr::from_ptr(pointer)
+    .to_str()
+    .map_err(|error| Failure::encoding(format!("Invalid UTF-8 in {label}: {error}")))
+}
+
+unsafe fn borrow_options<T: Default + DeserializeOwned>(pointer: *const c_char) -> Result<T, Failure> {
+  if pointer.is_null() {
+    return Ok(T::default());
+  }
+
+  let json = borrow_str(pointer, "options")?;
+
+  if json.trim().is_empty() {
+    return Ok(T::default());
+  }
+
+  serde_json::from_str(json).map_err(|error| Failure::option(format!("Invalid options: {error}")))
+}
+
+fn panic_message(payload: &Box<dyn Any + Send>) -> String {
+  if let Some(message) = payload.downcast_ref::<&str>() {
+    return (*message).to_string();
+  }
+
+  if let Some(message) = payload.downcast_ref::<String>() {
+    return message.clone();
+  }
+
+  "oxc panicked".to_string()
+}
+
+fn answer<T: serde::Serialize>(outcome: Result<T, Failure>) -> OxcResult {
+  match outcome {
+    Ok(payload) => match serde_json::to_string(&payload) {
+      Ok(json) => OxcResult::ok(json),
+      Err(error) => OxcResult::err(
+        OxcErrorCode::Internal,
+        format!("Failed to serialize the result: {error}"),
+      ),
+    },
+    Err(failure) => OxcResult::err(failure.code, failure.message),
+  }
+}
+
+pub fn guard<T: serde::Serialize>(call: impl FnOnce() -> Result<T, Failure>) -> OxcResult {
+  match panic::catch_unwind(AssertUnwindSafe(call)) {
+    Ok(outcome) => answer(outcome),
+    Err(payload) => OxcResult::err(OxcErrorCode::Panic, panic_message(&payload)),
+  }
+}
+
+fn minify_source(source: &str, options: &MinifyOptions) -> Result<MinifyPayload, Failure> {
+  let filename = options.filename.clone().unwrap_or_default();
+
+  let minifier_options = options.to_minifier_options().map_err(Failure::option)?;
+  let mut codegen_options = options.to_codegen_options().map_err(Failure::option)?;
+
+  let source_type =
+    source_type_for(&filename, options.lang.as_deref(), options.source_type.as_deref()).map_err(Failure::option)?;
+
+  let allocator = Allocator::default();
+  let parsed = Parser::new(&allocator, source, source_type).parse();
+
+  let mut program = parsed.program;
+
+  let minified = Minifier::new(minifier_options).minify(&allocator, &mut program);
+
+  if !options.sourcemap {
+    codegen_options.source_map_path = None;
+  }
+
+  let printed = Codegen::new()
+    .with_options(codegen_options)
+    .with_scoping(minified.scoping)
+    .build(&program);
+
+  let map = printed.map.map(|map| map.to_json_string());
+
+  let legal_comments = printed
+    .legal_comments
+    .iter()
+    .map(|comment| comment.span.source_text(source).to_string())
+    .collect();
+
+  Ok(MinifyPayload {
+    code: printed.code,
+    map,
+    legal_comments,
+    errors: Diagnostic::from_diagnostics(&filename, source, parsed.diagnostics),
+    panicked: parsed.panicked,
+  })
+}
+
+fn transform_source(source: &str, options: &TransformOptions) -> Result<TransformPayload, Failure> {
+  let filename = options.filename.clone().unwrap_or_default();
+
+  let source_type =
+    source_type_for(&filename, options.lang.as_deref(), options.source_type.as_deref()).map_err(Failure::option)?;
+
+  let mut compiler = Compiler::new(options).map_err(Failure::option)?;
+
+  compiler.compile(source, source_type, std::path::Path::new(&filename));
+
+  let legal_comments = compiler
+    .legal_comments
+    .iter()
+    .map(|span| span.source_text(source).to_string())
+    .collect();
+
+  let panicked = compiler.code.is_empty() && !compiler.errors.is_empty();
+
+  Ok(TransformPayload {
+    code: compiler.code,
+    map: compiler.map,
+    declaration: compiler.declaration,
+    declaration_map: compiler.declaration_map,
+    legal_comments,
+    helpers_used: compiler.helpers_used,
+    errors: Diagnostic::from_diagnostics(&filename, source, compiler.errors),
+    panicked,
+  })
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn oxc_parse(source: *const c_char, options_json: *const c_char) -> OxcResult {
+  guard(|| {
+    let source = borrow_str(source, "source")?;
+    let options = borrow_options::<ParseOptions>(options_json)?;
+
+    parse_source(source, &options).map_err(Failure::option)
+  })
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn oxc_transform(source: *const c_char, options_json: *const c_char) -> OxcResult {
+  guard(|| {
+    let source = borrow_str(source, "source")?;
+    let options = borrow_options::<TransformOptions>(options_json)?;
+
+    transform_source(source, &options)
+  })
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn oxc_minify(source: *const c_char, options_json: *const c_char) -> OxcResult {
+  guard(|| {
+    let source = borrow_str(source, "source")?;
+    let options = borrow_options::<MinifyOptions>(options_json)?;
+
+    minify_source(source, &options)
+  })
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn oxc_version() -> *mut c_char {
+  into_c_string(VERSION)
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn oxc_oxc_version() -> *mut c_char {
+  into_c_string(OXC_VERSION)
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn oxc_string_free(value: *mut c_char) {
+  if !value.is_null() {
+    drop(CString::from_raw(value));
+  }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn oxc_result_free(result: OxcResult) {
+  oxc_string_free(result.value);
+  oxc_string_free(result.error);
+}