syntax_tree 5.0.0 → 5.1.0

data/lib/syntax_tree/yarv/legacy.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+module SyntaxTree
+  module YARV
+    # This module contains the instructions that used to be a part of YARV but
+    # have been replaced or removed in more recent versions.
+    module Legacy
+      # ### Summary
+      #
+      # `getclassvariable` looks for a class variable in the current class and
+      # pushes its value onto the stack.
+      #
+      # This version of the `getclassvariable` instruction is no longer used
+      # since in Ruby 3.0 it gained an inline cache.`
+      #
+      # ### Usage
+      #
+      # ~~~ruby
+      # @@class_variable
+      # ~~~
+      #
+      class GetClassVariable
+        attr_reader :name
+
+        def initialize(name)
+          @name = name
+        end
+
+        def disasm(fmt)
+          fmt.instruction("getclassvariable", [fmt.object(name)])
+        end
+
+        def to_a(_iseq)
+          [:getclassvariable, name]
+        end
+
+        def length
+          2
+        end
+
+        def pops
+          0
+        end
+
+        def pushes
+          1
+        end
+      end
+
+      # ### Summary
+      #
+      # `opt_getinlinecache` is a wrapper around a series of `putobject` and
+      # `getconstant` instructions that allows skipping past them if the inline
+      # cache is currently set. It pushes the value of the cache onto the stack
+      # if it is set, otherwise it pushes `nil`.
+      #
+      # This instruction is no longer used since in Ruby 3.2 it was replaced by
+      # the consolidated `opt_getconstant_path` instruction.
+      #
+      # ### Usage
+      #
+      # ~~~ruby
+      # Constant
+      # ~~~
+      #
+      class OptGetInlineCache
+        attr_reader :label, :cache
+
+        def initialize(label, cache)
+          @label = label
+          @cache = cache
+        end
+
+        def disasm(fmt)
+          fmt.instruction(
+            "opt_getinlinecache",
+            [fmt.label(label), fmt.inline_storage(cache)]
+          )
+        end
+
+        def to_a(_iseq)
+          [:opt_getinlinecache, label.name, cache]
+        end
+
+        def length
+          3
+        end
+
+        def pops
+          0
+        end
+
+        def pushes
+          1
+        end
+
+        def call(vm)
+          vm.push(nil)
+        end
+      end
+
+      # ### Summary
+      #
+      # `opt_setinlinecache` sets an inline cache for a constant lookup. It pops
+      # the value it should set off the top of the stack. It then pushes that
+      # value back onto the top of the stack.
+      #
+      # This instruction is no longer used since in Ruby 3.2 it was replaced by
+      # the consolidated `opt_getconstant_path` instruction.
+      #
+      # ### Usage
+      #
+      # ~~~ruby
+      # Constant
+      # ~~~
+      #
+      class OptSetInlineCache
+        attr_reader :cache
+
+        def initialize(cache)
+          @cache = cache
+        end
+
+        def disasm(fmt)
+          fmt.instruction("opt_setinlinecache", [fmt.inline_storage(cache)])
+        end
+
+        def to_a(_iseq)
+          [:opt_setinlinecache, cache]
+        end
+
+        def length
+          2
+        end
+
+        def pops
+          1
+        end
+
+        def pushes
+          1
+        end
+
+        def call(vm)
+          vm.push(vm.pop)
+        end
+      end
+
+      # ### Summary
+      #
+      # `setclassvariable` looks for a class variable in the current class and
+      # sets its value to the value it pops off the top of the stack.
+      #
+      # This version of the `setclassvariable` instruction is no longer used
+      # since in Ruby 3.0 it gained an inline cache.
+      #
+      # ### Usage
+      #
+      # ~~~ruby
+      # @@class_variable = 1
+      # ~~~
+      #
+      class SetClassVariable
+        attr_reader :name
+
+        def initialize(name)
+          @name = name
+        end
+
+        def disasm(fmt)
+          fmt.instruction("setclassvariable", [fmt.object(name)])
+        end
+
+        def to_a(_iseq)
+          [:setclassvariable, name]
+        end
+
+        def length
+          2
+        end
+
+        def pops
+          1
+        end
+
+        def pushes
+          0
+        end
+      end
+    end
+  end
+end

