oxc 0.1.0-aarch64-linux-gnu → 0.2.0-aarch64-linux-gnu

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9fa077d820131502c696fa997503249eab68ff17c9b5141fcf21bb58960a18f3
-  data.tar.gz: '0943773966316220daaa10d8a6c4db27fe904cd4ef298f0199d3d50d97995e16'
+  metadata.gz: 5dc785957bee07cb9ebb340e741a8647cfa2f8fb68985c670ba655a25e88eba4
+  data.tar.gz: 1b1db8676e5eaa79c7d4c3e9617bcfb96fe7026d77eb7a96051d60cc7435f657
 SHA512:
-  metadata.gz: 412b3a718be49dede29e4c333029fc817234afec37edf7eda372eb172c833871e0b69bea2a783f4c70f3f793ed81e079094306363f25f1fd5261efa168faf22f
-  data.tar.gz: a5eab5ac59da90a729a5ec53dd64f295aeb01d840f959631d8881732d2efb4a289f65016a42ecc5b4118989b0c2208454091c63fca4267103f57b6eac2454530
+  metadata.gz: 9bd91b118312a60ff6d7abcd60142db4582f0fc2173ecaa350e85c2ccb1d0c5a39405495c4fadf55cb269795bbeb556460cf408ef92ed56e132115ead4d7e734
+  data.tar.gz: 4f6760423b7ae3db60792d5da5df4ff1313f96f9042b122a2cac2f062cb720f855639d55716fa486df9b4087954a72fe7b767c68985969e558a1949ae6c710af

data/README.md

