opal-wedge 0.9.0.dev

data/lib/opal/nodes/runtime_helpers.rb

@@ -0,0 +1,45 @@
+require 'set'
+require 'opal/nodes/base'
+
+module Opal
+  module Nodes
+    class RuntimeHelpers < Base
+      HELPERS = Set.new
+
+      children :recvr, :meth, :arglist
+
+      def self.compatible?(recvr, meth, arglist)
+        recvr == [:const, :Opal] and HELPERS.include?(meth.to_sym)
+      end
+
+      def self.helper(name, &block)
+        HELPERS << name
+        define_method("compile_#{name}", &block)
+      end
+
+      def compile
+        if HELPERS.include?(meth.to_sym)
+          __send__("compile_#{meth}")
+        else
+          raise "Helper not supported: #{meth}"
+        end
+      end
+
+      helper :truthy? do
+        unless sexp = arglist[1]
+          raise "truthy? requires an object"
+        end
+
+        js_truthy(sexp)
+      end
+
+      helper :falsy? do
+        unless sexp = arglist[1]
+          raise "falsy? requires an object"
+        end
+
+        js_falsy(sexp)
+      end
+    end
+  end
+end

data/lib/opal/nodes/scope.rb

@@ -0,0 +1,281 @@
+require 'opal/nodes/base'
+
+module Opal
+  module Nodes
+    class ScopeNode < Base
+
+      # Every scope can have a parent scope
+      attr_accessor :parent
+
+      # The class or module name if this scope is a class scope
+      attr_accessor :name
+
+      # The given block name for a def scope
+      attr_accessor :block_name
+
+      attr_reader :scope_name
+      attr_reader :ivars
+      attr_reader :gvars
+
+      attr_accessor :mid
+
+      # true if singleton def, false otherwise
+      attr_accessor :defs
+
+      # used by modules to know what methods to donate to includees
+      attr_reader :methods
+
+      # uses parents super method
+      attr_accessor :uses_super
+      attr_accessor :uses_zuper
+
+      attr_accessor :catch_return
+
+      def initialize(*)
+        super
+
+        @locals   = []
+        @temps    = []
+        @args     = []
+        @ivars    = []
+        @gvars    = []
+        @parent   = nil
+        @queue    = []
+        @unique   = 'a'
+        @while_stack = []
+        @identity = nil
+        @defs     = nil
+
+        @methods = []
+
+        @uses_block = false
+
+        # used by classes to store all ivars used in direct def methods
+        @proto_ivars = []
+      end
+
+      def in_scope(&block)
+        indent do
+          @parent = compiler.scope
+          compiler.scope = self
+          block.call self
+          compiler.scope = @parent
+        end
+      end
+
+      # Returns true if this scope is a class/module body scope
+      def class_scope?
+        @type == :class or @type == :module
+      end
+
+      # Returns true if this is strictly a class scope
+      def class?
+        @type == :class
+      end
+
+      # True if this is a module scope
+      def module?
+        @type == :module
+      end
+
+      def sclass?
+        @type == :sclass
+      end
+
+      # Returns true if this is a top scope (main file body)
+      def top?
+        @type == :top
+      end
+
+      # True if a block/iter scope
+      def iter?
+        @type == :iter
+      end
+
+      def def?
+        @type == :def
+      end
+
+      # Is this a normal def method directly inside a class? This is
+      # used for optimizing ivars as we can set them to nil in the
+      # class body
+      def def_in_class?
+        !@defs && @type == :def && @parent && @parent.class?
+      end
+
+      # Inside a class or module scope, the javascript variable name returned
+      # by this function points to the classes' prototype. This is the target
+      # to where methods are actually added inside a class body.
+      def proto
+        "def"
+      end
+
+      ##
+      # Vars to use inside each scope
+      def to_vars
+        vars = @temps.dup
+        vars.push(*@locals.map { |l| "#{l} = nil" })
+
+        iv = ivars.map do |ivar|
+          "if (self#{ivar} == null) self#{ivar} = nil;\n"
+        end
+
+        gv = gvars.map do |gvar|
+          "if ($gvars#{gvar} == null) $gvars#{gvar} = nil;\n"
+        end
+
+        indent = @compiler.parser_indent
+        str  = vars.empty? ? '' : "var #{vars.join ', '};\n"
+        str += "#{indent}#{iv.join indent}" unless ivars.empty?
+        str += "#{indent}#{gv.join indent}" unless gvars.empty?
+
+        if class? and !@proto_ivars.empty?
+          #raise "FIXME to_vars"
+          pvars = @proto_ivars.map { |i| "#{proto}#{i}"}.join(' = ')
+          result = "%s\n%s%s = nil;" % [str, indent, pvars]
+        else
+          result = str
+        end
+
+        fragment(result)
+      end
+
+      def add_scope_ivar(ivar)
+        if def_in_class?
+          @parent.add_proto_ivar ivar
+        else
+          @ivars << ivar unless @ivars.include? ivar
+        end
+      end
+
+      def add_scope_gvar(gvar)
+        @gvars << gvar unless @gvars.include? gvar
+      end
+
+      def add_proto_ivar(ivar)
+        @proto_ivars << ivar unless @proto_ivars.include? ivar
+      end
+
+      def add_arg(arg)
+        @args << arg unless @args.include? arg
+        arg
+      end
+
+      def add_scope_local(local)
+        return if has_local? local
+
+        @locals << local
+      end
+
+      def has_local?(local)
+        return true if @locals.include? local or @args.include? local
+        return @parent.has_local?(local) if @parent and @type == :iter
+
+        false
+      end
+
+      def add_scope_temp(*tmps)
+        @temps.push(*tmps)
+      end
+
+      def has_temp?(tmp)
+        @temps.include? tmp
+      end
+
+      def new_temp
+        return @queue.pop unless @queue.empty?
+
+        tmp = next_temp
+        @temps << tmp
+        tmp
+      end
+
+      def next_temp
+        while true
+          tmp = "$#{@unique}"
+          @unique = @unique.succ
+          unless has_local?(tmp)
+            break
+          end
+        end
+        tmp
+      end
+
+      def queue_temp(name)
+        @queue << name
+      end
+
+      def push_while
+        info = {}
+        @while_stack.push info
+        info
+      end
+
+      def pop_while
+        @while_stack.pop
+      end
+
+      def in_while?
+        !@while_stack.empty?
+      end
+
+      def uses_block!
+        if @type == :iter && @parent
+          @parent.uses_block!
+        else
+          @uses_block = true
+          identify!
+        end
+      end
+
+      def identify!
+        return @identity if @identity
+
+        @identity = @compiler.unique_temp
+        @parent.add_scope_temp @identity if @parent
+
+        @identity
+      end
+
+      def identity
+        @identity
+      end
+
+      def find_parent_def
+        scope = self
+        while scope = scope.parent
+          if scope.def?
+            return scope
+          end
+        end
+
+        nil
+      end
+
+      def get_super_chain
+        chain, scope, defn, mid = [], self, 'null', 'null'
+
+        while scope
+          if scope.type == :iter
+            chain << scope.identify!
+            scope = scope.parent if scope.parent
+
+          elsif scope.type == :def
+            defn = scope.identify!
+            mid  = "'#{scope.mid}'"
+            break
+
+          else
+            break
+          end
+        end
+
+        [chain, defn, mid]
+      end
+
+      def uses_block?
+        @uses_block
+      end
+    end
+  end
+end