data/lib/syntax_tree/yarv/local_table.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module SyntaxTree
+  module YARV
+    # This represents every local variable associated with an instruction
+    # sequence. There are two kinds of locals: plain locals that are what you
+    # expect, and block proxy locals, which represent local variables
+    # associated with blocks that were passed into the current instruction
+    # sequence.
+    class LocalTable
+      # A local representing a block passed into the current instruction
+      # sequence.
+      class BlockLocal
+        attr_reader :name
+
+        def initialize(name)
+          @name = name
+        end
+      end
+
+      # A regular local variable.
+      class PlainLocal
+        attr_reader :name
+
+        def initialize(name)
+          @name = name
+        end
+      end
+
+      # The result of looking up a local variable in the current local table.
+      class Lookup
+        attr_reader :local, :index, :level
+
+        def initialize(local, index, level)
+          @local = local
+          @index = index
+          @level = level
+        end
+      end
+
+      attr_reader :locals
+
+      def initialize
+        @locals = []
+      end
+
+      def empty?
+        locals.empty?
+      end
+
+      def find(name, level = 0)
+        index = locals.index { |local| local.name == name }
+        Lookup.new(locals[index], index, level) if index
+      end
+
+      def has?(name)
+        locals.any? { |local| local.name == name }
+      end
+
+      def names
+        locals.map(&:name)
+      end
+
+      def name_at(index)
+        locals[index].name
+      end
+
+      def size
+        locals.length
+      end
+
+      # Add a BlockLocal to the local table.
+      def block(name)
+        locals << BlockLocal.new(name) unless has?(name)
+      end
+
+      # Add a PlainLocal to the local table.
+      def plain(name)
+        locals << PlainLocal.new(name) unless has?(name)
+      end
+
+      # This is the offset from the top of the stack where this local variable
+      # lives.
+      def offset(index)
+        size - (index - 3) - 1
+      end
+    end
+  end
+end

data/lib/syntax_tree/yarv.rb