@@ -205,6 +205,171 @@ Oxc.parse("let a; let a;", semantic_errors: true).errors.map(&:message)
 #=> ["Identifier `a` has already been declared"]
 ```
 
+#### Walking the AST
+
+`root` answers the program as an `Oxc::Node`, which walks, reads its fields by name, and knows what it sits inside.
+
+```ruby
+root = Oxc.parse(source).root
+
+root.type                 #=> "Program"
+root.keys                 #=> the ESTree fields this node carries
+root.fields               #=> those fields and their values, without the span
+root.child_nodes          #=> the nodes directly under it
+root.every("Identifier")  #=> every identifier in the file
+root.at(offset)           #=> the innermost node covering a byte offset
+root.each                 #=> an Enumerator over every node
+```
+
+Inspecting a node shows every field it carries, so there is always something to reach for next.
+
+```
+#<Oxc::Node VariableDeclaration range=[0, 13] kind="let" declarations=[... 1 item]>
+#<Oxc::Node VariableDeclarator range=[4, 13] id=#<Oxc::Node Identifier> init=#<Oxc::Node Literal>>
+#<Oxc::Node Identifier range=[4, 9] name="count">
+```
+
+Every field is there, so what `inspect` prints and what `keys` answers never disagree. A field holding a node prints as that node's type, one holding a list prints how many it holds, and one holding nothing prints the `nil`, the `false` or the `[]` it holds.
+
+An ESTree field always wins over a method of the gem's own, since `name`, `attributes` and `children` are all real fields. `Identifier#name` is the identifier's name, `JSXElement#children` is what the element wraps, and `ImportDeclaration#attributes` is the import's `with` clause. The walker spells its own versions `underscored_type`, `to_h` and `child_nodes`, which no ESTree field can be called.
+
+A field comes back as a node when it holds one, so reads chain.
+
+```ruby
+declaration = root.child_nodes.first
+
+declaration.kind
+#=> "let"
+
+declaration.declarations.first.id.name
+#=> "count"
+```
+
+ESTree names its fields in camelCase, and a field answers to its snake_case name too, so reading an AST does not mean writing JavaScript casing in Ruby.
+
+```ruby
+node.type_annotation   # the same field as node.typeAnnotation
+node.super_class       # superClass
+root.source_type       # sourceType
+```
+
+Patterns take either name as well, binding what you asked for.
+
+```ruby
+node => { type_annotation: { type: }, readonly: }
+```
+
+`ancestors` is what a rewrite needs, since a reference sits inside the expression that has to be replaced.
+
+```ruby
+reference = root.at(source.index("count +="))
+reference.ancestors.find { |node| node.type == "AssignmentExpression" }.slice
+#=> "count += 1"
+```
+
+A parse result keeps the source it read and hands it down to every node it builds, so `slice` answers with no argument at all.
+
+```ruby
+parsed = Oxc.parse(source)
+
+parsed.source
+#=> "let count = 0\nfunction bump() { count += 1; render(count) }"
+
+parsed.root.every("FunctionDeclaration").first.slice
+#=> "function bump() { count += 1; render(count) }"
+```
+
+It still takes one, for a node assembled by hand or read against a different string.
+
+```ruby
+node.slice(other_source)
+```
+
+Nodes pattern match, and nest, since a field holding a node comes back as one.
+
+```ruby
+node => { type: "VariableDeclarator", id: { name: }, init: { value: } }
+name   #=> "count"
+value  #=> 0
+
+root.select { |node| node in { type: "FunctionDeclaration", id: { name: /^handle/ } } }
+```
+
+`deconstruct_keys` is the whole protocol here. There is no `deconstruct`, since `each` yields every descendant and an array pattern over direct children would disagree with `to_a`.
+
+`to_h` and `to_json` answer the ESTree the node wraps, which is what a snapshot test or a dump to another tool wants.
+
+```ruby
+node.to_h
+#=> { "type" => "Identifier", "name" => "count", "start" => 4, "end" => 9 }
+
+node.to_json
+#=> "{\"type\":\"Identifier\",\"name\":\"count\",\"start\":4,\"end\":9}"
+```
+
+`Oxc::Visitor` answers a node with the method named after its type, and walks through anything nothing answers.
+
+```ruby
+class Reads < Oxc::Visitor
+  def visit_assignment_expression(node)
+    puts "#{node.left["name"]} #{node.operator}"
+
+    visit_children(node)
+  end
+end
+
+Reads.new.visit(Oxc.parse(source))
+```
+
+It takes a parse result or a node, so the common case needs no `root`. A result with no AST is nothing to walk and visits nothing.
+
+There is one node class, not one per type, so a type the gem has never seen still walks and still answers. The types and their fields are [ESTree](https://github.com/estree/estree). For the TypeScript and JSX nodes, which ESTree does not cover, oxc publishes the exact shapes it emits as [`@oxc-project/types`](https://www.npmjs.com/package/@oxc-project/types).
+
+#### Rewriting
+
+`Oxc::MutationVisitor` records what to do to a node and splices the original text at the end, so everything it did not touch survives byte for byte, comments and indentation included.
+
+```ruby
+class Renamer < Oxc::MutationVisitor
+  def visit_identifier(node)
+    replace(node, "renamed") if node["name"] == "count"
+  end
+end
+
+Renamer.new.rewrite("let count = 1 // keep me")
+#=> "let renamed = 1 // keep me"
+```
+
+`replace`, `remove`, `insert_before`, `insert_after` and `wrap` are the operations, and each takes a node. Spans are exact, so removing `debugger;` removes what the node covered and leaves the newline after it alone.
+
+Walking into a node that was replaced would edit text that is no longer there, so it stops. Two edits over the same span raise `Oxc::MutationVisitor::Overlap` instead of quietly producing something broken.
+
+What goes in is text, so a node can become anything, including several statements or nothing at all. Nothing checks it on the way, so the result is read back afterwards and refused if it stopped being JavaScript.
+
+```ruby
+Breaker.new.rewrite("foo(data)")
+#=> Oxc::MutationVisitor::Invalid: what was rewritten no longer reads as JavaScript: Unexpected token
+```
+
+Pass `verify: false` for a fragment that was never going to parse on its own.
+
+`parsed` reaches what the source parsed to, so a rewrite can ask for symbols and drive from them. That is the difference between rewriting a name and rewriting the right one.
+
+```ruby
+class ToState < Oxc::MutationVisitor
+  def rewrite(source) = super(source, symbols: true)
+
+  def visit_identifier(node)
+    reference = parsed.symbols.fetch("declared").flat_map { |symbol| symbol["references"] }
+      .find { |found| found["start"] == node.start }
+
+    replace(node, %(state.get("#{node["name"]}"))) if reference && !reference["write"]
+  end
+end
+```
+
+Drive from references, not from every `Identifier`. That is what keeps a declaration, a shadowed local, and a same-named property out of the rewrite.
+
 #### What a file declared, and what it only used
 
 `symbols: true` answers every binding with the span it was declared at and the spans of every reference to it, plus the names the file used without declaring.

data/ext/oxc/extconf.rb

@@ -65,12 +65,12 @@ if target_platform
 
   system("rustup target add #{target_platform}") || warn("oxc: Failed to add Rust target #{target_platform}")
 
-  cargo_args = "--release --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"
+  cargo_args = "--release --locked"
   lib_dir = File.join(target_dir, "release")
 end
 

data/lib/oxc/diagnostic.rb

@@ -80,7 +80,7 @@ module Oxc
 
     #: () -> String
     def inspect
-      "#<#{self.class.name} #{start}..#{finish}#{" #{message.inspect}" if message}>"
+      "#<#{self.class.name} range=[#{start}, #{finish}]#{" #{message.inspect}" if message}>"
     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

data/lib/oxc/node.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+module Oxc
+  class Node
+    include Enumerable #[Oxc::Node]
+
+    ACRONYM = /([A-Z]+)([A-Z][a-z])/ #: Regexp
+    BOUNDARY = /([a-z\d])([A-Z])/ #: Regexp
+    SPAN = ["type", "start", "end"].freeze #: Array[String]
+
+    attr_reader :parent #: Oxc::Node?
+
+    protected
+
+    attr_reader :attributes #: Hash[String, untyped]
+    attr_reader :text #: String?
+
+    public
+
+    #: (Hash[String, untyped], ?Oxc::Node?, ?String?) -> void
+    def initialize(attributes, parent = nil, text = nil)
+      @attributes = attributes
+      @parent = parent
+      @text = text || parent&.text
+    end
+
+    #: () -> String
+    def type
+      attributes.fetch("type")
+    end
+
+    #: () -> Integer
+    def start
+      attributes.fetch("start")
+    end
+
+    #: () -> Integer
+    def finish
+      attributes.fetch("end")
+    end
+
+    #: () -> String
+    def underscored_type
+      @underscored_type ||= type.gsub(ACRONYM, '\1_\2').gsub(BOUNDARY, '\1_\2').downcase
+    end
+
+    #: (String) -> untyped
+    def [](key)
+      attributes[key]
+    end
+
+    #: (?String?) -> String?
+    def slice(from = text)
+      raise ArgumentError, "this node does not know its source, so #slice needs it" unless from
+
+      from.byteslice(start, finish - start)
+    end
+
+    #: () -> Array[String]
+    def keys
+      attributes.keys
+    end
+
+    #: () -> Hash[String, untyped]
+    def to_h
+      attributes
+    end
+
+    #: (?untyped) -> String
+    def to_json(state = nil)
+      state ? attributes.to_json(state) : attributes.to_json
+    end
+
+    #: (Array[Symbol]?) -> Hash[Symbol, untyped]
+    def deconstruct_keys(keys)
+      found = {} #: Hash[Symbol, untyped]
+
+      if keys
+        keys.each do |name|
+          key = field_for(name.to_s)
+
+          found[name] = wrap(attributes[key]) if key
+        end
+      else
+        attributes.each_key { |key| found[key.to_sym] = wrap(attributes[key]) }
+      end
+
+      found
+    end
+
+    #: () -> Array[Oxc::Node]
+    def child_nodes
+      @child_nodes ||= attributes.each_value
+                                 .flat_map { |value| value.is_a?(Array) ? value : [value] }
+                                 .select { |value| value.is_a?(Hash) && value.key?("type") }
+                                 .map { |value| Node.new(value, self) }
+                                 .freeze
+    end
+
+    #: () { (Oxc::Node) -> void } -> void
+    #: () -> Enumerator[Oxc::Node, void]
+    def each(&)
+      return enum_for(:each) unless block_given?
+
+      yield self
+
+      child_nodes.each { |child| child.each(&) }
+    end
+
+    #: () -> Array[Oxc::Node]
+    def ancestors
+      parent ? [parent, *parent.ancestors] : []
+    end
+
+    #: (Integer) -> Oxc::Node?
+    def at(offset)
+      covering = each.select { |node| offset >= node.start && offset < node.finish }
+
+      covering.min_by { |node| node.finish - node.start }
+    end
+
+    #: (String) -> Array[Oxc::Node]
+    def every(type)
+      each.select { |node| node.type == type }
+    end
+
+    #: () -> Hash[String, untyped]
+    def fields
+      attributes.except(*SPAN)
+    end
+
+    #: () -> String
+    def inspect
+      described = fields.map { |key, value| described_field(key, value) }
+
+      "#<#{self.class.name} #{type} range=[#{start}, #{finish}]#{" #{described.join(" ")}" unless described.empty?}>"
+    end
+
+    #: (Symbol, *untyped) -> untyped
+    def method_missing(name, *arguments)
+      key = field_for(name.to_s)
+
+      return super unless key
+
+      wrap(attributes[key])
+    end
+
+    #: (Symbol, ?bool) -> bool
+    def respond_to_missing?(name, include_private = false)
+      !field_for(name.to_s).nil? || super
+    end
+
+    private
+
+    #: (String, untyped) -> String
+    def described_field(key, value)
+      case value
+      when Array then "#{key}=#{if value.empty?
+                                  "[]"
+                                else
+                                  "[... #{value.length} #{value.length == 1 ? "item" : "items"}]"
+                                end}"
+      when Hash then "#{key}=#<#{self.class.name} #{value["type"]}>"
+      else "#{key}=#{value.inspect}"
+      end
+    end
+
+    #: (String) -> String?
+    def field_for(name)
+      return name if attributes.key?(name)
+
+      camelized = name.gsub(/_([a-z\d])/) { Regexp.last_match(1).to_s.upcase }
+
+      camelized if attributes.key?(camelized)
+    end
+
+    #: (untyped) -> untyped
+    def wrap(value)
+      case value
+      when Hash then value.key?("type") ? Node.new(value, self, text) : value
+      when Array then value.map { |item| wrap(item) }
+      else value
+      end
+    end
+  end
+end

