opal 0.5.5 → 0.6.0

data/lib/opal/nodes/call_special.rb

@@ -77,7 +77,7 @@ module Opal
         with_temp do |a| # args
           with_temp do |r| # recv
             cur = s(:call, s(:js_tmp, r), :[], s(:arglist, s(:js_tmp, a)))
-            rhs = s(:call, cur, :+, s(:arglist, self.rhs))
+            rhs = s(:call, cur, op.to_sym, s(:arglist, self.rhs))
             call = s(:call, s(:js_tmp, r), :[]=, s(:arglist, s(:js_tmp, a), rhs))
 
             push "(#{a} = ", expr(first_arg), ", #{r} = ", expr(lhs)

data/lib/opal/nodes/class.rb

@@ -17,8 +17,8 @@ module Opal
 
         in_scope do
           scope.name = name
-          add_temp "#{scope.proto} = $#{name}._proto"
-          add_temp "$scope = $#{name}._scope"
+          add_temp "#{scope.proto} = self._proto"
+          add_temp "$scope = self._scope"
 
           body_code = self.body_code
           empty_line

data/lib/opal/nodes/constants.rb

@@ -8,7 +8,9 @@ module Opal
       children :name
 
       def compile
-        if compiler.const_missing?
+        if name == :DATA and compiler.eof_content
+          push("$__END__")
+        elsif compiler.const_missing?
           with_temp do |tmp|
             push "((#{tmp} = $scope.#{name}) == null ? $opal.cm('#{name}') : #{tmp})"
           end

data/lib/opal/nodes/helpers.rb

@@ -3,31 +3,40 @@ module Opal
     module Helpers
 
       # Reserved javascript keywords - we cannot create variables with the
-      # same name
-      RESERVED = %w[
-        arguments break case catch char class const continue debugger default
-        delete do else enum export extends false finally for function if import
-        in instanceof let native new return static switch super this throw try
-        true typeof var void while with undefined
-      ]
+      # same name (ref: http://stackoverflow.com/a/9337272/601782)
+      ES51_RESERVED_WORD = /^(?:do|if|in|for|let|new|try|var|case|else|enum|eval|false|null|this|true|void|with|break|catch|class|const|super|throw|while|yield|delete|export|import|public|return|static|switch|typeof|default|extends|finally|package|private|continue|debugger|function|arguments|interface|protected|implements|instanceof)$/
+
+      # ES3 reserved words that aren’t ES5.1 reserved words
+      ES3_RESERVED_WORD_EXCLUSIVE = /^(?:int|byte|char|goto|long|final|float|short|double|native|throws|boolean|abstract|volatile|transient|synchronized)$/
+
+      # Immutable properties of the global object
+      IMMUTABLE_PROPS = /^(?:NaN|Infinity|undefined)$/
+
+      # Doesn't take in account utf8
+      BASIC_IDENTIFIER_RULES = /^[$_a-z][$_a-z\d]*$/i
+
 
       def property(name)
-        reserved?(name) ? "['#{name}']" : ".#{name}"
+        valid_name?(name) ? ".#{name}" : "[#{name.inspect}]"
       end
 
-      def reserved?(name)
-        RESERVED.include? name
+      def valid_name?(name)
+        BASIC_IDENTIFIER_RULES =~ name and not(
+          ES51_RESERVED_WORD          =~ name or
+          ES3_RESERVED_WORD_EXCLUSIVE =~ name or
+          IMMUTABLE_PROPS             =~ name
+        )
       end
 
       def variable(name)
-        reserved?(name.to_s) ? "#{name}$" : name
+        valid_name?(name.to_s) ? name : "#{name}$"
       end
 
       # Converts a ruby lvar/arg name to a js identifier. Not all ruby names
       # are valid in javascript. A $ suffix is added to non-valid names.
       # varibales
       def lvar_to_js(var)
-        var = "#{var}$" if RESERVED.include? var.to_s
+        var = "#{var}$" unless valid_name? var.to_s
         var.to_sym
       end
 
@@ -67,7 +76,7 @@ module Opal
         end
 
         with_temp do |tmp|