@@ -0,0 +1,287 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module SyntaxTree
+  # This module provides an object representation of the YARV bytecode.
+  module YARV
+    class VM
+      class Jump
+        attr_reader :name
+
+        def initialize(name)
+          @name = name
+        end
+      end
+
+      class Leave
+        attr_reader :value
+
+        def initialize(value)
+          @value = value
+        end
+      end
+
+      class Frame
+        attr_reader :iseq, :parent, :stack_index, :_self, :nesting, :svars
+
+        def initialize(iseq, parent, stack_index, _self, nesting)
+          @iseq = iseq
+          @parent = parent
+          @stack_index = stack_index
+          @_self = _self
+          @nesting = nesting
+          @svars = {}
+        end
+      end
+
+      class TopFrame < Frame
+        def initialize(iseq)
+          super(iseq, nil, 0, TOPLEVEL_BINDING.eval("self"), [Object])
+        end
+      end
+
+      class BlockFrame < Frame
+        def initialize(iseq, parent, stack_index)
+          super(iseq, parent, stack_index, parent._self, parent.nesting)
+        end
+      end
+
+      class MethodFrame < Frame
+        attr_reader :name, :block
+
+        def initialize(iseq, parent, stack_index, _self, name, block)
+          super(iseq, parent, stack_index, _self, parent.nesting)
+          @name = name
+          @block = block
+        end
+      end
+
+      class ClassFrame < Frame
+        def initialize(iseq, parent, stack_index, _self)
+          super(iseq, parent, stack_index, _self, parent.nesting + [_self])
+        end
+      end
+
+      class FrozenCore
+        define_method("core#hash_merge_kwd") { |left, right| left.merge(right) }
+
+        define_method("core#hash_merge_ptr") do |hash, *values|
+          hash.merge(values.each_slice(2).to_h)
+        end
+
+        define_method("core#set_method_alias") do |clazz, new_name, old_name|
+          clazz.alias_method(new_name, old_name)
+        end
+
+        define_method("core#set_variable_alias") do |new_name, old_name|
+          # Using eval here since there isn't a reflection API to be able to
+          # alias global variables.
+          eval("alias #{new_name} #{old_name}", binding, __FILE__, __LINE__)
+        end
+
+        define_method("core#set_postexe") { |&block| END { block.call } }
+
+        define_method("core#undef_method") do |clazz, name|
+          clazz.undef_method(name)
+        end
+      end
+
+      FROZEN_CORE = FrozenCore.new.freeze
+
+      extend Forwardable
+
+      attr_reader :stack
+      def_delegators :stack, :push, :pop
+
+      attr_reader :frame
+      def_delegators :frame, :_self
+
+      def initialize
+        @stack = []
+        @frame = nil
+      end
+
+      ##########################################################################
+      # Helper methods for frames
+      ##########################################################################
+
+      def run_frame(frame)
+        # First, set the current frame to the given value.
+        @frame = frame
+
+        # Next, set up the local table for the frame. This is actually incorrect
+        # as it could use the values already on the stack, but for now we're
+        # just doing this for simplicity.
+        frame.iseq.local_table.size.times { push(nil) }
+
+        # Yield so that some frame-specific setup can be done.
+        yield if block_given?
+
+        # This hash is going to hold a mapping of label names to their
+        # respective indices in our instruction list.
+        labels = {}
+
+        # This array is going to hold our instructions.
+        insns = []
+
+        # Here we're going to preprocess the instruction list from the
+        # instruction sequence to set up the labels hash and the insns array.
+        frame.iseq.insns.each do |insn|
+          case insn
+          when Integer, Symbol
+            # skip
+          when InstructionSequence::Label
+            labels[insn.name] = insns.length
+          else
+            insns << insn
+          end
+        end
+
+        # Finally we can execute the instructions one at a time. If they return
+        # jumps or leaves we will handle those appropriately.
+        pc = 0
+        while pc < insns.length
+          insn = insns[pc]
+          pc += 1
+
+          case (result = insn.call(self))
+          when Jump
+            pc = labels[result.name]
+          when Leave
+            return result.value
+          end
+        end
+      ensure
+        @stack = stack[0...frame.stack_index]
+        @frame = frame.parent
+      end
+
+      def run_top_frame(iseq)
+        run_frame(TopFrame.new(iseq))
+      end
+
+      def run_block_frame(iseq, *args, &block)
+        run_frame(BlockFrame.new(iseq, frame, stack.length)) do
+          locals = [*args, block]
+          iseq.local_table.size.times do |index|
+            local_set(index, 0, locals.shift)
+          end
+        end
+      end
+
+      def run_class_frame(iseq, clazz)
+        run_frame(ClassFrame.new(iseq, frame, stack.length, clazz))
+      end
+
+      def run_method_frame(name, iseq, _self, *args, **kwargs, &block)
+        run_frame(
+          MethodFrame.new(iseq, frame, stack.length, _self, name, block)
+        ) do
+          locals = [*args, block]
+
+          if iseq.argument_options[:keyword]
+            # First, set up the keyword bits array.
+            keyword_bits =
+              iseq.argument_options[:keyword].map do |config|
+                kwargs.key?(config.is_a?(Array) ? config[0] : config)
+              end
+
+            iseq.local_table.locals.each_with_index do |local, index|
+              # If this is the keyword bits local, then set it appropriately.
+              if local.name == 2
+                locals.insert(index, keyword_bits)
+                next
+              end
+
+              # First, find the configuration for this local in the keywords
+              # list if it exists.
+              name = local.name
+              config =
+                iseq.argument_options[:keyword].find do |keyword|
+                  keyword.is_a?(Array) ? keyword[0] == name : keyword == name
+                end
+
+              # If the configuration doesn't exist, then the local is not a
+              # keyword local.
+              next unless config
+
+              if !config.is_a?(Array)
+                # required keyword
+                locals.insert(index, kwargs.fetch(name))
+              elsif !config[1].nil?
+                # optional keyword with embedded default value
+                locals.insert(index, kwargs.fetch(name, config[1]))
+              else
+                # optional keyword with expression default value
+                locals.insert(index, nil)
+              end
+            end
+          end
+
+          iseq.local_table.size.times do |index|
+            local_set(index, 0, locals.shift)
+          end
+        end
+      end
+
+      ##########################################################################
+      # Helper methods for instructions
+      ##########################################################################
+
+      def const_base
+        frame.nesting.last
+      end
+
+      def frame_at(level)
+        current = frame
+        level.times { current = current.parent }
+        current
+      end
+
+      def frame_svar
+        current = frame
+        current = current.parent while current.is_a?(BlockFrame)
+        current
+      end
+
+      def frame_yield
+        current = frame
+        current = current.parent until current.is_a?(MethodFrame)
+        current
+      end
+
+      def frozen_core
+        FROZEN_CORE
+      end
+
+      def jump(label)
+        Jump.new(label.name)
+      end
+
+      def leave
+        Leave.new(pop)
+      end
+
+      def local_get(index, level)
+        stack[frame_at(level).stack_index + index]
+      end
+
+      def local_set(index, level, value)
+        stack[frame_at(level).stack_index + index] = value
+      end
+    end
+
+    # Compile the given source into a YARV instruction sequence.
+    def self.compile(source, options = Compiler::Options.new)
+      SyntaxTree.parse(source).accept(Compiler.new(options))
+    end
+
+    # Compile and interpret the given source.
+    def self.interpret(source, options = Compiler::Options.new)
+      iseq = RubyVM::InstructionSequence.compile(source, **options)
+      iseq = InstructionSequence.from(iseq.to_a)
+      VM.new.run_top_frame(iseq)
+    end
+  end
+end