data/lib/oxc/options.rb

@@ -72,9 +72,9 @@ module Oxc
       freeze
     end
 
-    #: (?untyped) -> String
+    #: (?JSON::options?) -> String
     def to_json(state = nil)
-      JSON.generate(to_h, state)
+      state ? JSON.generate(to_h, state) : JSON.generate(to_h)
     end
 
     #: () -> String

data/lib/oxc/parse_result.rb

@@ -4,17 +4,19 @@ module Oxc
   class ParseResult
     include Diagnosed
 
+    attr_reader :source #: String?
     attr_reader :program #: Hash[String, untyped]?
     attr_reader :module_record #: Hash[String, untyped]?
     attr_reader :symbols #: Hash[String, untyped]?
     attr_reader :comments #: Array[Oxc::Comment]
     attr_reader :diagnostics #: Array[Oxc::Diagnostic]
 
-    #: (String) -> Oxc::ParseResult
-    def self.from_json(payload)
+    #: (String, ?String?) -> Oxc::ParseResult
+    def self.from_json(payload, source = nil)
       parsed = JSON.parse(payload)
 
       new(
+        source: source,
         program: parsed["program"],
         module_record: parsed["module_record"],
         symbols: parsed["symbols"],
@@ -24,8 +26,9 @@ module Oxc
       )
     end
 
