oxc 0.0.1 → 0.2.0

data/rust/src/parse.rs

@@ -0,0 +1,93 @@
+use oxc::allocator::Allocator;
+use oxc::ast::CommentKind;
+use oxc::parser::{ParseOptions as OxcParseOptions, Parser};
+use oxc::semantic::SemanticBuilder;
+use serde_json::value::RawValue;
+
+use crate::diagnostic::Diagnostic;
+use crate::module_record::ModuleRecord;
+use crate::options::ParseOptions;
+use crate::result::{Comment, ParsePayload};
+use crate::source_type::source_type_for;
+use crate::symbols;
+
+pub fn parse_source(source: &str, options: &ParseOptions) -> Result<ParsePayload, String> {
+  let filename = options.filename.clone().unwrap_or_default();
+  let source_type = source_type_for(&filename, options.lang.as_deref(), options.source_type.as_deref())?;
+  let include_ts_fields = options.include_ts_fields(&source_type)?;
+
+  let allocator = Allocator::default();
+
+  let parsed = Parser::new(&allocator, source, source_type)
+    .with_options(OxcParseOptions {
+      preserve_parens: options.preserve_parens,
+      enable_ident_hashes: options.semantic_errors || options.symbols,
+      ..OxcParseOptions::default()
+    })
+    .parse();
+
+  let program = parsed.program;
+  let mut diagnostics = parsed.diagnostics;
+
+  let module_record = options.module_record.then(|| ModuleRecord::from(&parsed.module_record));
+  let symbols = options.symbols.then(|| symbols::read(&program));
+
+  if options.semantic_errors {
+    diagnostics.extend(SemanticBuilder::new_compiler().build(&program).diagnostics);
+  }
+
+  let comments = if options.comments {
+    collect_comments(source, &program, include_ts_fields)
+  } else {
+    Vec::new()
+  };
+
+  let serialized = if options.ast {
+    let json = program.to_estree_json(include_ts_fields, options.ranges);
+
+    Some(RawValue::from_string(json).map_err(|error| format!("Failed to read the AST back: {error}"))?)
+  } else {
+    None
+  };
+
+  Ok(ParsePayload {
+    program: serialized,
+    module_record,
+    symbols,
+    comments,
+    errors: Diagnostic::from_diagnostics(&filename, source, diagnostics),
+    panicked: parsed.panicked,
+  })
+}
+
+fn collect_comments(source: &str, program: &oxc::ast::ast::Program<'_>, include_ts_fields: bool) -> Vec<Comment> {
+  let mut comments = program
+    .comments
+    .iter()
+    .map(|comment| Comment {
+      kind: match comment.kind {
+        CommentKind::Line => "Line",
+        CommentKind::SingleLineBlock | CommentKind::MultiLineBlock => "Block",
+      },
+      value: comment.content_span().source_text(source).to_string(),
+      start: comment.span.start,
+      end: comment.span.end,
+    })
+    .collect::<Vec<_>>();
+
+  if !include_ts_fields {
+    if let Some(hashbang) = &program.hashbang {
+      comments.insert(
+        0,
+        Comment {
+          kind: "Line",
+          value: hashbang.value.to_string(),
+          start: hashbang.span.start,
+          end: hashbang.span.end,
+        },
+      );
+    }
+  }
+
+  comments
+}

data/rust/src/result.rs

