oxc 0.0.1 → 0.2.0

data/ext/oxc/extconf.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require "mkmf"
+require "fileutils"
+
+ext_dir = __dir__
+root_dir = File.expand_path("../..", ext_dir)
+
+rust_dir = File.join(root_dir, "rust")
+
+unless File.exist?(File.join(rust_dir, "Cargo.toml"))
+  abort <<~MESSAGE
+
+    ERROR: Rust sources not found at #{rust_dir}.
+
+  MESSAGE
+end
+
+unless system("cargo --version > /dev/null 2>&1")
+  abort <<~MESSAGE
+
+    ERROR: Rust toolchain not found.
+
+    oxc requires the Rust toolchain to compile from source.
+
+    Install Rust: https://rustup.rs
+
+  MESSAGE
+end
+
+RUST_TARGETS = {
+  "aarch64-linux-gnu" => "aarch64-unknown-linux-gnu",
+  "aarch64-linux-musl" => "aarch64-unknown-linux-musl",
+  "arm-linux-gnu" => "armv7-unknown-linux-gnueabihf",
+  "arm-linux-musl" => "armv7-unknown-linux-musleabihf",
+  "arm64-darwin" => "aarch64-apple-darwin",
+  "x86_64-darwin" => "x86_64-apple-darwin",
+  "x86_64-linux-gnu" => "x86_64-unknown-linux-gnu",
+  "x86_64-linux-musl" => "x86_64-unknown-linux-musl",
+  "x86-linux-gnu" => "i686-unknown-linux-gnu",
+  "x86-linux-musl" => "i686-unknown-linux-musl",
+}.freeze
+
+cross_compiling = ENV.key?("RUBY_CC_VERSION")
+target_platform = ENV.fetch("CARGO_BUILD_TARGET", nil)
+
+if cross_compiling && target_platform.nil?
+  rcd_platform = ENV.fetch("RCD_PLATFORM", "")
+  target_platform = RUST_TARGETS[rcd_platform]
+
+  if target_platform.nil?
+    ruby_platform = RbConfig::CONFIG["arch"]
+    target_platform = RUST_TARGETS.values.find { |target| ruby_platform.include?(target.split("-").first) }
+  end
+end
+
+header_path = File.join(ext_dir, "include", "oxc.h")
+
+FileUtils.mkdir_p(File.dirname(header_path))
+
+target_dir = File.join(rust_dir, "target")
+
+if target_platform
+  puts "oxc: Cross-compiling Rust for target: #{target_platform}"
+
+  system("rustup target add #{target_platform}") || warn("oxc: Failed to add Rust target #{target_platform}")
+
+  cargo_args = "--release --locked --target #{target_platform}"
+  lib_dir = File.join(target_dir, target_platform, "release")
+else
+  puts "oxc: Compiling Rust library for native platform..."
+
+  cargo_args = "--release --locked"
+  lib_dir = File.join(target_dir, "release")
+end
+
+unless system("cd #{rust_dir} && cargo build #{cargo_args}")
+  abort "ERROR: Failed to compile oxc from Rust source."
+end
+
+unless File.exist?(header_path)
+  abort "ERROR: cbindgen did not generate #{header_path}. Try `cargo clean` in #{rust_dir} and reinstall."
+end
+
+static_lib = File.join(lib_dir, "liboxc_ffi.a")
+
+developing = File.exist?(File.join(root_dir, ".git"))
+
+if File.exist?(static_lib) && !developing
+  vendored = File.join(ext_dir, "liboxc_ffi.a")
+
+  FileUtils.cp(static_lib, vendored)
+  FileUtils.rm_rf(target_dir)
+
+  puts "oxc: Static library vendored at #{vendored}, Rust build directory removed"
+
+  $LDFLAGS << " #{vendored}"
+elsif File.exist?(static_lib)
+  puts "oxc: Static library found at #{static_lib}"
+
+  $LDFLAGS << " #{static_lib}"
+else
+  host_os = target_platform || RbConfig::CONFIG["host_os"]
+
+  lib_name = case host_os
+             when /darwin/ then "liboxc_ffi.dylib"
+             when /mingw|mswin|windows/ then "oxc_ffi.dll"
+             else "liboxc_ffi.so"
+             end
+
+  lib_path = File.join(lib_dir, lib_name)
+
+  abort "ERROR: Shared library not found at #{lib_path}" unless File.exist?(lib_path)
+
+  puts "oxc: Shared library found at #{lib_path} (dynamic)"
+
+  $LDFLAGS << " -L#{lib_dir} -loxc_ffi"
+  $LDFLAGS << " -Wl,-rpath,#{lib_dir}" if RbConfig::CONFIG["host_os"].match?(/darwin|linux/)
+end
+
+$CFLAGS << " -I#{ext_dir}"
+
+create_makefile("oxc/oxc")