data/lib/syntax_tree.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "etc"
+require "fiddle"
 require "json"
 require "pp"
 require "prettier_print"
@@ -9,6 +10,7 @@ require "stringio"
 
 require_relative "syntax_tree/formatter"
 require_relative "syntax_tree/node"
+require_relative "syntax_tree/dsl"
 require_relative "syntax_tree/version"
 
 require_relative "syntax_tree/basic_visitor"
@@ -25,6 +27,17 @@ require_relative "syntax_tree/parser"
 require_relative "syntax_tree/pattern"
 require_relative "syntax_tree/search"
 
+require_relative "syntax_tree/yarv"
+require_relative "syntax_tree/yarv/bf"
+require_relative "syntax_tree/yarv/compiler"
+require_relative "syntax_tree/yarv/decompiler"
+require_relative "syntax_tree/yarv/disassembler"
+require_relative "syntax_tree/yarv/instruction_sequence"
+require_relative "syntax_tree/yarv/instructions"
+require_relative "syntax_tree/yarv/legacy"
+require_relative "syntax_tree/yarv/local_table"
+require_relative "syntax_tree/yarv/assembler"
+
 # Syntax Tree is a suite of tools built on top of the internal CRuby parser. It
 # provides the ability to generate a syntax tree from source, as well as the
 # tools necessary to inspect and manipulate that syntax tree. It can be used to
@@ -40,6 +53,14 @@ module SyntaxTree
   # optional second argument to ::format.
   DEFAULT_PRINT_WIDTH = 80
 
+  # This is the default ruby version that we're going to target for formatting.
+  # It shouldn't really be changed except in very niche circumstances.
+  DEFAULT_RUBY_VERSION = Formatter::SemanticVersion.new(RUBY_VERSION).freeze
+
+  # The default indentation level for formatting. We allow changing this so
+  # that Syntax Tree can format arbitrary parts of a document.
+  DEFAULT_INDENTATION = 0
+
   # This is a hook provided so that plugins can register themselves as the
   # handler for a particular file type.
   def self.register_handler(extension, handler)
@@ -57,12 +78,13 @@ module SyntaxTree
   def self.format(
     source,
     maxwidth = DEFAULT_PRINT_WIDTH,
+    base_indentation = DEFAULT_INDENTATION,
     options: Formatter::Options.new
   )
     formatter = Formatter.new(source, [], maxwidth, options: options)
     parse(source).format(formatter)
 
-    formatter.flush
+    formatter.flush(base_indentation)
     formatter.output.join
   end
 

data/syntax_tree.gemspec

@@ -25,7 +25,7 @@ Gem::Specification.new do |spec|
   spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = %w[lib]
 
-  spec.add_dependency "prettier_print", ">= 1.1.0"
+  spec.add_dependency "prettier_print", ">= 1.2.0"
 
   spec.add_development_dependency "bundler"
   spec.add_development_dependency "minitest"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: syntax_tree
 version: !ruby/object:Gem::Version
-  version: 5.0.0
+  version: 5.1.0
 platform: ruby
 authors:
 - Kevin Newton
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-11-09 00:00:00.000000000 Z
+date: 2022-12-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: prettier_print
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.1.0
+        version: 1.2.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.1.0
+        version: 1.2.0
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -125,6 +125,7 @@ files:
 - lib/syntax_tree.rb
 - lib/syntax_tree/basic_visitor.rb
 - lib/syntax_tree/cli.rb
+- lib/syntax_tree/dsl.rb
 - lib/syntax_tree/formatter.rb
 - lib/syntax_tree/language_server.rb
 - lib/syntax_tree/language_server/inlay_hints.rb
@@ -147,6 +148,16 @@ files:
 - lib/syntax_tree/visitor/mutation_visitor.rb
 - lib/syntax_tree/visitor/pretty_print_visitor.rb
 - lib/syntax_tree/visitor/with_environment.rb
+- lib/syntax_tree/yarv.rb
+- lib/syntax_tree/yarv/assembler.rb
+- lib/syntax_tree/yarv/bf.rb
+- lib/syntax_tree/yarv/compiler.rb
+- lib/syntax_tree/yarv/decompiler.rb
+- lib/syntax_tree/yarv/disassembler.rb
+- lib/syntax_tree/yarv/instruction_sequence.rb
+- lib/syntax_tree/yarv/instructions.rb
+- lib/syntax_tree/yarv/legacy.rb
+- lib/syntax_tree/yarv/local_table.rb
 - syntax_tree.gemspec
 homepage: https://github.com/kddnewton/syntax_tree
 licenses: