syntax_tree 5.1.0 → 5.3.0

data/lib/syntax_tree/yarv/compiler.rb

@@ -285,7 +285,7 @@ module SyntaxTree
       # if we need to return the value of the last statement.
       attr_reader :last_statement
 
-      def initialize(options)
+      def initialize(options = Options.new)
         @options = options
         @iseq = nil
         @last_statement = false
@@ -304,10 +304,11 @@ module SyntaxTree
       end
 
       def visit_END(node)
+        start_line = node.location.start_line
         once_iseq =
-          with_child_iseq(iseq.block_child_iseq(node.location)) do
+          with_child_iseq(iseq.block_child_iseq(start_line)) do
             postexe_iseq =
-              with_child_iseq(iseq.block_child_iseq(node.location)) do
+              with_child_iseq(iseq.block_child_iseq(start_line)) do
                 iseq.event(:RUBY_EVENT_B_CALL)
 
                 *statements, last_statement = node.statements.body
@@ -567,7 +568,7 @@ module SyntaxTree
       end
 
       def visit_block(node)
-        with_child_iseq(iseq.block_child_iseq(node.location)) do
+        with_child_iseq(iseq.block_child_iseq(node.location.start_line)) do
           iseq.event(:RUBY_EVENT_B_CALL)
           visit(node.block_var)
           visit(node.bodystmt)
@@ -751,7 +752,9 @@ module SyntaxTree
       def visit_class(node)
         name = node.constant.constant.value.to_sym
         class_iseq =
-          with_child_iseq(iseq.class_child_iseq(name, node.location)) do
+          with_child_iseq(
+            iseq.class_child_iseq(name, node.location.start_line)
+          ) do
             iseq.event(:RUBY_EVENT_CLASS)
             visit(node.bodystmt)
             iseq.event(:RUBY_EVENT_END)
@@ -818,7 +821,8 @@ module SyntaxTree
 
       def visit_def(node)
         name = node.name.value.to_sym
-        method_iseq = iseq.method_child_iseq(name.to_s, node.location)
+        method_iseq =
+          iseq.method_child_iseq(name.to_s, node.location.start_line)
 
         with_child_iseq(method_iseq) do
           visit(node.params) if node.params
@@ -939,7 +943,9 @@ module SyntaxTree
         iseq.local_table.plain(name)
 
         block_iseq =
-          with_child_iseq(iseq.block_child_iseq(node.statements.location)) do
+          with_child_iseq(
+            iseq.block_child_iseq(node.statements.location.start_line)
+          ) do
             iseq.argument_options[:lead_num] ||= 0
             iseq.argument_options[:lead_num] += 1
             iseq.argument_options[:ambiguous_param0] = true
@@ -1076,7 +1082,7 @@ module SyntaxTree
 
       def visit_lambda(node)
         lambda_iseq =
-          with_child_iseq(iseq.block_child_iseq(node.location)) do
+          with_child_iseq(iseq.block_child_iseq(node.location.start_line)) do
             iseq.event(:RUBY_EVENT_B_CALL)
             visit(node.params)
             visit(node.statements)
@@ -1127,7 +1133,9 @@ module SyntaxTree
       def visit_module(node)
         name = node.constant.constant.value.to_sym
         module_iseq =
-          with_child_iseq(iseq.module_child_iseq(name, node.location)) do
+          with_child_iseq(
+            iseq.module_child_iseq(name, node.location.start_line)
+          ) do
             iseq.event(:RUBY_EVENT_CLASS)
             visit(node.bodystmt)
             iseq.event(:RUBY_EVENT_END)
@@ -1375,10 +1383,11 @@ module SyntaxTree
 
         top_iseq =
           InstructionSequence.new(
-            :top,
             "<compiled>",
+            "<compiled>",
+            1,
+            :top,
             nil,
-            node.location,
             options
           )
 
@@ -1543,7 +1552,9 @@ module SyntaxTree
         iseq.putnil
 
         singleton_iseq =
-          with_child_iseq(iseq.singleton_class_child_iseq(node.location)) do
+          with_child_iseq(
+            iseq.singleton_class_child_iseq(node.location.start_line)
+          ) do
             iseq.event(:RUBY_EVENT_CLASS)
             visit(node.bodystmt)
             iseq.event(:RUBY_EVENT_END)
@@ -2018,7 +2029,7 @@ module SyntaxTree
           if node.constant
             iseq.dup
             visit(node.constant)
-            iseq.checkmatch(CheckMatch::TYPE_CASE)
+            iseq.checkmatch(CheckMatch::VM_CHECKMATCH_TYPE_CASE)
             iseq.branchunless(match_failure_label)
           end
 