data/ext/oxc/include/oxc.h

@@ -0,0 +1,40 @@
+/* Generated by cbindgen — do not edit manually */
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <stddef.h>
+
+#ifndef OXC_H
+#define OXC_H
+
+typedef enum OxcErrorCode {
+  OXC_ERROR_CODE_NONE = 0,
+  OXC_ERROR_CODE_OPTION,
+  OXC_ERROR_CODE_ENCODING,
+  OXC_ERROR_CODE_TRANSFORM,
+  OXC_ERROR_CODE_INTERNAL,
+  OXC_ERROR_CODE_PANIC,
+} OxcErrorCode;
+
+typedef struct OxcResult {
+  char *value;
+  uintptr_t value_len;
+  char *error;
+  enum OxcErrorCode code;
+} OxcResult;
+
+struct OxcResult oxc_parse(const char *source, const char *options_json);
+
+struct OxcResult oxc_transform(const char *source, const char *options_json);
+
+struct OxcResult oxc_minify(const char *source, const char *options_json);
+
+char *oxc_version(void);
+
+char *oxc_oxc_version(void);
+
+void oxc_string_free(char *value);
+
+void oxc_result_free(struct OxcResult result);
+
+#endif  /* OXC_H */

data/ext/oxc/oxc.c

@@ -0,0 +1,136 @@
+#include <ruby.h>
+#include <ruby/encoding.h>
+#include <ruby/thread.h>
+#include "include/oxc.h"
+
+static VALUE rb_mOxc;
+static VALUE rb_mBackend;
+static VALUE rb_eError;
+static VALUE rb_eOptionError;
+static VALUE rb_eOxcEncodingError;
+static VALUE rb_eTransformError;
+static VALUE rb_eInternalError;
+static VALUE rb_ePanicError;
+
+typedef struct OxcResult (*oxc_function)(const char *, const char *);
+
+struct call_arguments {
+  oxc_function function;
+  const char *source;
+  const char *options;
+  struct OxcResult result;
+};
+
+static VALUE make_utf8_string(const char *cstring) {
+  return rb_enc_str_new_cstr(cstring, rb_utf8_encoding());
+}
+
+static VALUE take_utf8_string(char *cstring) {
+  if (!cstring) return Qnil;
+
+  VALUE string = make_utf8_string(cstring);
+  oxc_string_free(cstring);
+
+  return string;
+}
+
+static VALUE error_class_for(enum OxcErrorCode code) {
+  switch (code) {
+    case OXC_ERROR_CODE_OPTION: return rb_eOptionError;
+    case OXC_ERROR_CODE_ENCODING: return rb_eOxcEncodingError;
+    case OXC_ERROR_CODE_TRANSFORM: return rb_eTransformError;
+    case OXC_ERROR_CODE_PANIC: return rb_ePanicError;
+    default: return rb_eInternalError;
+  }
+}
+
+static VALUE unwrap(struct OxcResult result) {
+  if (result.error) {
+    VALUE message = make_utf8_string(result.error);
+    VALUE error_class = error_class_for(result.code);
+
+    oxc_result_free(result);
+
+    rb_raise(error_class, "%s", StringValueCStr(message));
+  }
+
+  if (!result.value) {
+    oxc_result_free(result);
+
+    rb_raise(rb_eInternalError, "oxc returned no result");
+  }
+
+  VALUE value = rb_enc_str_new(result.value, (long) result.value_len, rb_utf8_encoding());
+
+  oxc_result_free(result);
+
+  return value;
+}
+
+static void *without_gvl(void *data) {
+  struct call_arguments *arguments = (struct call_arguments *) data;
+
+  arguments->result = arguments->function(arguments->source, arguments->options);
+
+  return NULL;
+}
+
+static VALUE call(oxc_function function, VALUE source, VALUE options) {
+  struct call_arguments arguments;
+
+  arguments.function = function;
+  arguments.source = StringValueCStr(source);
+  arguments.options = StringValueCStr(options);
+
+  rb_thread_call_without_gvl(without_gvl, &arguments, NULL, NULL);
+
+  return unwrap(arguments.result);
+}
+
+static VALUE rb_minify(VALUE self, VALUE source, VALUE options) {
+  (void) self;
+
+  return call(oxc_minify, source, options);
+}
+
+static VALUE rb_transform(VALUE self, VALUE source, VALUE options) {
+  (void) self;
+
+  return call(oxc_transform, source, options);
+}
+
+static VALUE rb_parse(VALUE self, VALUE source, VALUE options) {
+  (void) self;
+
+  return call(oxc_parse, source, options);
+}
+
+static VALUE rb_native_version(VALUE self) {
+  (void) self;
+
+  return take_utf8_string(oxc_version());
+}
+
+static VALUE rb_oxc_version(VALUE self) {
+  (void) self;
+
+  return take_utf8_string(oxc_oxc_version());
+}
+
+void Init_oxc(void) {
+  rb_mOxc = rb_define_module("Oxc");
+  rb_mBackend = rb_define_module_under(rb_mOxc, "Backend");
+
+  rb_eError = rb_define_class_under(rb_mOxc, "Error", rb_eStandardError);
+  rb_eOptionError = rb_define_class_under(rb_mOxc, "OptionError", rb_eError);
+  rb_eOxcEncodingError = rb_define_class_under(rb_mOxc, "EncodingError", rb_eError);
+  rb_eTransformError = rb_define_class_under(rb_mOxc, "TransformError", rb_eError);
+  rb_eInternalError = rb_define_class_under(rb_mOxc, "InternalError", rb_eError);
+  rb_ePanicError = rb_define_class_under(rb_mOxc, "PanicError", rb_eInternalError);
+
+  rb_define_singleton_method(rb_mBackend, "minify", rb_minify, 2);
+  rb_define_singleton_method(rb_mBackend, "transform", rb_transform, 2);
+  rb_define_singleton_method(rb_mBackend, "parse", rb_parse, 2);
+  rb_define_singleton_method(rb_mBackend, "version", rb_native_version, 0);
+  rb_define_singleton_method(rb_mBackend, "oxc_version", rb_oxc_version, 0);
+}