-    #: (comments: Array[Oxc::Comment], diagnostics: Array[Oxc::Diagnostic], ?program: Hash[String, untyped]?, ?module_record: Hash[String, untyped]?, ?symbols: Hash[String, untyped]?, ?panicked: bool) -> void
-    def initialize(comments:, diagnostics:, program: nil, module_record: nil, symbols: nil, panicked: false)
+    #: (comments: Array[Oxc::Comment], diagnostics: Array[Oxc::Diagnostic], ?source: String?, ?program: Hash[String, untyped]?, ?module_record: Hash[String, untyped]?, ?symbols: Hash[String, untyped]?, ?panicked: bool) -> void
+    def initialize(comments:, diagnostics:, source: nil, program: nil, module_record: nil, symbols: nil, panicked: false)
+      @source = source
       @program = program.freeze
       @module_record = module_record.freeze
       @symbols = symbols.freeze
@@ -36,6 +39,11 @@ module Oxc
       freeze
     end
 
+    #: () -> Oxc::Node?
+    def root
+      program ? Node.new(program, nil, source) : nil
+    end
+
     #: () -> Oxc::ParseResult
     def validate!
       return self unless errors? || panicked?
@@ -46,7 +54,9 @@ module Oxc
     #: () -> String
     def inspect
       parts = [] #: Array[String]