@@ -2078,7 +2089,7 @@ module SyntaxTree
               iseq.setlocal(lookup.index, lookup.level)
             else
               visit(required)
-              iseq.checkmatch(CheckMatch::TYPE_CASE)
+              iseq.checkmatch(CheckMatch::VM_CHECKMATCH_TYPE_CASE)
               iseq.branchunless(match_failure_label)
             end
 

data/lib/syntax_tree/yarv/decompiler.rb

@@ -64,6 +64,13 @@ module SyntaxTree
             clauses[label] = clause
             clause = []
             label = insn.name
+          when BranchIf
+            body = [
+              Assign(block_label.field, node_for(insn.label.name)),
+              Next(Args([]))
+            ]
+
+            clause << UnlessNode(clause.pop, Statements(body), nil)
           when BranchUnless
             body = [
               Assign(block_label.field, node_for(insn.label.name)),
@@ -90,7 +97,7 @@ module SyntaxTree
             clause << Next(Args([]))
           when Leave
             value = Args([clause.pop])
-            clause << (iseq.type == :top ? Break(value) : ReturnNode(value))
+            clause << (iseq.type != :top ? Break(value) : ReturnNode(value))
           when OptAnd, OptDiv, OptEq, OptGE, OptGT, OptLE, OptLT, OptLTLT,
                OptMinus, OptMod, OptMult, OptOr, OptPlus
             left, right = clause.pop(2)
@@ -157,6 +164,8 @@ module SyntaxTree
                 )
               end
             end
+          when Pop
+            # skip
           when PutObject
             case insn.object
             when Float

data/lib/syntax_tree/yarv/disassembler.rb

@@ -4,7 +4,8 @@ module SyntaxTree
   module YARV
     class Disassembler
       attr_reader :output, :queue
-      attr_reader :current_prefix, :current_iseq
+      attr_reader :current_prefix
+      attr_accessor :current_iseq
 
       def initialize
         @output = StringIO.new
@@ -114,7 +115,7 @@ module SyntaxTree
         output << "#{current_prefix}== disasm: "
         output << "#<ISeq:#{iseq.name}@<compiled>:1 "
 
-        location = iseq.location
+        location = Location.fixed(line: iseq.line, char: 0, column: 0)
         output << "(#{location.start_line},#{location.start_column})-"
         output << "(#{location.end_line},#{location.end_column})"
         output << "> "

data/lib/syntax_tree/yarv/instruction_sequence.rb

@@ -70,7 +70,7 @@ module SyntaxTree
             [Fiddle::TYPE_VOIDP] * 3,
             Fiddle::TYPE_VOIDP
           )
-        rescue NameError
+        rescue NameError, Fiddle::DLError
         end
 
       # This object is used to track the size of the stack at any given time. It
@@ -116,18 +116,18 @@ module SyntaxTree
         end
       end
 
-      # The type of the instruction sequence.
-      attr_reader :type
-
       # The name of the instruction sequence.
       attr_reader :name
 
+      # The source location of the instruction sequence.
+      attr_reader :file, :line
+
+      # The type of the instruction sequence.
+      attr_reader :type
+
       # The parent instruction sequence, if there is one.
       attr_reader :parent_iseq
 
-      # The location of the root node of this instruction sequence.
-      attr_reader :location
-
       # This is the list of information about the arguments to this
       # instruction sequence.
       attr_accessor :argument_size
@@ -157,16 +157,18 @@ module SyntaxTree
       attr_reader :options
 
       def initialize(
-        type,
         name,
-        parent_iseq,
-        location,
+        file,
+        line,
+        type,
+        parent_iseq = nil,
         options = Compiler::Options.new
       )
-        @type = type
         @name = name
+        @file = file
+        @line = line
+        @type = type
         @parent_iseq = parent_iseq
-        @location = location
 
         @argument_size = 0
         @argument_options = {}
@@ -256,9 +258,9 @@ module SyntaxTree
             node_ids: [-1] * insns.length
           },
           name,
+          file,
           "<compiled>",
-          "<compiled>",
-          location.start_line,
+          line,
           type,
           local_table.names,
           dumped_options,
@@ -278,6 +280,12 @@ module SyntaxTree
       def compile!
         specialize_instructions! if options.specialized_instruction?
 
+        catch_table.each do |catch_entry|
+          if !catch_entry.is_a?(CatchBreak) && catch_entry.iseq
+            catch_entry.iseq.compile!
+          end
+        end
+
         length = 0
         insns.each do |insn|
           case insn
