opal 0.11.4 → 1.0.0.beta1

data/lib/opal/parser/patch.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+if RUBY_ENGINE == 'opal'
+  class Parser::Lexer::Literal
+    undef :extend_string
+
+    def extend_string(string, ts, te)
+      @buffer_s ||= ts
+      @buffer_e = te
+
+      # Patch for opal-parser, original:
+      # @buffer << string
+      @buffer += string
+    end
+  end
+
+  class Parser::Source::Buffer
+    def source_lines
+      @lines ||= begin
+        lines = @source.lines.to_a
+        lines << '' if @source.end_with?("\n")
+        lines.map { |line| line.chomp("\n") }
+      end
+    end
+  end
+end

data/lib/opal/parser/source_buffer.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Opal
+  module Parser
+    class SourceBuffer < ::Parser::Source::Buffer
+      def self.recognize_encoding(string)
+        super || Encoding::UTF_8
+      end
+    end
+  end
+end

data/lib/opal/parser/with_c_lexer.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+begin
+  require 'c_lexer'
+rescue LoadError
+  $stderr.puts 'Failed to load WithCLexer, using pure Ruby lexer'
+end
+
+if defined? Parser::Ruby25WithWithCLexer
+  class Opal::Parser::WithCLexer < Parser::Ruby25WithWithCLexer
+    include Opal::Parser::DefaultConfig
+    Opal::Parser.default_parser_class = self
+  end
+end

data/lib/opal/parser/with_ruby_lexer.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+class Opal::Parser::WithRubyLexer < Parser::Ruby25
+  include Opal::Parser::DefaultConfig
+  Opal::Parser.default_parser_class = self
+end

data/lib/opal/path_reader.rb

@@ -1,11 +1,12 @@
 # frozen_string_literal: true
+
 require 'opal/regexp_anchors'
-require 'hike'
+require 'opal/hike'
 
 module Opal
   class PathReader