@@ -0,0 +1,55 @@
+use std::collections::BTreeMap;
+
+use serde::Serialize;
+use serde_json::value::RawValue;
+
+use crate::diagnostic::Diagnostic;
+use crate::module_record::ModuleRecord;
+use crate::symbols::Symbols;
+
+#[derive(Debug, Default, Serialize)]
+pub struct MinifyPayload {
+  pub code: String,
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub map: Option<String>,
+  pub legal_comments: Vec<String>,
+  pub errors: Vec<Diagnostic>,
+  pub panicked: bool,
+}
+
+#[derive(Debug, Default, Serialize)]
+pub struct TransformPayload {
+  pub code: String,
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub map: Option<String>,
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub declaration: Option<String>,
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub declaration_map: Option<String>,
+  pub legal_comments: Vec<String>,
+  pub helpers_used: BTreeMap<String, String>,
+  pub errors: Vec<Diagnostic>,
+  pub panicked: bool,
+}
+
+#[derive(Debug, Serialize)]
+pub struct Comment {
+  #[serde(rename = "type")]
+  pub kind: &'static str,
+  pub value: String,
+  pub start: u32,
+  pub end: u32,
+}
+
+#[derive(Debug, Serialize)]
+pub struct ParsePayload {
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub program: Option<Box<RawValue>>,
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub module_record: Option<ModuleRecord>,
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub symbols: Option<Symbols>,
+  pub comments: Vec<Comment>,
+  pub errors: Vec<Diagnostic>,
+  pub panicked: bool,
+}

data/rust/src/source_type.rs

@@ -0,0 +1,26 @@
+use oxc::span::SourceType;
+
+pub fn source_type_for(filename: &str, lang: Option<&str>, source_type: Option<&str>) -> Result<SourceType, String> {
+  let ty = match lang {
+    Some("js") => SourceType::unambiguous(),
+    Some("jsx") => SourceType::unambiguous().with_jsx(true),
+    Some("ts") => SourceType::unambiguous().with_typescript(true),
+    Some("tsx") => SourceType::unambiguous().with_typescript(true).with_jsx(true),
+    Some("dts") => SourceType::d_ts(),
+    Some(other) => return Err(format!("Unknown lang: {other}. Expected js, jsx, ts, tsx or dts.")),
+    None => SourceType::from_path(filename).unwrap_or_default(),
+  };
+
+  Ok(match source_type {
+    Some("script") => ty.with_script(true),
+    Some("module") => ty.with_module(true),
+    Some("commonjs") => ty.with_commonjs(true),
+    Some("unambiguous") => ty.with_unambiguous(true),
+    Some(other) => {
+      return Err(format!(
+        "Unknown source_type: {other}. Expected script, module, commonjs or unambiguous."
+      ));
+    }
+    None => ty,
+  })
+}

data/rust/src/symbols.rs

@@ -0,0 +1,101 @@
+use oxc::ast::ast::Program;
+use oxc::semantic::{ReferenceId, Semantic, SemanticBuilder};
+use oxc::span::GetSpan;
+use serde::Serialize;
+
+use crate::module_record::Span;
+
+#[derive(Debug, Serialize)]
+pub struct Symbols {
+  pub declared: Vec<Symbol>,
+  pub unresolved: Vec<Unresolved>,
+}
+
+#[derive(Debug, Serialize)]
+pub struct Symbol {
+  pub name: String,
+  pub root: bool,
+  pub declaration: Span,
+  pub references: Vec<Reference>,
+}
+
+#[derive(Debug, Serialize)]
+pub struct Unresolved {
+  pub name: String,
+  pub references: Vec<Reference>,
+}
+
+#[derive(Debug, Serialize)]
+pub struct Reference {
+  pub start: u32,
+  pub end: u32,
+  pub read: bool,
+  pub write: bool,
+}
+
+pub fn read<'a>(program: &'a Program<'a>) -> Symbols {
+  let semantic = SemanticBuilder::new().with_build_nodes(true).build(program).semantic;
+
+  Symbols {
+    declared: declared(&semantic),
+    unresolved: unresolved(&semantic),
+  }
+}
+
+fn declared(semantic: &Semantic<'_>) -> Vec<Symbol> {
+  let scoping = semantic.scoping();
+
+  scoping
+    .symbol_ids()
+    .map(|symbol_id| {
+      let name = scoping.symbol_name(symbol_id).to_string();
+      let declaration = scoping.symbol_span(symbol_id);
+
+      Symbol {
+        root: scoping.symbol_scope_id(symbol_id) == scoping.root_scope_id(),
+        name,
+        declaration: Span {
+          start: declaration.start,
+          end: declaration.end,
+        },
+        references: scoping
+          .get_resolved_reference_ids(symbol_id)
+          .iter()
+          .map(|reference_id| reference(semantic, *reference_id))
+          .collect(),
+      }
+    })
+    .collect()
+}
+
+fn unresolved(semantic: &Semantic<'_>) -> Vec<Unresolved> {
+  let scoping = semantic.scoping();
+
+  let mut unresolved = scoping
+    .root_unresolved_references()
+    .iter()
+    .map(|(name, reference_ids)| Unresolved {
+      name: name.to_string(),
+      references: reference_ids
+        .iter()
+        .map(|reference_id| reference(semantic, *reference_id))
+        .collect(),
+    })
+    .collect::<Vec<_>>();
+
+  unresolved.sort_unstable_by(|left, right| left.name.cmp(&right.name));
+
+  unresolved
+}
+
+fn reference(semantic: &Semantic<'_>, reference_id: ReferenceId) -> Reference {
+  let found = semantic.scoping().get_reference(reference_id);
+  let span = semantic.nodes().kind(found.node_id()).span();
+
+  Reference {
+    start: span.start,
+    end: span.end,
+    read: found.is_read(),
+    write: found.is_write(),
+  }
+}