@@ -416,30 +424,30 @@ module SyntaxTree
       # Child instruction sequence methods
       ##########################################################################
 
-      def child_iseq(type, name, location)
-        InstructionSequence.new(type, name, self, location, options)
+      def child_iseq(name, line, type)
+        InstructionSequence.new(name, file, line, type, self, options)
       end
 
-      def block_child_iseq(location)
+      def block_child_iseq(line)
         current = self
         current = current.parent_iseq while current.type == :block
-        child_iseq(:block, "block in #{current.name}", location)
+        child_iseq("block in #{current.name}", line, :block)
       end
 
-      def class_child_iseq(name, location)
-        child_iseq(:class, "<class:#{name}>", location)
+      def class_child_iseq(name, line)
+        child_iseq("<class:#{name}>", line, :class)
       end
 
-      def method_child_iseq(name, location)
-        child_iseq(:method, name, location)
+      def method_child_iseq(name, line)
+        child_iseq(name, line, :method)
       end
 
-      def module_child_iseq(name, location)
-        child_iseq(:class, "<module:#{name}>", location)
+      def module_child_iseq(name, line)
+        child_iseq("<module:#{name}>", line, :class)
       end
 
-      def singleton_class_child_iseq(location)
-        child_iseq(:class, "singleton class", location)
+      def singleton_class_child_iseq(line)
+        child_iseq("singleton class", line, :class)
       end
 
       ##########################################################################
@@ -447,19 +455,39 @@ module SyntaxTree
       ##########################################################################
 
       class CatchEntry
-        attr_reader :iseq, :begin_label, :end_label, :exit_label
+        attr_reader :iseq, :begin_label, :end_label, :exit_label, :restore_sp
 
-        def initialize(iseq, begin_label, end_label, exit_label)
+        def initialize(iseq, begin_label, end_label, exit_label, restore_sp)
           @iseq = iseq
           @begin_label = begin_label
           @end_label = end_label
           @exit_label = exit_label
+          @restore_sp = restore_sp
         end
       end
 
       class CatchBreak < CatchEntry
         def to_a
-          [:break, iseq.to_a, begin_label.name, end_label.name, exit_label.name]
+          [
+            :break,
+            iseq.to_a,
+            begin_label.name,
+            end_label.name,
+            exit_label.name,
+            restore_sp
+          ]
+        end
+      end
+
+      class CatchEnsure < CatchEntry
+        def to_a
+          [
+            :ensure,
+            iseq.to_a,
+            begin_label.name,
+            end_label.name,
+            exit_label.name
+          ]
         end
       end
 
@@ -493,24 +521,64 @@ module SyntaxTree
         end
       end
 
-      def catch_break(iseq, begin_label, end_label, exit_label)
-        catch_table << CatchBreak.new(iseq, begin_label, end_label, exit_label)
-      end
-
-      def catch_next(begin_label, end_label, exit_label)
-        catch_table << CatchNext.new(nil, begin_label, end_label, exit_label)
-      end
-
-      def catch_redo(begin_label, end_label, exit_label)
-        catch_table << CatchRedo.new(nil, begin_label, end_label, exit_label)
-      end
-
-      def catch_rescue(iseq, begin_label, end_label, exit_label)
-        catch_table << CatchRescue.new(iseq, begin_label, end_label, exit_label)
-      end
-
-      def catch_retry(begin_label, end_label, exit_label)
-        catch_table << CatchRetry.new(nil, begin_label, end_label, exit_label)
+      def catch_break(iseq, begin_label, end_label, exit_label, restore_sp)
+        catch_table << CatchBreak.new(
+          iseq,
+          begin_label,
+          end_label,
+          exit_label,
+          restore_sp
+        )
+      end
+
+      def catch_ensure(iseq, begin_label, end_label, exit_label, restore_sp)
+        catch_table << CatchEnsure.new(
+          iseq,
+          begin_label,
+          end_label,
+          exit_label,
+          restore_sp
+        )
+      end
+
+      def catch_next(begin_label, end_label, exit_label, restore_sp)
+        catch_table << CatchNext.new(
+          nil,
+          begin_label,
+          end_label,
+          exit_label,
+          restore_sp
+        )
+      end
+
+      def catch_redo(begin_label, end_label, exit_label, restore_sp)
+        catch_table << CatchRedo.new(
+          nil,
+          begin_label,
+          end_label,
+          exit_label,
+          restore_sp
+        )
+      end
+
+      def catch_rescue(iseq, begin_label, end_label, exit_label, restore_sp)
+        catch_table << CatchRescue.new(
+          iseq,
+          begin_label,
+          end_label,
+          exit_label,
+          restore_sp
+        )
+      end
+
+      def catch_retry(begin_label, end_label, exit_label, restore_sp)
+        catch_table << CatchRetry.new(
+          nil,
+          begin_label,
+          end_label,
+          exit_label,
+          restore_sp
+        )
       end
 
       ##########################################################################