-      parts << "program=#{program["type"]}" if program
+      parts << "#{root&.type} range=[#{root&.start}, #{root&.finish}]" if program
+      parts << "module_record" if module_record
+      parts << "symbols=#{symbols.fetch("declared").length}" if symbols
       parts << "comments=#{comments.length}" unless comments.empty?
       parts << "diagnostics=#{diagnostics.length}" unless diagnostics.empty?
 

data/lib/oxc/result.rb

@@ -18,7 +18,7 @@ module Oxc
       @panicked = panicked
     end
 
-    #: (?strict: untyped) -> self
+    #: (?strict: bool?) -> self
     def validate!(strict: false)
       return self unless errors? || panicked?
       return self unless strict || panicked? || code.empty?

data/lib/oxc/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Oxc
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/oxc/visitor.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Oxc
+  class Visitor
+    #: (Oxc::Node | Oxc::ParseResult) -> void
+    def visit(node)
+      node = node.root if node.is_a?(ParseResult)
+
+      return nil unless node
+
+      answer = "visit_#{node.underscored_type}"
+
+      respond_to?(answer) ? public_send(answer, node) : visit_children(node)
+
+      nil
+    end
+
+    #: (Oxc::Node) -> void
+    def visit_children(node)
+      node.child_nodes.each { |child| visit(child) }
+
+      nil
+    end
+  end
+end

data/lib/oxc.rb

@@ -19,6 +19,9 @@ require_relative "oxc/diagnosed"
 require_relative "oxc/result"
 require_relative "oxc/minify_result"
 require_relative "oxc/transform_result"
+require_relative "oxc/node"
+require_relative "oxc/visitor"
+require_relative "oxc/mutation_visitor"
 require_relative "oxc/parse_result"
 require_relative "oxc/transformer"
 require_relative "oxc/minifier"
@@ -28,21 +31,21 @@ module Oxc
   def self.minify(source, **options)
     serialized = Options.serialize(options, Options::MINIFY, "minify")
 
-    MinifyResult.from_json(Backend.minify(source.to_s, serialized)).validate!(strict: options[:strict])
+    MinifyResult.from_json(Backend.minify(source.to_s, serialized)).validate!(strict: options[:strict] ? true : false)
   end
 
   #: (String, ?filename: String?, ?lang: String?, ?source_type: String?, ?cwd: String?, ?target: targets?, ?jsx: jsx?, ?typescript: typescript?, ?assumptions: assumptions?, ?decorator: decorator?, ?helpers: helpers?, ?define: Hash[String, String]?, ?inject: inject?, ?minify: minify?, ?codegen: codegen?, ?sourcemap: bool, ?strict: bool) -> Oxc::TransformResult
   def self.transform(source, **options)
     serialized = Options.serialize(options, Options::TRANSFORM, "transform")
 
-    TransformResult.from_json(Backend.transform(source.to_s, serialized)).validate!(strict: options[:strict])
+    TransformResult.from_json(Backend.transform(source.to_s, serialized)).validate!(strict: options[:strict] ? true : false)
   end
 
   #: (String, ?filename: String?, ?lang: String?, ?source_type: String?, ?ast_type: String?, ?ast: bool, ?ranges: bool, ?preserve_parens: bool, ?comments: bool, ?module_record: bool, ?symbols: bool, ?semantic_errors: bool) -> Oxc::ParseResult
   def self.parse(source, **options)
     serialized = Options.serialize(options, Options::PARSE, "parse")
 
-    ParseResult.from_json(Backend.parse(source.to_s, serialized))
+    ParseResult.from_json(Backend.parse(source.to_s, serialized), source.to_s)
   end
 
   #: () -> String

data/rust/Cargo.lock