data/lib/oxc/backend.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Oxc
+  module Backend
+    module Unavailable
+      #: (String, String) -> String
+      def minify(_source, _options_json)
+        unavailable(__method__)
+      end
+
+      #: (String, String) -> String
+      def transform(_source, _options_json)
+        unavailable(__method__)
+      end
+
+      #: (String, String) -> String
+      def parse(_source, _options_json)
+        unavailable(__method__)
+      end
+
+      #: () -> String
+      def version
+        unavailable(__method__)
+      end
+
+      #: () -> String
+      def oxc_version
+        unavailable(__method__)
+      end
+
+      private
+
+      #: (Symbol?) -> bot
+      def unavailable(name)
+        raise NotImplementedError, "Oxc::Backend.#{name} is defined by the native extension, which did not load"
+      end
+    end
+
+    extend Unavailable
+  end
+end

data/lib/oxc/diagnosed.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Oxc
+  # @rbs module-self _Diagnosed
+  module Diagnosed
+    # @rbs @panicked: bool
+
+    #: () -> Array[Oxc::Diagnostic]
+    def errors
+      diagnostics.select(&:error?)
+    end
+
+    #: () -> Array[Oxc::Diagnostic]
+    def warnings
+      diagnostics.select(&:warning?)
+    end
+
+    #: () -> bool
+    def errors?
+      !errors.empty?
+    end
+
+    #: () -> bool
+    def warnings?
+      !warnings.empty?
+    end
+
+    #: () -> bool
+    def panicked?
+      @panicked
+    end
+  end
+end