@@ -895,7 +963,8 @@ module SyntaxTree
       # This method will create a new instruction sequence from a serialized
       # RubyVM::InstructionSequence object.
       def self.from(source, options = Compiler::Options.new, parent_iseq = nil)
-        iseq = new(source[9], source[5], parent_iseq, Location.default, options)
+        iseq =
+          new(source[5], source[6], source[8], source[9], parent_iseq, options)
 
         # set up the labels object so that the labels are shared between the
         # location in the instruction sequence and the instructions that
@@ -914,45 +983,9 @@ module SyntaxTree
           iseq.argument_options[:opt].map! { |opt| labels[opt] }
         end
 
-        # set up the catch table
-        source[12].each do |entry|
-          case entry[0]
-          when :break
-            iseq.catch_break(
-              from(entry[1]),
-              labels[entry[2]],
-              labels[entry[3]],
-              labels[entry[4]]
-            )
-          when :next
-            iseq.catch_next(
-              labels[entry[2]],
-              labels[entry[3]],
-              labels[entry[4]]
-            )
-          when :rescue
-            iseq.catch_rescue(
-              from(entry[1]),
-              labels[entry[2]],
-              labels[entry[3]],
-              labels[entry[4]]
-            )
-          when :redo
-            iseq.catch_redo(
-              labels[entry[2]],
-              labels[entry[3]],
-              labels[entry[4]]
-            )
-          when :retry
-            iseq.catch_retry(
-              labels[entry[2]],
-              labels[entry[3]],
-              labels[entry[4]]
-            )
-          else
-            raise "unknown catch type: #{entry[0]}"
-          end
-        end
+        # track the child block iseqs so that our catch table can point to the
+        # correctly created iseqs
+        block_iseqs = []
 
         # set up all of the instructions
         source[13].each do |insn|
@@ -1135,6 +1168,7 @@ module SyntaxTree
             iseq.putspecialobject(opnds[0])
           when :send
             block_iseq = opnds[1] ? from(opnds[1], options, iseq) : nil
+            block_iseqs << block_iseq if block_iseq
             iseq.send(CallData.from(opnds[0]), block_iseq)
           when :setclassvariable
             iseq.push(SetClassVariable.new(opnds[0], opnds[1]))
@@ -1163,6 +1197,76 @@ module SyntaxTree
           end
         end
 
+        # set up the catch table
+        source[12].each do |entry|
+          case entry[0]
+          when :break
+            if entry[1]
+              break_iseq =
+                block_iseqs.find do |block_iseq|
+                  block_iseq.name == entry[1][5] &&
+                    block_iseq.file == entry[1][6] &&
+                    block_iseq.line == entry[1][8]
+                end
+
+              iseq.catch_break(
+                break_iseq || from(entry[1], options, iseq),
+                labels[entry[2]],
+                labels[entry[3]],
+                labels[entry[4]],
+                entry[5]
+              )
+            else
+              iseq.catch_break(
+                nil,
+                labels[entry[2]],
+                labels[entry[3]],
+                labels[entry[4]],
+                entry[5]
+              )
+            end
+          when :ensure
+            iseq.catch_ensure(
+              from(entry[1], options, iseq),
+              labels[entry[2]],
+              labels[entry[3]],
+              labels[entry[4]],
+              entry[5]
+            )
+          when :next
+            iseq.catch_next(
+              labels[entry[2]],
+              labels[entry[3]],
+              labels[entry[4]],
+              entry[5]
+            )
+          when :rescue
+            iseq.catch_rescue(
+              from(entry[1], options, iseq),
+              labels[entry[2]],
+              labels[entry[3]],
+              labels[entry[4]],
+              entry[5]
+            )
+          when :redo
+            iseq.catch_redo(
+              labels[entry[2]],
+              labels[entry[3]],
+              labels[entry[4]],
+              entry[5]
+            )
+          when :retry
+            iseq.catch_retry(
+              labels[entry[2]],
+              labels[entry[3]],
+              labels[entry[4]],
+              entry[5]
+            )
+          else
+            raise "unknown catch type: #{entry[0]}"
+          end
+        end
+
         iseq.compile! if iseq.type == :top
         iseq
       end