data/rust/src/transform.rs

@@ -0,0 +1,116 @@
+use std::collections::BTreeMap;
+use std::ops::ControlFlow;
+
+use oxc::ast::ast::Program;
+use oxc::codegen::{CodegenOptions, CodegenReturn};
+use oxc::diagnostics::Diagnostics;
+use oxc::isolated_declarations::IsolatedDeclarationsOptions;
+use oxc::minifier::{CompressOptions, MangleOptions};
+use oxc::span::Span;
+use oxc::transformer::{TransformOptions as OxcTransformOptions, TransformerReturn};
+use oxc::transformer_plugins::{InjectGlobalVariablesConfig, ReplaceGlobalDefinesConfig};
+use oxc::CompilerInterface;
+
+use crate::options::TransformOptions;
+
+#[derive(Default)]
+pub struct Compiler {
+  transform_options: OxcTransformOptions,
+  codegen_options: CodegenOptions,
+  compress: Option<CompressOptions>,
+  mangle: Option<MangleOptions>,
+  define: Option<ReplaceGlobalDefinesConfig>,
+  inject: Option<InjectGlobalVariablesConfig>,
+  sourcemap: bool,
+  isolated_declarations: Option<IsolatedDeclarationsOptions>,
+
+  pub code: String,
+  pub declaration: Option<String>,
+  pub declaration_map: Option<String>,
+  pub map: Option<String>,
+  pub legal_comments: Vec<Span>,
+  pub helpers_used: BTreeMap<String, String>,
+  pub errors: Diagnostics,
+}
+
+impl Compiler {
+  pub fn new(options: &TransformOptions) -> Result<Self, String> {
+    let minifier_options = options.to_minifier_options()?;
+
+    Ok(Self {
+      transform_options: options.to_transform_options()?,
+      codegen_options: options.to_codegen_options()?,
+      compress: minifier_options.as_ref().and_then(|options| options.compress.clone()),
+      mangle: minifier_options.as_ref().and_then(|options| options.mangle.clone()),
+      define: options.to_define_config()?,
+      inject: options.to_inject_config()?,
+      sourcemap: options.sourcemap,
+      isolated_declarations: options.to_isolated_declarations_options(),
+      ..Self::default()
+    })
+  }
+}
+
+impl CompilerInterface for Compiler {
+  fn handle_errors(&mut self, errors: Diagnostics) {
+    self.errors.extend(errors);
+  }
+
+  fn enable_sourcemap(&self) -> bool {
+    self.sourcemap
+  }
+
+  fn transform_options(&self) -> Option<&OxcTransformOptions> {
+    Some(&self.transform_options)
+  }
+
+  fn isolated_declaration_options(&self) -> Option<IsolatedDeclarationsOptions> {
+    self.isolated_declarations
+  }
+
+  fn define_options(&self) -> Option<ReplaceGlobalDefinesConfig> {
+    self.define.clone()
+  }
+
+  fn inject_options(&self) -> Option<InjectGlobalVariablesConfig> {
+    self.inject.clone()
+  }
+
+  fn compress_options(&self) -> Option<CompressOptions> {
+    self.compress.clone()
+  }
+
+  fn mangle_options(&self) -> Option<MangleOptions> {
+    self.mangle.clone()
+  }
+
+  fn codegen_options(&self) -> Option<CodegenOptions> {
+    Some(self.codegen_options.clone())
+  }
+
+  #[expect(deprecated)]
+  fn after_transform(
+    &mut self,
+    _program: &mut Program<'_>,
+    transformer_return: &mut TransformerReturn,
+  ) -> ControlFlow<()> {
+    self.helpers_used = transformer_return
+      .helpers_used
+      .drain()
+      .map(|(helper, source)| (helper.name().to_string(), source))
+      .collect();
+
+    ControlFlow::Continue(())
+  }
+
+  fn after_isolated_declarations(&mut self, ret: CodegenReturn<'_>) {
+    self.declaration = Some(ret.code);
+    self.declaration_map = ret.map.map(|map| map.to_json_string());
+  }
+
+  fn after_codegen(&mut self, ret: CodegenReturn<'_>) {
+    self.code = ret.code;
+    self.map = ret.map.map(|map| map.to_json_string());
+    self.legal_comments = ret.legal_comments.iter().map(|comment| comment.span).collect();
+  }
+}

