mutant-melbourne 2.0.1

data/lib/compiler/ast/transforms.rb

@@ -0,0 +1,298 @@
+# -*- encoding: us-ascii -*-
+
+module Rubinius
+  module AST
+    module Transforms
+      def self.register(category, name, klass)
+        transform_map[name] = klass
+        category_map[category] << klass
+      end
+
+      def self.transform_map
+        @transform_map ||= { }
+      end
+
+      def self.category_map
+        @category_map ||= Hash.new { |h, k| h[k] = [] }
+      end
+
+      def self.[](name)
+        transform_map[name]
+      end
+
+      def self.category(name)
+        if name == :all
+          category_map.values.flatten
+        else
+          category_map[name]
+        end
+      end
+    end
+
+    ##
+    # Handles block_given?
+    class BlockGiven < Send
+      transform :default, :block_given, "VM instruction for block_given?, iterator?"
+
+      def self.match?(line, receiver, name, arguments, privately)
+        if receiver.kind_of? Self and (name == :block_given? or name == :iterator?)
+          new line, receiver, name, privately
+        end
+      end
+    end
+
+    class AccessUndefined < Send
+      transform :kernel, :access_undefined, "VM instruction for undefined"
+
+      def self.match?(line, receiver, name, arguments, privately)
+        if privately and name == :undefined
+          new line, receiver, name, privately
+        end
+      end
+    end
+
+    ##
+    # Handles Rubinius.primitive
+    class SendPrimitive < SendWithArguments
+      transform :default, :primitive, "Rubinius.primitive"
+
+      def self.match?(line, receiver, name, arguments, privately)
+        match_send? receiver, :Rubinius, name, :primitive
+      end
+    end
+
+    ##
+    # Handles Rubinius.check_frozen
+    class CheckFrozen < SendWithArguments
+      transform :default, :frozen, "Rubinius.check_frozen"
+
+      def self.match?(line, receiver, name, arguments, privately)
+        match_send? receiver, :Rubinius, name, :check_frozen
+      end
+    end
+
+    ##
+    # Handles Rubinius.invoke_primitive
+    #
+    class InvokePrimitive < SendWithArguments
+      transform :default, :invoke_primitive, "Rubinius.invoke_primitive"
+
+      def self.match?(line, receiver, name, arguments, privately)
+        match_send? receiver, :Rubinius, name, :invoke_primitive
+      end
+    end
+
+    ##
+    # Handles Rubinius.call_custom
+    #
+    class CallCustom < SendWithArguments
+      transform :default, :call_custom, "Rubinius.call_custom"
+
+      def self.match?(line, receiver, name, arguments, privately)
+        match_send? receiver, :Rubinius, name, :call_custom
+      end
+    end
+
+    ##
+    # Handles Rubinius.single_block_arg
+    #
+    # Given the following code:
+    #
+    #   m { |x| ... }
+    #
+    # In Ruby 1.8, this has the following semantics:
+    #
+    #   * x == nil if no values are yielded
+    #   * x == val if one value is yielded
+    #   * x == [p, q, r, ...] if more than one value is yielded
+    #   * x == [a, b, c, ...] if one Array is yielded
+    #
+    # In Ruby 1.9, this has the following semantics:
+    #
+    #   * x == nil if no values are yielded
+    #   * x == val if one value is yielded
+    #   * x == p if yield(p, q, r, ...)
+    #   * x == [a, b, c, ...] if one Array is yielded
+    #
+    # However, in Ruby 1.9, the Enumerator code manually implements the 1.8
+    # block argument semantics. This transform exposes the VM instruction we
+    # use in 1.8 mode (cast_for_single_block_arg) so we can use it in 1.9 mode
+    # for Enumerator.
+    #
+    class SingleBlockArg < SendWithArguments
+      transform :default, :single_block_arg, "Rubinius.single_block_arg"
+
+      def self.match?(line, receiver, name, arguments, privately)
+        match_send? receiver, :Rubinius, name, :single_block_arg
+      end
+    end
+
+    ##
+    # Handles Rubinius.asm
+    #
+    class InlineAssembly < SendWithArguments
+      transform :default, :assembly, "Rubinius.asm"
+
+      def self.match?(line, receiver, name, arguments, privately)
+        match_send? receiver, :Rubinius, name, :asm
+      end
+    end
+
+    ##
+    # Handles Rubinius.privately
+    #
+    class SendPrivately < Send
+      transform :kernel, :privately, "Rubinius.privately"
+
+      def self.match?(line, receiver, name, arguments, privately)
+        if match_send? receiver, :Rubinius, name, :privately
+          new line, receiver, name, privately
+        end
+      end
+
+      def block=(iter)
+        @block = iter.body
+      end
+
+      def map_sends
+        walk do |result, node|
+          case node
+          when Send, SendWithArguments
+            node.privately = true
+          end
+
+          result
+        end
+      end
+    end
+
+    ##
+    # Emits fast VM instructions for certain methods.
+    #
+    class SendFastMath < SendWithArguments
+      transform :default, :fast_math, "VM instructions for math, relational methods"
+
+      Operators = {
+        :+    => :meta_send_op_plus,
+        :-    => :meta_send_op_minus,
+        :==   => :meta_send_op_equal,
+        :===  => :meta_send_op_tequal,
+        :<    => :meta_send_op_lt,
+        :>    => :meta_send_op_gt
+      }
+
+      def self.match?(line, receiver, name, arguments, privately)
+        return false unless op = Operators[name]
+        if match_arguments? arguments, 1
+          node = new line, receiver, name, arguments
+          node.operator = op
+          node
+        end
+      end
+
+      attr_accessor :operator
+    end
+
+    ##
+    # Emits a fast path for #new
+    #
+    class SendFastNew < SendWithArguments
+      transform :default, :fast_new, "Fast SomeClass.new path"
+
+      # FIXME duplicated from kernel/common/compiled_code.rb
+      KernelMethodSerial = 47
+
+      def self.match?(line, receiver, name, arguments, privately)
+        # ignore vcall style
+        return false if !arguments and privately
+        name == :new
+      end
+    end
+
+    ##
+    # Emits "safe" names for certain fundamental core library methods
+    #
+    class SendKernelMethod < SendWithArguments
+      transform :kernel, :kernel_methods, "Safe names for fundamental methods"
+
+      Methods = {
+        :/      => :divide,
+        :__slash__ => :/,
+        :class  => :__class__
+      }
+
+      Arguments = {
+        :/      => 1,
+        :__slash__ => 1,
+        :class  => 0
+      }
+
+      def self.match?(line, receiver, name, arguments, privately)
+        return false unless rename = Methods[name]
+        if match_arguments? arguments, Arguments[name]
+          new line, receiver, rename, arguments, privately
+        end
+      end
+    end
+
+    ##
+    # Maps various methods to VM instructions
+    #
+    class SendInstructionMethod < SendWithArguments
+      transform :default, :fast_system, "VM instructions for certain methods"
+
+      Methods = {
+        :__kind_of__     => :kind_of,
+        :__instance_of__ => :instance_of,
+        :__nil__         => :is_nil,
+      }
+
+      Arguments = {
+        :__kind_of__     => 1,
+        :__instance_of__ => 1,
+        :__nil__         => 0,
+      }
+
+      def self.match?(line, receiver, name, arguments, privately)
+        return false unless rename = Methods[name]
+        if match_arguments? arguments, Arguments[name]
+          new line, receiver, rename, arguments, privately
+        end
+      end
+    end
+
+    ##
+    # Speeds up certain forms of Type.coerce_to
+    #
+    class SendFastCoerceTo < SendWithArguments
+      transform :default, :fast_coerce, "Fast Rubinius::Type.coerce_to path"
+
+      def self.match?(line, receiver, name, arguments, privately)
+        methods = [:coerce_to, :check_convert_type, :try_convert]
+        receiver.kind_of?(TypeConstant) && methods.include?(name) &&
+          arguments.body.size == 3
+      end
+    end
+
+    ##
+    # Handles loop do ... end
+    #
+    class SendLoop < Send
+      transform :magic, :loop, "loop do ... end"
+
+      def self.match?(line, receiver, name, arguments, privately)
+        if receiver.kind_of? Self and name == :loop
+          new line, receiver, name, privately
+        end
+      end
+
+      def block=(iter)
+        if iter.kind_of? BlockPass
+          @blockarg = iter
+        else
+          @block = iter.body
+        end
+      end
+    end
+  end
+end