data/lib/opal/nodes/singleton_class.rb

@@ -0,0 +1,26 @@
+require 'opal/nodes/scope'
+
+module Opal
+  module Nodes
+    class SingletonClassNode < ScopeNode
+      handle :sclass
+
+      children :object, :body
+
+      def compile
+        push "(function(self) {"
+
+        in_scope do
+          add_temp '$scope = self.$$scope'
+          add_temp 'def = self.$$proto'
+
+          body_stmt = stmt(compiler.returns(body))
+          line scope.to_vars
+          line body_stmt
+        end
+
+        line "})(", recv(object), ".$singleton_class())"
+      end
+    end
+  end
+end

data/lib/opal/nodes/super.rb

@@ -0,0 +1,97 @@
+require 'opal/nodes/base'
+
+module Opal
+  module Nodes
+    # This base class is used just to child the find_super_dispatcher method
+    # body. This is then used by actual super calls, or a defined?(super) style
+    # call.
+    class BaseSuperNode < Base
+      children :arglist, :iter
+
+      def compile_dispatcher
+        if arglist or iter
+          iter = expr(iter_sexp)
+        else
+          scope.uses_block!
+          iter = '$iter'
+        end
+        if scope.def?
+          scope.uses_block!
+          scope_name = scope.identify!
+          class_name = scope.parent.name ? "$#{scope.parent.name}" : 'self.$$class.$$proto'
+
+          if scope.defs
+            push "Opal.find_super_dispatcher(self, '#{scope.mid.to_s}', #{scope_name}, "
+            push iter
+            push ", #{class_name})"
+          else
+            push "Opal.find_super_dispatcher(self, '#{scope.mid.to_s}', #{scope_name}, "
+            push iter
+            push ")"
+          end
+        elsif scope.iter?
+          chain, cur_defn, mid = scope.get_super_chain
+          trys = chain.map { |c| "#{c}.$$def" }.join(' || ')
+
+          push "Opal.find_iter_super_dispatcher(self, #{mid}, (#{trys} || #{cur_defn}), null)"
+        else
+          raise "Cannot call super() from outside a method block"
+        end
+      end
+
+      def args
+        arglist || s(:arglist)
+      end
+
+      def iter_sexp
+        iter || s(:js_tmp, 'null')
+      end
+    end
+
+    class DefinedSuperNode < BaseSuperNode
+      handle :defined_super
+
+      def compile
+        # insert method body to find super method
+        self.compile_dispatcher
+
+        wrap '((', ') != null ? "super" : nil)'
+      end
+    end
+
+    class SuperNode < BaseSuperNode
+      handle :super
+
+      children :arglist, :iter
+
+      def compile
+        if arglist or iter
+          splat = has_splat?
+          args = expr(self.args)
+
+          unless splat
+            args = [fragment('['), args, fragment(']')]
+          end
+        else
+          if scope.def?
+            scope.uses_zuper = true
+            args = fragment('$zuper')
+          else
+            args = fragment('$slice.call(arguments)')
+          end
+        end
+
+        # compile our call to runtime to get super method
+        self.compile_dispatcher
+
+        push ".apply(self, "
+        push(*args)
+        push ")"
+      end
+
+      def has_splat?
+        args.children.any? { |child| child.type == :splat }
+      end
+    end
+  end
+end