-    RELATIVE_PATH_REGEXP = %r{#{Opal::REGEXP_START}\.?\.#{Regexp.quote File::SEPARATOR}}
-    DEFAULT_EXTENSIONS = ['.js', '.js.rb', '.rb', '.opalerb']
+    RELATIVE_PATH_REGEXP = /#{Opal::REGEXP_START}\.?\.#{Regexp.quote File::SEPARATOR}/
+    DEFAULT_EXTENSIONS = ['.js', '.js.rb', '.rb', '.opalerb'].freeze
 
     def initialize(paths = Opal.paths, extensions = DEFAULT_EXTENSIONS)
       @file_finder = Hike::Trail.new
@@ -16,7 +17,7 @@ module Opal
     def read(path)
       full_path = expand(path)
       return nil if full_path.nil?
-      File.open(full_path, 'rb:UTF-8'){|f| f.read}
+      File.open(full_path, 'rb:UTF-8', &:read)
     end
 
     def expand(path)
@@ -43,7 +44,7 @@ module Opal
 
     def find_path(path)
       pathname = Pathname(path)
-      return path if pathname.absolute? and pathname.exist?
+      return path if pathname.absolute? && pathname.exist?
       file_finder.find(path)
     end
 

data/lib/opal/paths.rb

@@ -1,15 +1,16 @@
 # frozen_string_literal: true
+
 module Opal
   def self.gem_dir
-    File.expand_path("../..", __FILE__.dup.untaint)
+    File.expand_path('../..', __FILE__.dup.untaint)
   end
 
   def self.core_dir
-    File.expand_path("../../../opal", __FILE__.dup.untaint)
+    File.expand_path('../../../opal', __FILE__.dup.untaint)
   end
 
   def self.std_dir
-    File.expand_path("../../../stdlib", __FILE__.dup.untaint)
+    File.expand_path('../../../stdlib', __FILE__.dup.untaint)
   end
 
   # Add a file path to opals load path. Any gem containing ruby code that Opal
@@ -48,9 +49,11 @@ module Opal
       spec = Gem::Specification.find_by_name(gem_name)
       raise GemNotFound, gem_name unless spec
 
-      spec.runtime_dependencies.each do |dependency|
-        paths += require_paths_for_gem(dependency.name, include_dependencies)
-      end if include_dependencies
+      if include_dependencies
+        spec.runtime_dependencies.each do |dependency|
+          paths += require_paths_for_gem(dependency.name, include_dependencies)
+        end
+      end
 
       gem_dir = spec.gem_dir
       spec.require_paths.map do |path|

data/lib/opal/regexp_anchors.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
+
 module Opal
-  REGEXP_START = RUBY_ENGINE == 'opal' ? '^' : '\A'.freeze
-  REGEXP_END = RUBY_ENGINE == 'opal' ? '$' : '\z'.freeze
+  REGEXP_START = RUBY_ENGINE == 'opal' ? '^' : '\A'
+  REGEXP_END = RUBY_ENGINE == 'opal' ? '$' : '\z'
 
   # Unicode characters in ranges
   # \u0001 - \u002F (blank unicode characters + space + !"#$%&'()*+,-./ chars)
@@ -10,7 +11,7 @@ module Opal
   # \u0060          (` char)
   # \u007B - \u007F ({|}~ chars})
   # are not allowed to be used in identifier in the beggining or middle of its name
-  FORBIDDEN_STARTING_IDENTIFIER_CHARS = "\\u0001-\\u002F\\u003A-\\u0040\\u005B-\\u005E\\u0060\\u007B-\\u007F"
+  FORBIDDEN_STARTING_IDENTIFIER_CHARS = '\u0001-\u002F\u003A-\u0040\u005B-\u005E\u0060\u007B-\u007F'
 
   # Unicode characters in ranges
   # \u0001 - \u0020 (blank unicode characters + space)
@@ -22,11 +23,11 @@ module Opal
   # \u007B - \u007F ({|}~ chars})
   # are not allowed to be used in identifier in the end of its name
   # In fact, FORBIDDEN_STARTING_IDENTIFIER_CHARS = FORBIDDEN_ENDING_IDENTIFIER_CHARS + \u0021 ('?') + \u003F ('!')
-  FORBIDDEN_ENDING_IDENTIFIER_CHARS   = "\\u0001-\\u0020\\u0022-\\u002F\\u003A-\\u003E\\u0040\\u005B-\\u005E\\u0060\\u007B-\\u007F"
+  FORBIDDEN_ENDING_IDENTIFIER_CHARS   = '\u0001-\u0020\u0022-\u002F\u003A-\u003E\u0040\u005B-\u005E\u0060\u007B-\u007F'
   INLINE_IDENTIFIER_REGEXP = Regexp.new("[^#{FORBIDDEN_STARTING_IDENTIFIER_CHARS}]*[^#{FORBIDDEN_ENDING_IDENTIFIER_CHARS}]")
 
   # For constants rules are pretty much the same, but ':' is allowed and '?!' are not.
   # Plus it may start with a '::' which indicates that the constant comes from toplevel.
-  FORBIDDEN_CONST_NAME_CHARS = "\\u0001-\\u0020\\u0021-\\u002F\\u003B-\\u003F\\u0040\\u005B-\\u005E\\u0060\\u007B-\\u007F"
+  FORBIDDEN_CONST_NAME_CHARS = '\u0001-\u0020\u0021-\u002F\u003B-\u003F\u0040\u005B-\u005E\u0060\u007B-\u007F'
   CONST_NAME_REGEXP = Regexp.new("#{REGEXP_START}(::)?[A-Z][^#{FORBIDDEN_CONST_NAME_CHARS}]*#{REGEXP_END}")
 end

data/lib/opal/rewriter.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'opal/rewriters/opal_engine_check'
 require 'opal/rewriters/for_rewriter'
 require 'opal/rewriters/explicit_writer_return'
@@ -8,6 +9,9 @@ require 'opal/rewriters/dot_js_syntax'
 require 'opal/rewriters/logical_operator_assignment'
 require 'opal/rewriters/binary_operator_assignment'
 require 'opal/rewriters/hashes/key_duplicates_rewriter'
+require 'opal/rewriters/dump_args'
+require 'opal/rewriters/mlhs_args'
+require 'opal/rewriters/inline_args'
 
 module Opal
   class Rewriter
@@ -45,6 +49,9 @@ module Opal
     use Rewriters::BinaryOperatorAssignment
     use Rewriters::ExplicitWriterReturn
     use Rewriters::Hashes::KeyDuplicatesRewriter
+    use Rewriters::DumpArgs
+    use Rewriters::MlhsArgs
+    use Rewriters::InlineArgs
 
     def initialize(sexp)
       @sexp = sexp

data/lib/opal/rewriters/arguments.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Opal
+  module Rewriters
+    class Arguments
+      attr_reader :args, :optargs, :restarg, :postargs,
+        :kwargs, :kwoptargs, :kwrestarg,
+        :shadowargs, :blockarg
+
+      def initialize(args)
+        @args = []
+        @optargs = []
+        @restarg = nil
+        @postargs = []
+        @kwargs = []
+        @kwoptargs = []
+        @kwrestarg = nil
+        @shadowargs = []
+        @blockarg = nil
+
+        args.each do |arg|
+          case arg.type
+          when :arg, :mlhs
+            (@restarg || @optargs.any? ? @postargs : @args) << arg
+          when :optarg
+            @optargs << arg
+          when :restarg
+            @restarg = arg
+          when :kwarg
+            @kwargs << arg
+          when :kwoptarg
+            @kwoptargs << arg
+          when :kwrestarg
+            @kwrestarg = arg
+          when :shadowarg
+            @shadowargs << arg
+          when :blockarg
+            @blockarg = arg
+          else
+            raise "Unsupported arg type #{arg.type}"
+          end
+        end
+      end
+
+      def has_post_args?
+        !@restarg.nil? || @postargs.any? || (has_any_kwargs? && !can_inline_kwargs?)
+      end
+
+      def has_any_kwargs?
+        @kwargs.any? || @kwoptargs.any? || !@kwrestarg.nil?
+      end
+
+      def can_inline_kwargs?
+        @optargs.empty? && @restarg.nil? && @postargs.empty?
+      end
+    end
+  end
+end

data/lib/opal/rewriters/base.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'parser'
 require 'opal/ast/node'
 
@@ -7,6 +8,7 @@ module Opal
     class Base < ::Parser::AST::Processor
       class DummyLocation
         def node=(*)
+          # stub
         end
 
         def expression
@@ -66,13 +68,8 @@ module Opal
       # Returns a new body with +node+ injected as a first statement.
       #
       def prepend_to_body(body, node)
-        if body.nil?
-          node
-        elsif [:begin, :kwbegin].include?(body.type)
-          body.updated(nil, [node, *body])
-        else
-          s(:begin, node, body)
-        end
+        stmts = stmts_of(node) + stmts_of(body)
+        begin_with_stmts(stmts)
       end
 
       # Appends given +node+ to +body+ node.
@@ -85,12 +82,28 @@ module Opal
       # Returns a new body with +node+ injected as a last statement.
       #
       def append_to_body(body, node)
-        if body.nil?
-          node
-        elsif [:begin, :kwbegin].include?(body.type)
-          body.updated(nil, [*body, node])
+        stmts = stmts_of(body) + stmts_of(node)
+        begin_with_stmts(stmts)
+      end
+
+      def stmts_of(node)
+        if node.nil?
+          []
+        elsif %i[begin kwbegin].include?(node.type)
+          node.children
         else
-          s(:begin, body, node)
+          [node]
+        end
+      end
+
+      def begin_with_stmts(stmts)
+        case stmts.length
+        when 0
+          nil
+        when 1
+          stmts[0]
+        else
+          s(:begin, *stmts)
         end
       end
 
@@ -104,6 +117,13 @@ module Opal
       ensure
         self.current_node = nil
       end
+
+      # This is called when a rewriting error occurs.
+      def error(msg)
+        error = ::Opal::RewritingError.new(msg)
+        error.location = current_node.loc if current_node
+        raise error
+      end
     end
   end
 end

data/lib/opal/rewriters/binary_operator_assignment.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'opal/rewriters/base'
 
 module Opal
@@ -15,14 +16,12 @@ module Opal
       end
 
       GET_SET = ->(get_type, set_type) {
+        ->(lhs, operation, rhs) {
+          get_node = lhs.updated(get_type)               # lhs
+          set_node = s(:send, get_node, operation, rhs)  # lhs + rhs
 
-        ->(lhs, op, rhs) {
-          get_node = lhs.updated(get_type) # lhs
-          set_node = s(:send, get_node, op, rhs) # lhs + rhs
-
-          lhs.updated(set_type, [*lhs, set_node]) # lhs = lhs + rhs
+          lhs.updated(set_type, [*lhs, set_node])        # lhs = lhs + rhs
         }
-
       }
 
       # Takes    `lhs += rhs`
@@ -49,21 +48,21 @@ module Opal
       # Produces `recvr.meth = recvr.meth + rhs`
       # (lhs is a recvr.meth, op is :+)
       class SendHandler < self
-        def self.call(lhs, op, rhs)
+        def self.call(lhs, operation, rhs)
           recvr, reader_method, *args = *lhs
 
           # If recvr is a complex expression it must be cached.
           # MRI calls recvr in `recvr.meth ||= rhs` only once.
           if recvr && recvr.type == :send
             recvr_tmp = new_temp
-            cache_recvr = s(:lvasgn, recvr_tmp, recvr)                         # $tmp = recvr
+            cache_recvr = s(:lvasgn, recvr_tmp, recvr) # $tmp = recvr
             recvr = s(:js_tmp, recvr_tmp)
           end
 
           writer_method = :"#{reader_method}="
 
-          call_reader = lhs.updated(:send, [recvr, reader_method, *args])      # $tmp.meth
-          call_op = s(:send, call_reader, op, rhs) # $tmp.meth + rhs
+          call_reader = lhs.updated(:send, [recvr, reader_method, *args])          # $tmp.meth
+          call_op = s(:send, call_reader, operation, rhs)                          # $tmp.meth + rhs
           call_writer = lhs.updated(:send, [recvr, writer_method, *args, call_op]) # $tmp.meth = $tmp.meth + rhs
 
           if cache_recvr
@@ -79,24 +78,25 @@ module Opal
       #   NOTE: Later output of this handler gets post-processed by this rewriter again
       #   using SendHandler to `recvr.nil? ? nil : (recvr.meth = recvr.meth + rhs)`
       class ConditionalSendHandler < self
-        def self.call(lhs, op, rhs)
+        def self.call(lhs, operation, rhs)
           recvr, meth, *args = *lhs
 
           recvr_tmp = new_temp
-          cache_recvr = s(:lvasgn, recvr_tmp, recvr)          # $tmp = recvr
+          cache_recvr = s(:lvasgn, recvr_tmp, recvr) # $tmp = recvr
           recvr = s(:js_tmp, recvr_tmp)
 
-          recvr_is_nil = s(:send, recvr, :nil?)                 # recvr.nil?
-          plain_send = lhs.updated(:send, [recvr, meth, *args]) # recvr.meth
-          plain_op_asgn = s(:op_asgn, plain_send, op, rhs)      # recvr.meth += rhs
+          recvr_is_nil = s(:send, recvr, :nil?)                   # recvr.nil?
+          plain_send = lhs.updated(:send, [recvr, meth, *args])   # recvr.meth
+          plain_op_asgn = s(:op_asgn, plain_send, operation, rhs) # recvr.meth += rhs
 
           s(:begin,
             cache_recvr,
             s(:if, recvr_is_nil,                          # if recvr.nil?
               s(:nil),                                    #   nil
                                                           # else
-              plain_op_asgn))                             #   recvr.meth ||= rhs
-                                                          # end
+              plain_op_asgn                               #   recvr.meth ||= rhs
+            ),
+          )                                               # end
         end
       end
 
@@ -108,15 +108,15 @@ module Opal
         cvasgn: ClassVariableHandler,
         send:   SendHandler,
         csend:  ConditionalSendHandler
-      }
+      }.freeze
 
       # lhs += rhs
       def on_op_asgn(node)
         lhs, op, rhs = *node
 
         result = HANDLERS
-          .fetch(lhs.type) { raise NotImplementedError }
-          .call(lhs, op, rhs)
+                 .fetch(lhs.type) { error "cannot handle LHS type: #{lhs.type}" }
+                 .call(lhs, op, rhs)
 
         process(result)
       end

data/lib/opal/rewriters/block_to_iter.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'opal/rewriters/base'
 
 module Opal
@@ -9,7 +10,7 @@ module Opal
         iter_node = s(:iter, args, body)
         recvr.updated(
           nil,
-          recvr.children + [iter_node]
+          recvr.children + [iter_node],
         )
       end
     end

data/lib/opal/rewriters/break_finder.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'opal/rewriter'
 
 module Opal
@@ -18,6 +19,7 @@ module Opal
       end
 
       def stop_lookup(node)
+        # noop
       end
 
       # regular loops