data/lib/compiler/ast/values.rb

@@ -0,0 +1,88 @@
+# -*- encoding: us-ascii -*-
+
+module Rubinius
+  module AST
+    class SplatValue < Node
+      attr_accessor :value
+
+      def initialize(line, value)
+        @line = line
+        @value = value
+      end
+
+      def to_sexp
+        [:splat, @value.to_sexp]
+      end
+    end
+
+    class ConcatArgs < Node
+      attr_accessor :array, :rest
+
+      def initialize(line, array, rest)
+        @line = line
+        @array = array
+        @rest = rest
+      end
+
+      def to_sexp
+        [:argscat, @array.to_sexp, @rest.to_sexp]
+      end
+    end
+
+    class PushArgs < Node
+      attr_accessor :arguments, :value
+
+      def initialize(line, arguments, value)
+        @line = line
+        @arguments = arguments
+        @value = value
+      end
+
+      def to_sexp
+        [:argspush, @arguments.to_sexp, @value.to_sexp]
+      end
+    end
+
+
+    class SValue < Node
+      attr_accessor :value
+
+      def initialize(line, value)
+        @line = line
+        @value = value
+      end
+
+      def to_sexp
+        [:svalue, @value.to_sexp]
+      end
+    end
+
+    class ToArray < Node
+      attr_accessor :value
+
+      def initialize(line, value)
+        @line = line
+        @value = value
+      end
+
+      def to_sexp
+        [:to_ary, @value.to_sexp]
+      end
+    end
+
+    class ToString < Node
+      attr_accessor :value
+
+      def initialize(line, value)
+        @line = line
+        @value = value
+      end
+
+      def to_sexp
+        sexp = [:evstr]
+        sexp << @value.to_sexp if @value
+        sexp
+      end
+    end
+  end
+end