data/lib/oxc/diagnostic.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Oxc
+  class Diagnostic
+    ERROR = "error" #: String
+    WARNING = "warning" #: String
+
+    attr_reader :severity #: String
+    attr_reader :message #: String
+    attr_reader :labels #: Array[Oxc::Label]
+    attr_reader :help #: String?
+    attr_reader :codeframe #: String?
+
+    #: (Hash[String, untyped]) -> Oxc::Diagnostic
+    def self.from_hash(parsed)
+      new(
+        severity: parsed.fetch("severity"),
+        message: parsed.fetch("message"),
+        labels: parsed.fetch("labels").map { |label| Label.from_hash(label) },
+        help: parsed["help"],
+        codeframe: parsed["codeframe"]
+      )
+    end
+
+    #: (severity: String, message: String, labels: Array[Oxc::Label], ?help: String?, ?codeframe: String?) -> void
+    def initialize(severity:, message:, labels:, help: nil, codeframe: nil)
+      @severity = severity
+      @message = message
+      @labels = labels.freeze
+      @help = help
+      @codeframe = codeframe
+
+      freeze
+    end
+
+    #: () -> bool
+    def error?
+      severity == ERROR
+    end
+
+    #: () -> bool
+    def warning?
+      severity == WARNING
+    end
+
+    #: () -> String
+    def to_s
+      message
+    end
+
+    #: () -> String
+    def inspect
+      "#<#{self.class.name} #{severity} #{message.inspect}>"
+    end
+  end
+
+  class Label
+    attr_reader :message #: String?
+    attr_reader :start #: Integer
+    attr_reader :finish #: Integer
+
+    #: (Hash[String, untyped]) -> Oxc::Label
+    def self.from_hash(parsed)
+      new(message: parsed["message"], start: parsed.fetch("start"), finish: parsed.fetch("end"))
+    end
+
+    #: (start: Integer, finish: Integer, ?message: String?) -> void
+    def initialize(start:, finish:, message: nil)
+      @start = start
+      @finish = finish
+      @message = message
+
+      freeze
+    end
+
+    #: (String) -> String?
+    def slice(source)
+      source.byteslice(start, finish - start)
+    end
+
+    #: () -> String
+    def inspect
+      "#<#{self.class.name} range=[#{start}, #{finish}]#{" #{message.inspect}" if message}>"
+    end
+  end
+end

data/lib/oxc/errors.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Oxc
+  class Error < StandardError; end
+  class OptionError < Error; end
+  class EncodingError < Error; end
+  class TransformError < Error; end
+  class InternalError < Error; end
+  class PanicError < InternalError; end
+
+  class SyntaxError < Error
+    attr_reader :result #: (Oxc::Result | Oxc::ParseResult)?
+
+    #: (String, ?(Oxc::Result | Oxc::ParseResult)?) -> void
+    def initialize(message, result = nil)
+      super(message)
+
+      @result = result
+    end
+
+    #: () -> Array[Oxc::Diagnostic]
+    def diagnostics
+      result ? result.diagnostics : []
+    end
+  end
+end

data/lib/oxc/minifier.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Oxc
+  class Minifier
+    attr_reader :options #: Hash[Symbol, untyped]
+
+    #: (?filename: String?, ?lang: String?, ?source_type: String?, ?compress: compress?, ?mangle: mangle?, ?codegen: codegen?, ?sourcemap: bool, ?strict: bool) -> void
+    def initialize(**options)
+      @options = options.transform_keys(&:to_sym).freeze
+
+      freeze
+    end
+
+    #: (String, ?filename: String?, ?lang: String?, ?source_type: String?, ?compress: compress?, ?mangle: mangle?, ?codegen: codegen?, ?sourcemap: bool, ?strict: bool) -> Oxc::MinifyResult
+    def minify(source, **overrides)
+      Oxc.minify(source, **options, **overrides)
+    end
+
+    alias call minify
+
+    #: (?filename: String?, ?lang: String?, ?source_type: String?, ?compress: compress?, ?mangle: mangle?, ?codegen: codegen?, ?sourcemap: bool, ?strict: bool) -> Oxc::Minifier
+    def with(**overrides)
+      self.class.new(**options, **overrides)
+    end
+
+    #: () -> String
+    def inspect
+      "#<#{self.class.name} #{options.inspect}>"
+    end
+  end
+end