data/sig/oxc/backend.rbs

@@ -0,0 +1,29 @@
+# Generated from lib/oxc/backend.rb with RBS::Inline
+
+module Oxc
+  module Backend
+    module Unavailable
+      # : (String, String) -> String
+      def minify: (String, String) -> String
+
+      # : (String, String) -> String
+      def transform: (String, String) -> String
+
+      # : (String, String) -> String
+      def parse: (String, String) -> String
+
+      # : () -> String
+      def version: () -> String
+
+      # : () -> String
+      def oxc_version: () -> String
+
+      private
+
+      # : (Symbol?) -> bot
+      def unavailable: (Symbol?) -> bot
+    end
+
+    extend Unavailable
+  end
+end

data/sig/oxc/diagnosed.rbs

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

data/sig/oxc/diagnostic.rbs

@@ -0,0 +1,57 @@
+# Generated from lib/oxc/diagnostic.rb with RBS::Inline
+
+module Oxc
+  class Diagnostic
+    ERROR: String
+
+    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: (Hash[String, untyped]) -> Oxc::Diagnostic
+
+    # : (severity: String, message: String, labels: Array[Oxc::Label], ?help: String?, ?codeframe: String?) -> void
+    def initialize: (severity: String, message: String, labels: Array[Oxc::Label], ?help: String?, ?codeframe: String?) -> void
+
+    # : () -> bool
+    def error?: () -> bool
+
+    # : () -> bool
+    def warning?: () -> bool
+
+    # : () -> String
+    def to_s: () -> String
+
+    # : () -> String
+    def inspect: () -> String
+  end
+
+  class Label
+    attr_reader message: String?
+
+    attr_reader start: Integer
+
+    attr_reader finish: Integer
+
+    # : (Hash[String, untyped]) -> Oxc::Label
+    def self.from_hash: (Hash[String, untyped]) -> Oxc::Label
+
+    # : (start: Integer, finish: Integer, ?message: String?) -> void
+    def initialize: (start: Integer, finish: Integer, ?message: String?) -> void
+
+    # : (String) -> String?
+    def slice: (String) -> String?
+
+    # : () -> String
+    def inspect: () -> String
+  end
+end

data/sig/oxc/errors.rbs

@@ -0,0 +1,31 @@
+# Generated from lib/oxc/errors.rb with RBS::Inline
+
+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: (String, ?(Oxc::Result | Oxc::ParseResult)?) -> void
+
+    # : () -> Array[Oxc::Diagnostic]
+    def diagnostics: () -> Array[Oxc::Diagnostic]
+  end
+end

data/sig/oxc/minifier.rbs