-          [fragment("(#{tmp} = "), expr(sexp), fragment(") !== false && #{tmp} !== nil")]
+          [fragment("((#{tmp} = "), expr(sexp), fragment(") !== nil && (!#{tmp}._isBoolean || #{tmp} == true))")]
         end
       end
 
@@ -81,7 +90,7 @@ module Opal
         end
 
         with_temp do |tmp|
-          [fragment("(#{tmp} = "), expr(sexp), fragment(") === false || #{tmp} === nil")]
+          [fragment("((#{tmp} = "), expr(sexp), fragment(") === nil || (#{tmp}._isBoolean && #{tmp} == false))")]
         end
       end
 

data/lib/opal/nodes/if.rb

@@ -7,21 +7,20 @@ module Opal
 
       children :test, :true_body, :false_body
 
+      RUBY_ENGINE_CHECK = [:call, [:const, :RUBY_ENGINE],
+                              :==, [:arglist, [:str, "opal"]]]
+
+      RUBY_PLATFORM_CHECK = [:call, [:const, :RUBY_PLATFORM],
+                              :==, [:arglist, [:str, "opal"]]]
+
       def compile
         truthy, falsy = self.truthy, self.falsy
 
-        push "if ("
-
-        # optimize unless (we don't want a else() unless we need to)
-        if falsy and !truthy
-          truthy = falsy
+        if skip_check_present?
           falsy = nil
-          push js_falsy(test)
-        else
-          push js_truthy(test)
         end
 
-        push ") {"
+        push "if (", js_truthy(test), ") {"
 
         # skip if-body if no truthy sexp
         indent { line stmt(truthy) } if truthy
@@ -44,6 +43,14 @@ module Opal
         wrap "(function() {", "; return nil; })()" if needs_wrapper?
       end
 
+      # pre-processing only effects falsy blocks. If engine is
+      # opal, then falsy block gets generated as normal. Unless
+      # engine is opal then that code gets generated as the
+      # falsy block
+      def skip_check_present?
+        test == RUBY_ENGINE_CHECK or test == RUBY_PLATFORM_CHECK
+      end
+
       def truthy
         needs_wrapper? ? compiler.returns(true_body || s(:nil)) : true_body
       end

data/lib/opal/nodes/literal.rb

@@ -44,14 +44,38 @@ module Opal
     class RegexpNode < Base
       handle :regexp
 
-      children :value
+      children :value, :flags
 
       def compile