data/lib/oxc/minify_result.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Oxc
+  class MinifyResult < Result
+    #: (String) -> Oxc::MinifyResult
+    def self.from_json(payload)
+      parsed = JSON.parse(payload)
+
+      new(
+        code: parsed.fetch("code"),
+        map: parsed["map"],
+        legal_comments: parsed.fetch("legal_comments"),
+        diagnostics: parsed.fetch("errors").map { |diagnostic| Diagnostic.from_hash(diagnostic) },
+        panicked: parsed.fetch("panicked")
+      )
+    end
+
+    #: (code: String, diagnostics: Array[Oxc::Diagnostic], ?map: String?, ?legal_comments: Array[String], ?panicked: bool) -> void
+    def initialize(...)
+      super
+
+      freeze
+    end
+  end
+end

data/lib/oxc/mutation_visitor.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module Oxc
+  # A visitor that rewrites the source it walked, by recording what to do to a node and splicing the
+  # original text at the end. Everything nothing touched survives byte for byte.
+  #
+  #     class Renamer < Oxc::MutationVisitor
+  #       def visit_identifier(node)
+  #         replace(node, "renamed") if node["name"] == "count"
+  #       end
+  #     end
+  #
+  #     Renamer.new.rewrite("let count = 1")  #=> "let renamed = 1"
+  #
+  class MutationVisitor < Visitor
+    class Overlap < StandardError; end
+    class Invalid < Error; end
+
+    Edit = Data.define(
+      :start, #: Integer
+      :finish, #: Integer
+      :text, #: String
+      :order #: Integer
+    )
+
+    attr_reader :source #: String
+    attr_reader :parsed #: Oxc::ParseResult
+
+    #: (String, ?verify: bool, **untyped) -> String
+    def rewrite(source, verify: true, **options)
+      @source = source
+      @edits = [] #: Array[Edit]
+      @replaced = [] #: Array[[Integer, Integer]]
+      @parsed = Oxc.parse(source, **options).validate!
+
+      visit(parsed)
+
+      rewritten = apply
+
+      verify ? verified(rewritten, options) : rewritten
+    end
+
+    #: (Oxc::Node, String) -> void
+    def replace(node, text)
+      @replaced << [node.start, node.finish]
+
+      edit(node.start, node.finish, text)
+    end
+
+    #: (Oxc::Node) -> void
+    def remove(node)
+      replace(node, "")
+    end
+
+    #: (Oxc::Node, String) -> void
+    def insert_before(node, text)
+      edit(node.start, node.start, text)
+    end
+
+    #: (Oxc::Node, String) -> void
+    def insert_after(node, text)
+      edit(node.finish, node.finish, text)
+    end
+
+    #: (Oxc::Node, String, String) -> void
+    def wrap(node, before, after)
+      insert_before(node, before)
+      insert_after(node, after)
+    end
+
+    #: (Oxc::Node) -> void
+    def visit_children(node)
+      return nil if replaced?(node)
+
+      super
+    end
+
+    private
+
+    #: (String, Hash[Symbol, untyped]) -> String
+    def verified(rewritten, options)
+      answer = Oxc.parse(rewritten, **options, ast: false)
+
+      return rewritten unless answer.errors?
+
+      raise Invalid, "what was rewritten no longer reads as JavaScript: #{answer.errors.first&.message}"
+    end
+
+    #: (Oxc::Node) -> bool
+    def replaced?(node)
+      @replaced.any? { |start, finish| node.start >= start && node.finish <= finish }
+    end
+
+    #: (Integer, Integer, String) -> void
+    def edit(start, finish, text)
+      @edits.each do |existing|
+        next unless overlaps?(existing, start, finish)
+
+        raise Overlap, "an edit at #{start}..#{finish} overlaps one at #{existing.start}..#{existing.finish}"
+      end
+
+      @edits << Edit.new(start: start, finish: finish, text: text, order: @edits.length)
+
+      nil
+    end
+
+    #: (Edit, Integer, Integer) -> bool
+    def overlaps?(existing, start, finish)
+      return false if existing.start == existing.finish && start == finish
+
+      start < existing.finish && existing.start < finish
+    end
+
+    #: () -> String
+    def apply
+      taken = 0
+      result = +""
+
+      @edits.sort_by { |edit| [edit.start, edit.order] }.each do |edit|
+        result << source.byteslice(taken, edit.start - taken).to_s << edit.text
+
+        taken = edit.finish
+      end
+
+      result << source.byteslice(taken..).to_s
+    end
+  end
+end