data/lib/compiler/ast/variables.rb

@@ -0,0 +1,351 @@
+# -*- encoding: us-ascii -*-
+
+module Rubinius
+  module AST
+    class BackRef < Node
+      attr_accessor :kind
+
+      def initialize(line, ref)
+        @line = line
+        @kind = ref
+      end
+
+      Kinds = {
+        :~ => 0,
+        :& => 1,
+        :"`" => 2,
+        :"'" => 3,
+        :+ => 4
+      }
+
+      def mode
+        unless mode = Kinds[@kind]
+          raise "Unknown backref: #{@kind}"
+        end
+
+        mode
+      end
+
+      def to_sexp
+        [:back_ref, @kind]
+      end
+    end
+
+    class NthRef < Node
+      attr_accessor :which
+
+      def initialize(line, ref)
+        @line = line
+        @which = ref
+      end
+
+      Mode = 5
+
+      def to_sexp
+        [:nth_ref, @which]
+      end
+    end
+
+    class VariableAccess < Node
+      attr_accessor :name
+
+      def initialize(line, name)
+        @line = line
+        @name = name
+      end
+    end
+
+    class VariableAssignment < Node
+      attr_accessor :name, :value
+
+      def initialize(line, name, value)
+        @line = line
+        @name = name
+        @value = value
+      end
+
+      def defined(g)
+        g.push_literal "assignment"
+      end
+
+      def to_sexp
+        sexp = [sexp_name, @name]
+        sexp << @value.to_sexp if @value
+        sexp
+      end
+    end
+
+    class ClassVariableAccess < VariableAccess
+      def to_sexp
+        [:cvar, @name]
+      end
+    end
+
+    class ClassVariableAssignment < VariableAssignment
+      def sexp_name
+        :cvasgn
+      end
+    end
+
+    class ClassVariableDeclaration < ClassVariableAssignment
+      def sexp_name
+        :cvdecl
+      end
+    end
+
+    class CurrentException < Node
+      def to_sexp
+        [:gvar, :$!]
+      end
+    end
+
+    class GlobalVariableAccess < VariableAccess
+      EnglishBackrefs = {
+        :$LAST_MATCH_INFO => :~,
+        :$MATCH => :&,
+        :$PREMATCH => :'`',
+        :$POSTMATCH => :"'",
+        :$LAST_PAREN_MATCH => :+,
+      }
+
+      def self.for_name(line, name)
+        case name
+        when :$!
+          CurrentException.new(line)
+        when :$~
+          BackRef.new(line, :~)
+        else
+          if backref = EnglishBackrefs[name]
+            BackRef.new(line, backref)
+          else
+            new(line, name)
+          end
+        end
+      end
+
+      def to_sexp
+        [:gvar, @name]
+      end
+    end
+
+    class GlobalVariableAssignment < VariableAssignment
+      def sexp_name
+        :gasgn
+      end
+    end
+
+    class SplatAssignment < Node
+      attr_accessor :value
+
+      def initialize(line, value)
+        @line = line
+        @value = value
+      end
+
+      def to_sexp
+        [:splat_assign, @value.to_sexp]
+      end
+    end
+
+    class SplatArray < SplatAssignment
+      def initialize(line, value, size)
+        @line = line
+        @value = value
+        @size = size
+      end
+
+      def to_sexp
+        [:splat, @value.to_sexp]
+      end
+    end
+
+    class SplatWrapped < SplatAssignment
+      def to_sexp
+        [:splat, @value.to_sexp]
+      end
+    end
+
+    class EmptySplat < Node
+      def initialize(line, size)
+        @line = line
+        @size = size
+      end
+
+      def to_sexp
+        [:splat]
+      end
+    end
+
+    class InstanceVariableAccess < VariableAccess
+      def to_sexp
+        [:ivar, @name]
+      end
+    end
+
+    class InstanceVariableAssignment < VariableAssignment
+      def sexp_name
+        :iasgn
+      end
+    end
+
+    class LocalVariableAccess < VariableAccess
+      include LocalVariable
+
+      def initialize(line, name)
+        @line = line
+        @name = name
+        @variable = nil
+      end
+
+      def to_sexp
+        [:lvar, @name]
+      end
+    end
+
+    class LocalVariableAssignment < VariableAssignment
+      include LocalVariable
+
+      def initialize(line, name, value)
+        @line = line
+        @name = name
+        @value = value
+        @variable = nil
+      end
+
+      def sexp_name
+        :lasgn
+      end
+    end
+
+    class PostArg < Node
+      attr_accessor :into, :rest
+
+      def initialize(line, into, rest)
+        @line = line
+        @into = into
+        @rest = rest
+      end
+    end
+
+    class MultipleAssignment < Node
+      attr_accessor :left, :right, :splat, :block
+
+      def initialize(line, left, right, splat)
+        @line = line
+        @left = left
+        @right = right
+        @splat = nil
+        @block = nil # support for |&b|
+        @post = nil # in `a,*b,c`, c is in post.
+
+        if Rubinius.ruby18?
+          @fixed = right.kind_of?(ArrayLiteral) ? true : false
+        elsif splat.kind_of?(PostArg)
+          @fixed = false
+          @post = splat.rest
+          splat = splat.into
+        elsif right.kind_of?(ArrayLiteral)
+          @fixed = right.body.size > 1
+        else
+          @fixed = false
+        end
+
+        if splat.kind_of? Node
+          if @left
+            if right
+              @splat = SplatAssignment.new line, splat
+            else
+              @splat = SplatWrapped.new line, splat
+            end
+          elsif @fixed
+            @splat = SplatArray.new line, splat, right.body.size
+          elsif right.kind_of? SplatValue
+            @splat = splat
+          else
+            @splat = SplatWrapped.new line, splat
+          end
+        elsif splat
+          # We need a node for eg { |*| } and { |a, *| }
+          size = @fixed ? right.body.size : 0
+          @splat = EmptySplat.new line, size
+        end
+      end
+
+      def pad_short(g)
+        short = @left.body.size - @right.body.size
+        if short > 0
+          short.times { g.push :nil }
+          g.make_array 0 if @splat
+        end
+      end
+
+      def pop_excess(g)
+        excess = @right.body.size - @left.body.size
+        excess.times { g.pop } if excess > 0
+      end
+
+      def make_array(g)
+        size = @right.body.size - @left.body.size
+        g.make_array size if size >= 0
+      end
+
+      def rotate(g)
+        if @splat
+          size = @left.body.size + 1
+        else
+          size = @right.body.size
+        end
+        g.rotate size
+      end
+
+      def iter_arguments
+        @iter_arguments = true
+      end
+
+      def declare_local_scope(scope)
+        # Fix the scope for locals introduced by the left. We
+        # do this before running the code for the right so that
+        # right side sees the proper scoping of the locals on the left.
+
+        if @left
+          @left.body.each do |var|
+            case var
+            when LocalVariable
+              scope.assign_local_reference var
+            when MultipleAssignment
+              var.declare_local_scope(scope)
+            end
+          end
+        end
+
+        if @splat and @splat.kind_of?(SplatAssignment)
+          if @splat.value.kind_of?(LocalVariable)
+            scope.assign_local_reference @splat.value
+          end
+        end
+      end
+
+      def to_sexp
+        left = @left ? @left.to_sexp : [:array]
+        left << [:splat, @splat.to_sexp] if @splat
+        left << @block.to_sexp if @block
+
+        sexp = [:masgn, left]
+        sexp << @right.to_sexp if @right
+        sexp
+      end
+    end
+
+    class PatternVariable < Node
+      include LocalVariable
+
+      attr_accessor :name, :value
+
+      def initialize(line, name)
+        @line = line
+        @name = name
+        @variable = nil
+      end
+    end
+  end
+end