@@ -0,0 +1,21 @@
+# Generated from lib/oxc/minifier.rb with RBS::Inline
+
+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: (?filename: String?, ?lang: String?, ?source_type: String?, ?compress: compress?, ?mangle: mangle?, ?codegen: codegen?, ?sourcemap: bool, ?strict: bool) -> void
+
+    # : (String, ?filename: String?, ?lang: String?, ?source_type: String?, ?compress: compress?, ?mangle: mangle?, ?codegen: codegen?, ?sourcemap: bool, ?strict: bool) -> Oxc::MinifyResult
+    def minify: (String, ?filename: String?, ?lang: String?, ?source_type: String?, ?compress: compress?, ?mangle: mangle?, ?codegen: codegen?, ?sourcemap: bool, ?strict: bool) -> Oxc::MinifyResult
+
+    alias call minify
+
+    # : (?filename: String?, ?lang: String?, ?source_type: String?, ?compress: compress?, ?mangle: mangle?, ?codegen: codegen?, ?sourcemap: bool, ?strict: bool) -> Oxc::Minifier
+    def with: (?filename: String?, ?lang: String?, ?source_type: String?, ?compress: compress?, ?mangle: mangle?, ?codegen: codegen?, ?sourcemap: bool, ?strict: bool) -> Oxc::Minifier
+
+    # : () -> String
+    def inspect: () -> String
+  end
+end

data/sig/oxc/minify_result.rbs

@@ -0,0 +1,11 @@
+# Generated from lib/oxc/minify_result.rb with RBS::Inline
+
+module Oxc
+  class MinifyResult < Result
+    # : (String) -> Oxc::MinifyResult
+    def self.from_json: (String) -> Oxc::MinifyResult
+
+    # : (code: String, diagnostics: Array[Oxc::Diagnostic], ?map: String?, ?legal_comments: Array[String], ?panicked: bool) -> void
+    def initialize: (code: String, diagnostics: Array[Oxc::Diagnostic], ?map: String?, ?legal_comments: Array[String], ?panicked: bool) -> void
+  end
+end

data/sig/oxc/mutation_visitor.rbs

@@ -0,0 +1,80 @@
+# Generated from lib/oxc/mutation_visitor.rb with RBS::Inline
+
+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
+
+    class Edit < Data
+      attr_reader start(): Integer
+
+      attr_reader finish(): Integer
+
+      attr_reader text(): String
+
+      attr_reader order(): Integer
+
+      def self.new: (Integer start, Integer finish, String text, Integer order) -> instance
+                  | (start: Integer, finish: Integer, text: String, order: Integer) -> instance
+
+      def self.members: () -> [ :start, :finish, :text, :order ]
+
+      def members: () -> [ :start, :finish, :text, :order ]
+    end
+
+    attr_reader source: String
+
+    attr_reader parsed: Oxc::ParseResult
+
+    # : (String, ?verify: bool, **untyped) -> String
+    def rewrite: (String, ?verify: bool, **untyped) -> String
+
+    # : (Oxc::Node, String) -> void
+    def replace: (Oxc::Node, String) -> void
+
+    # : (Oxc::Node) -> void
+    def remove: (Oxc::Node) -> void
+
+    # : (Oxc::Node, String) -> void
+    def insert_before: (Oxc::Node, String) -> void
+
+    # : (Oxc::Node, String) -> void
+    def insert_after: (Oxc::Node, String) -> void
+
+    # : (Oxc::Node, String, String) -> void
+    def wrap: (Oxc::Node, String, String) -> void
+
+    # : (Oxc::Node) -> void
+    def visit_children: (Oxc::Node) -> void
+
+    private
+
+    # : (String, Hash[Symbol, untyped]) -> String
+    def verified: (String, Hash[Symbol, untyped]) -> String
+
+    # : (Oxc::Node) -> bool
+    def replaced?: (Oxc::Node) -> bool
+
+    # : (Integer, Integer, String) -> void
+    def edit: (Integer, Integer, String) -> void
+
+    # : (Edit, Integer, Integer) -> bool
+    def overlaps?: (Edit, Integer, Integer) -> bool
+
+    # : () -> String
+    def apply: () -> String
+  end
+end