-        push((value == // ? /^/ : value).inspect)
+        if value == ''
+          push('/^/')
+        else
+          push "#{Regexp.new(value).inspect}#{flags}"
+        end
+      end
+    end
+
+    module XStringLineSplitter
+      def compile_split_lines(value, sexp)
+        idx = 0
+        value.each_line do |line|
+          if idx == 0
+            push line
+          else
+            line_sexp = s()
+            line_sexp.source = [sexp.line + idx, 0]
+            frag = Fragment.new(line, line_sexp)
+            push frag
+          end
+
+          idx += 1
+        end
       end
     end
 
     class XStringNode < Base
+      include XStringLineSplitter
+
       handle :xstr
 
       children :value
@@ -61,11 +85,16 @@ module Opal
       end
 
       def compile
-        push value.to_s
+        compile_split_lines(value.to_s, @sexp)
+
         push ';' if needs_semicolon?
 
         wrap '(', ')' if recv?
       end
+
+      def start_line
+        @sexp.line
+      end
     end
 
     class DynamicStringNode < Base
@@ -115,6 +144,8 @@ module Opal
     end
 
     class DynamicXStringNode < Base
+      include XStringLineSplitter
+
       handle :dxstr
 
       def requires_semicolon(code)
@@ -126,12 +157,13 @@ module Opal
 
         children.each do |part|
           if String === part
-            push part.to_s
+            compile_split_lines(part.to_s, @sexp)
+
             needs_semicolon = true if requires_semicolon(part.to_s)
           elsif part.type == :evstr
             push expr(part[1])
           elsif part.type == :str
-            push part.last.to_s
+            compile_split_lines(part.last.to_s, part)
             needs_semicolon = true if requires_semicolon(part.last.to_s)
           else
             raise "Bad dxstr part"

data/lib/opal/nodes/logic.rb

@@ -148,7 +148,13 @@ module Opal
       children :value
 
       def return_val
-        expr_or_nil value
+        if value.nil?
+          expr(s(:nil))
+        elsif children.size > 1
+          expr(s(:array, *children))
+        else
+          expr(value)
+        end
       end
 
       def return_in_iter?

data/lib/opal/nodes/module.rb

@@ -31,8 +31,8 @@ module Opal
       end
 
       def name_and_base
-        if Symbol === cid or String === cid
-          [cid.to_s, 'self']
+        if cid.type == :const
+          [cid[1].to_s, 'self']
         elsif cid.type == :colon2
           [cid[2].to_s, expr(cid[1])]
         elsif cid.type == :colon3

data/lib/opal/nodes/scope.rb

@@ -15,6 +15,7 @@ module Opal
 
       attr_reader :scope_name
       attr_reader :ivars
+      attr_reader :gvars
 
       attr_accessor :mid
 
@@ -37,6 +38,7 @@ module Opal
         @temps    = []
         @args     = []
         @ivars    = []
+        @gvars    = []
         @parent   = nil
         @queue    = []
         @unique   = 'a'
@@ -124,9 +126,14 @@ module Opal
           "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
-        res = vars.empty? ? '' : "var #{vars.join ', '};"
-        str = ivars.empty? ? res : "#{res}\n#{indent}#{iv.join 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"
@@ -156,6 +163,10 @@ module Opal
         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

data/lib/opal/nodes/top.rb

@@ -27,6 +27,7 @@ module Opal
 
           compile_method_stubs
           compile_irb_vars
+          compile_end_construct
 
           line body_code
         end
@@ -57,6 +58,14 @@ module Opal
         end
       end
 
+      # Any special __END__ content in code
+      def compile_end_construct
+        if content = compiler.eof_content
+          line "var $__END__ = Opal.Object.$new();"
+          line "$__END__.$read = function() { return #{content.inspect}; };"
+        end
+      end
+
       def version_comment
         "/* Generated by Opal #{Opal::VERSION} */"
       end

data/lib/opal/nodes/variables.rb

@@ -88,7 +88,9 @@ module Opal
 
       def compile
         helper :gvars
-        push "$gvars[#{var_name.inspect}]"
+        name = property var_name
+        add_gvar name
+        push "$gvars#{name}"
       end
     end
 
@@ -103,7 +105,8 @@ module Opal
 
       def compile
         helper :gvars
-        push "$gvars[#{var_name.inspect}] = "
+        name = property var_name
+        push "$gvars#{name} = "
         push expr(value)
       end
     end

data/lib/opal/parser.rb

@@ -9,9 +9,10 @@ module Opal
     attr_reader :lexer, :file, :scope
 
     def parse(source, file = '(string)')
-      @lexer = Lexer.new(source, file)
       @file = file
       @scopes = []
+      @lexer = Lexer.new(source, file)
+      @lexer.parser = self
 
       self.parse_to_sexp
     end
@@ -29,9 +30,7 @@ module Opal
     end
 
     def s(*parts)
-      sexp = Sexp.new(parts)
-      sexp.line = @lexer.line
-      sexp
+      Sexp.new(parts)
     end
 
     def push_scope(type = nil)
@@ -48,29 +47,161 @@ module Opal
     end
 
     def on_error(t, val, vstack)
-      raise "parse error on value #{val.inspect} (#{token_to_str(t) || '?'}) :#{@file}:#{lexer.line}"
+      raise "parse error on value #{value(val).inspect} (#{token_to_str(t) || '?'}) :#{@file}:#{lexer.line}"
+    end
+
+    def value(tok)
+      tok[0]
+    end
+
+    def source(tok)
+      tok ? tok[1] : nil
+    end
+
+    def s0(type, source)
+      sexp = s(type)
+      sexp.source = source
+      sexp
+    end
+
+    def s1(type, first, source)
+      sexp = s(type, first)
+      sexp.source = source
+      sexp
+    end
+
+    def new_nil(tok)
+      s0(:nil, source(tok))
+    end
+
+    def new_self(tok)
+      s0(:self, source(tok))
+    end
+
+    def new_true(tok)
+      s0(:true, source(tok))
+    end
+
+    def new_false(tok)
+      s0(:false, source(tok))
+    end
+
+    def new___FILE__(tok)
+      s1(:str, self.file, source(tok))
+    end
+
+    def new___LINE__(tok)
+      s1(:int, lexer.line, source(tok))
+    end
+
+    def new_ident(tok)
+      s1(:identifier, value(tok).to_sym, source(tok))
+    end
+
+    def new_int(tok)
+      s1(:int, value(tok), source(tok))
+    end
+
+    def new_float(tok)
+      s1(:float, value(tok), source(tok))
+    end
+
+    def new_ivar(tok)
+      s1(:ivar, value(tok).to_sym, source(tok))
+    end
+
+    def new_gvar(tok)
+      s1(:gvar, value(tok).to_sym, source(tok))
+    end
+
+    def new_cvar(tok)
+      s1(:cvar, value(tok).to_sym, source(tok))
+    end
+
+    def new_const(tok)
+      s1(:const, value(tok).to_sym, source(tok))
+    end
+
+    def new_colon2(lhs, tok, name)
+      sexp = s(:colon2, lhs, value(name).to_sym)
+      sexp.source = source(tok)
+      sexp
+    end
+
+    def new_colon3(tok, name)
+      s1(:colon3, value(name).to_sym, source(name))
+    end
+
+    def new_sym(tok)
+      s1(:sym, value(tok).to_sym, source(tok))
+    end
+
+    def new_alias(kw, new, old)
+      sexp = s(:alias, new, old)
+      sexp.source = source(kw)
+      sexp
+    end
+
+    def new_break(kw, args=nil)
+      if args.nil?
+        sexp = s(:break)
+      elsif args.length == 1
+        sexp = s(:break, args[0])
+      else
+        sexp = s(:break, s(:array, *args))
+      end
+
+      sexp
+    end
+
+    def new_return(kw, args=nil)
+      if args.nil?
+        sexp = s(:return)
+      elsif args.length == 1
+        sexp = s(:return, args[0])
+      else
+        sexp = s(:return, s(:array, *args))
+      end
+
+      sexp
+    end
+
+    def new_next(kw, args=[])
+      if args.length == 1
+        sexp = s(:next, args[0])
+      else
+        sexp = s(:next, s(:array, *args))
+      end
+
+      sexp
     end
 
     def new_block(stmt = nil)
-      s = s(:block)
-      s << stmt if stmt
-      s
+      sexp = s(:block)
+      sexp << stmt if stmt
+      sexp
     end
 
     def new_compstmt(block)
-      if block.size == 1
-        nil
-      elsif block.size == 2
-        block[1]
+      comp = if block.size == 1
+              nil
+            elsif block.size == 2
+              block[1]
+            else
+              block
+            end
+
+      if comp && comp.type == :begin && comp.size == 2
+        result = comp[1]
       else
-        block.line = block[1].line
-        block
+        result = comp
       end
+
+      result
     end
 
     def new_body(compstmt, res, els, ens)
       s = compstmt || s(:block)
-      s.line = compstmt.line if compstmt
 
       if res
         s = s(:rescue, s)
@@ -81,40 +212,87 @@ module Opal
       ens ? s(:ensure, s, ens) : s
     end
 
-    def new_def(line, recv, name, args, body)
+    def new_def(kw, recv, name, args, body, end_tok)
       body = s(:block, body) if body.type != :block
       body << s(:nil) if body.size == 1
-      args.line = line
-      s = s(:def, recv, name.to_sym, args, body)
-      s.line = line
-      s.end_line = @lexer.line
-      s
+
+      sexp = s(:def, recv, value(name).to_sym, args, body)
+      sexp.source = source(kw)
+      sexp
     end
 
-    def new_class(path, sup, body)
-      s(:class, path, sup, body)
+    def new_class(start, path, sup, body, endt)
+      sexp = s(:class, path, sup, body)
+      sexp.source = source(start)
+      sexp
     end
 
-    def new_sclass(expr, body)
-      s(:sclass, expr, body)
+    def new_sclass(kw, expr, body, end_tok)
+      sexp = s(:sclass, expr, body)
+      sexp.source = source(kw)
+      sexp
     end
 
-    def new_module(path, body)
-      s(:module, path, body)
+    def new_module(kw, path, body, end_tok)
+      sexp = s(:module, path, body)
+      sexp.source = source(kw)
+      sexp
     end
 
     def new_iter(args, body)
+      args ||= nil
       s = s(:iter, args)
       s << body if body
-      s.end_line = @lexer.line
       s
     end
 
-    def new_if(expr, stmt, tail)
-      s = s(:if, expr, stmt, tail)
-      s.line = expr.line
-      s.end_line = @lexer.line
-      s
+    def new_if(if_tok, expr, stmt, tail)
+      sexp = s(:if, expr, stmt, tail)
+      sexp.source = source(if_tok)
+      sexp
+    end
+
+    def new_while(kw, test, body)
+      sexp = s(:while, test, body)
+      sexp.source = source(kw)
+      sexp
+    end
+
+    def new_until(kw, test, body)
+      sexp = s(:until, test, body)
+      sexp.source = source(kw)
+      sexp
+    end
+
+    def new_rescue_mod(kw, expr, resc)
+      sexp = s(:rescue_mod, expr, resc)
+      sexp.source = source(kw)
+      sexp
+    end
+
+    def new_array(start, args, finish)
+      args ||= []
+      sexp = s(:array, *args)
+      sexp.source = source(start)
+      sexp
+    end
+
+    def new_hash(open, assocs, close)
+      sexp = s(:hash, *assocs)
+      sexp.source = source(open)
+      sexp
+    end
+
+    def new_not(kw, expr)
+      s1(:not, expr, source(kw))
+    end
+
+    def new_paren(open, expr, close)
+      if expr.nil? or expr == [:block]
+        s1(:paren, s0(:nil, source(open)), source(open))
+      else
+        s1(:paren, expr, source(open))
+      end
     end
 
     def new_args(norm, opt, rest, block)
@@ -171,7 +349,7 @@ module Opal
 
       if rest
         r = rest.to_s[1..-1].to_sym
-        res << s(:splat, s(:lasgn, r))
+        res << new_splat(nil, s(:lasgn, r))
         scope.add_local r
       end
 
@@ -193,25 +371,42 @@ module Opal
     end
 
     def new_call(recv, meth, args = nil)
-      call = s(:call, recv, meth)
-      args = s(:arglist) unless args
-      args.type = :arglist if args.type == :array
-      call << args
-
-      if recv
-        call.line = recv.line
-      elsif args[1]
-        call.line = args[1].line
-      end
+      args ||= []
+      sexp = s(:call, recv, value(meth).to_sym, s(:arglist, *args))
+      sexp.source = source(meth)
+      sexp
+    end
 
-      # fix arglist spilling over into next line if no args
-      if args.length == 1
-        args.line = call.line
-      else
-        args.line = args[1].line
-      end
+    def new_binary_call(recv, meth, arg)
+      new_call(recv, meth, [arg])
+    end
+
+    def new_unary_call(op, recv)
+      new_call(recv, op, [])
+    end
+
+    def new_and(lhs, tok, rhs)
+      sexp = s(:and, lhs, rhs)
+      sexp.source = source(tok)
+      sexp
+    end
+
+    def new_or(lhs, tok, rhs)
+      sexp = s(:or, lhs, rhs)
+      sexp.source = source(tok)
+      sexp
+    end
 
-      call
+    def new_irange(beg, op, finish)
+      sexp = s(:irange, beg, finish)
+      sexp.source = source(op)
+      sexp
+    end
+
+    def new_erange(beg, op, finish)
+      sexp = s(:erange, beg, finish)
+      sexp.source = source(op)
+      sexp
     end
 
     def add_block_pass(arglist, block)
@@ -219,8 +414,16 @@ module Opal
       arglist
     end
 
+    def new_block_pass(amper_tok, val)
+      s1(:block_pass, val, source(amper_tok))
+    end
+
+    def new_splat(tok, value)
+      s1(:splat, value, source(tok))
+    end
+
     def new_op_asgn(op, lhs, rhs)
-      case op
+      case value(op).to_sym
       when :"||"
         result = s(:op_asgn_or, new_gettable(lhs))
         result << (lhs << rhs)
@@ -229,15 +432,31 @@ module Opal
         result << (lhs << rhs)
       else
         result = lhs
-        result << new_call(new_gettable(lhs), op, s(:arglist, rhs))
+        result << new_call(new_gettable(lhs), op, [rhs])
 
       end
 
-      result.line = lhs.line
       result
     end
 
-    def new_assign(lhs, rhs)
+    def new_op_asgn1(lhs, args, op, rhs)
+      arglist = s(:arglist, *args)
+      sexp = s(:op_asgn1, lhs, arglist, value(op), rhs)
+      sexp.source = source(op)
+      sexp
+    end
+
+    def op_to_setter(op)
+      "#{value(op)}=".to_sym
+    end
+
+    def new_attrasgn(recv, op, args=[])
+      arglist = s(:arglist, *args)
+      sexp = s(:attrasgn, recv, op, arglist)
+      sexp
+    end
+
+    def new_assign(lhs, tok, rhs)
       case lhs.type
       when :iasgn, :cdecl, :lasgn, :gasgn, :cvdecl, :nth_ref
         lhs << rhs
@@ -288,11 +507,13 @@ module Opal
               s(:gvar, ref[1])
             when :cvdecl
               s(:cvar, ref[1])
+            when :cdecl
+              s(:const, ref[1])
             else
               raise "Bad new_gettable ref: #{ref.type}"
             end
 
-      res.line = ref.line
+      res.source = ref.source
       res
     end
 
@@ -311,32 +532,36 @@ module Opal
         # returns for __FILE__ as it is converted into str
         ref
       when :identifier
-        if scope.has_local? ref[1]
-          s(:lvar, ref[1])
-        else
-          s(:call, nil, ref[1], s(:arglist))
-        end
+        result = if scope.has_local? ref[1]
+                  s(:lvar, ref[1])
+                else
+                  s(:call, nil, ref[1], s(:arglist))
+                end
+
+        result.source = ref.source
+        result
       else
         raise "Bad var_ref type: #{ref.type}"
       end
     end
 
-    def new_super(args)
-      args = (args || s(:arglist))
-
-      if args.type == :array
-        args.type = :arglist
+    def new_super(kw, args)
+      if args.nil?
+        sexp = s(:super, nil)
+      else
+        sexp = s(:super, s(:arglist, *args))
       end
 
-      s(:super, args)
+      sexp.source = source(kw)
+      sexp
     end
 
     def new_yield(args)
-      args = (args || s(:arglist))[1..-1]
+      args ||= []
       s(:yield, *args)
     end
 
-    def new_xstr(str)
+    def new_xstr(start_t, str, end_t)
       return s(:xstr, '') unless str
       case str.type
       when :str   then str.type = :xstr
@@ -344,6 +569,8 @@ module Opal
       when :evstr then str = s(:dxstr, '', str)
       end
 
+      str.source = source(start_t)
+
       str
     end
 
@@ -360,6 +587,10 @@ module Opal
       str
     end
 
+    def new_evstr(str)
+      s(:evstr, str)
+    end
+
     def new_str(str)
       # cover empty strings
       return s(:str, "") unless str
@@ -379,10 +610,10 @@ module Opal
     end
 
     def new_regexp(reg, ending)
-      return s(:regexp, //) unless reg
+      return s(:regexp, '') unless reg
       case reg.type
       when :str
-        s(:regexp, Regexp.new(reg[1], ending))
+        s(:regexp, reg[1], value(ending))
       when :evstr
         s(:dregx, "", reg)
       when :dstr
@@ -405,5 +636,9 @@ module Opal
       str << str2
       str
     end
+
+    def new_str_content(tok)
+      s1(:str, value(tok), source(tok))
+    end
   end
 end