@@ -517,7 +517,7 @@ dependencies = [
 
 [[package]]
 name = "oxc-ruby-ffi"
-version = "0.1.0"
+version = "0.2.0"
 dependencies = [
  "cbindgen",
  "oxc",

data/rust/Cargo.toml

@@ -2,7 +2,7 @@
 
 [package]
 name = "oxc-ruby-ffi"
-version = "0.1.0"
+version = "0.2.0"
 edition = "2021"
 authors = ["Marco Roth <marco.roth@intergga.ch>"]
 description = "C FFI bindings for oxc, used by the oxc gem"

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

data/sig/oxc/node.rbs

@@ -0,0 +1,94 @@
+# Generated from lib/oxc/node.rb with RBS::Inline
+
+module Oxc
+  class Node
+    include Enumerable[Oxc::Node]
+
+    ACRONYM: Regexp
+
+    BOUNDARY: Regexp
+
+    SPAN: Array[String]
+
+    attr_reader parent: Oxc::Node?
+
+    attr_reader attributes: Hash[String, untyped]
+
+    attr_reader text: String?
+
+    public
+
+    # : (Hash[String, untyped], ?Oxc::Node?, ?String?) -> void
+    def initialize: (Hash[String, untyped], ?Oxc::Node?, ?String?) -> void
+
+    # : () -> String
+    def type: () -> String
+
+    # : () -> Integer
+    def start: () -> Integer
+
+    # : () -> Integer
+    def finish: () -> Integer
+
+    # : () -> String
+    def underscored_type: () -> String
+
+    # : (String) -> untyped
+    def []: (String) -> untyped
+
+    # : (?String?) -> String?
+    def slice: (?String?) -> String?
+
+    # : () -> Array[String]
+    def keys: () -> Array[String]
+
+    # : () -> Hash[String, untyped]
+    def to_h: () -> Hash[String, untyped]
+
+    # : (?untyped) -> String
+    def to_json: (?untyped) -> String
+
+    # : (Array[Symbol]?) -> Hash[Symbol, untyped]
+    def deconstruct_keys: (Array[Symbol]?) -> Hash[Symbol, untyped]
+
+    # : () -> Array[Oxc::Node]
+    def child_nodes: () -> Array[Oxc::Node]
+
+    # : () { (Oxc::Node) -> void } -> void
+    # : () -> Enumerator[Oxc::Node, void]
+    def each: () { (Oxc::Node) -> void } -> void
+            | () -> Enumerator[Oxc::Node, void]
+
+    # : () -> Array[Oxc::Node]
+    def ancestors: () -> Array[Oxc::Node]
+
+    # : (Integer) -> Oxc::Node?
+    def at: (Integer) -> Oxc::Node?
+
+    # : (String) -> Array[Oxc::Node]
+    def every: (String) -> Array[Oxc::Node]
+
+    # : () -> Hash[String, untyped]
+    def fields: () -> Hash[String, untyped]
+
+    # : () -> String
+    def inspect: () -> String
+
+    # : (Symbol, *untyped) -> untyped
+    def method_missing: (Symbol, *untyped) -> untyped
+
+    # : (Symbol, ?bool) -> bool
+    def respond_to_missing?: (Symbol, ?bool) -> bool
+
+    private
+
+    # : (String, untyped) -> String
+    def described_field: (String, untyped) -> String
+
+    # : (String) -> String?
+    def field_for: (String) -> String?
+
+    # : (untyped) -> untyped
+    def wrap: (untyped) -> untyped
+  end
+end

data/sig/oxc/options.rbs

@@ -25,8 +25,8 @@ module Oxc
     # : (Hash[Symbol, untyped], ?Array[Symbol], ?String) -> void
     def initialize: (Hash[Symbol, untyped], ?Array[Symbol], ?String) -> void
 
-    # : (?untyped) -> String
-    def to_json: (?untyped) -> String
+    # : (?JSON::options?) -> String
+    def to_json: (?JSON::options?) -> String
 
     # : () -> String
     def inspect: () -> String

data/sig/oxc/parse_result.rbs

@@ -4,6 +4,8 @@ module Oxc
   class ParseResult
     include Diagnosed
 
+    attr_reader source: String?
+
     attr_reader program: Hash[String, untyped]?
 
     attr_reader module_record: Hash[String, untyped]?
@@ -14,11 +16,14 @@ module Oxc
 
     attr_reader diagnostics: Array[Oxc::Diagnostic]
 
-    # : (String) -> Oxc::ParseResult
-    def self.from_json: (String) -> Oxc::ParseResult
+    # : (String, ?String?) -> Oxc::ParseResult
+    def self.from_json: (String, ?String?) -> Oxc::ParseResult
+
+    # : (comments: Array[Oxc::Comment], diagnostics: Array[Oxc::Diagnostic], ?source: String?, ?program: Hash[String, untyped]?, ?module_record: Hash[String, untyped]?, ?symbols: Hash[String, untyped]?, ?panicked: bool) -> void
+    def initialize: (comments: Array[Oxc::Comment], diagnostics: Array[Oxc::Diagnostic], ?source: String?, ?program: Hash[String, untyped]?, ?module_record: Hash[String, untyped]?, ?symbols: Hash[String, untyped]?, ?panicked: bool) -> void
 
-    # : (comments: Array[Oxc::Comment], diagnostics: Array[Oxc::Diagnostic], ?program: Hash[String, untyped]?, ?module_record: Hash[String, untyped]?, ?symbols: Hash[String, untyped]?, ?panicked: bool) -> void
-    def initialize: (comments: Array[Oxc::Comment], diagnostics: Array[Oxc::Diagnostic], ?program: Hash[String, untyped]?, ?module_record: Hash[String, untyped]?, ?symbols: Hash[String, untyped]?, ?panicked: bool) -> void
+    # : () -> Oxc::Node?
+    def root: () -> Oxc::Node?
 
     # : () -> Oxc::ParseResult
     def validate!: () -> Oxc::ParseResult

data/sig/oxc/result.rbs

@@ -15,8 +15,8 @@ module Oxc
     # : (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
 
-    # : (?strict: untyped) -> self
-    def validate!: (?strict: untyped) -> self
+    # : (?strict: bool?) -> self
+    def validate!: (?strict: bool?) -> self
 
     # : () -> String
     def to_s: () -> String

data/sig/oxc/visitor.rbs

@@ -0,0 +1,11 @@
+# Generated from lib/oxc/visitor.rb with RBS::Inline
+
+module Oxc
+  class Visitor
+    # : (Oxc::Node | Oxc::ParseResult) -> void
+    def visit: (Oxc::Node | Oxc::ParseResult) -> void
+
+    # : (Oxc::Node) -> void
+    def visit_children: (Oxc::Node) -> void
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: oxc
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: aarch64-linux-gnu
 authors:
 - Marco Roth
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-08-25 00:00:00.000000000 Z
+date: 2026-08-26 00:00:00.000000000 Z
 dependencies: []
 description: Ruby bindings for Oxc, the JavaScript Oxidation Compiler. A collection
   of high-performance tools for JavaScript and TypeScript written in Rust.
@@ -34,12 +34,15 @@ files:
 - lib/oxc/errors.rb
 - lib/oxc/minifier.rb
 - lib/oxc/minify_result.rb
+- lib/oxc/mutation_visitor.rb
+- lib/oxc/node.rb
 - lib/oxc/options.rb
 - lib/oxc/parse_result.rb
 - lib/oxc/result.rb
 - lib/oxc/transform_result.rb
 - lib/oxc/transformer.rb
 - lib/oxc/version.rb
+- lib/oxc/visitor.rb
 - licenses/README.md
 - licenses/oxc-MIT.txt
 - licenses/oxc-THIRD-PARTY.txt
@@ -65,6 +68,8 @@ files:
 - sig/oxc/errors.rbs
 - sig/oxc/minifier.rbs
 - sig/oxc/minify_result.rbs
+- sig/oxc/mutation_visitor.rbs
+- sig/oxc/node.rbs
 - sig/oxc/options.rbs
 - sig/oxc/parse_result.rbs
 - sig/oxc/result.rbs
@@ -72,6 +77,7 @@ files:
 - sig/oxc/transformer.rbs
 - sig/oxc/types.rbs
 - sig/oxc/version.rbs
+- sig/oxc/visitor.rbs
 homepage: https://github.com/marcoroth/oxc-ruby
 licenses:
 - MIT