opal 0.10.6 → 0.11.0.rc1

data/lib/opal/path_reader.rb

@@ -1,7 +1,11 @@
+# frozen_string_literal: true
+require 'opal/regexp_anchors'
 require 'opal/hike_path_finder'
 
 module Opal
   class PathReader
+    RELATIVE_PATH_REGEXP = %r{#{Opal::REGEXP_START}\.?\.#{Regexp.quote File::SEPARATOR}}
+
     def initialize(file_finder = HikePathFinder.new)
       @file_finder = file_finder
     end
@@ -13,7 +17,7 @@ module Opal
     end
 
     def expand(path)
-      if Pathname.new(path).absolute? || path =~ %r{\A\.?\.#{File::SEPARATOR}}
+      if Pathname.new(path).absolute? || path =~ RELATIVE_PATH_REGEXP
         path
       else
         file_finder.find(path)

data/lib/opal/paths.rb

@@ -1,14 +1,15 @@
+# frozen_string_literal: true
 module Opal
   def self.gem_dir
-    File.expand_path('../..', __FILE__.untaint)
+    File.expand_path("../..", __FILE__.dup.untaint)
   end
 
   def self.core_dir
-    File.expand_path('../../../opal', __FILE__.untaint)
+    File.expand_path("../../../opal", __FILE__.dup.untaint)
   end
 
   def self.std_dir
-    File.expand_path('../../../stdlib', __FILE__.untaint)
+    File.expand_path("../../../stdlib", __FILE__.dup.untaint)
   end
 
   # Add a file path to opals load path. Any gem containing ruby code that Opal
@@ -66,9 +67,14 @@ module Opal
     @paths.dup.freeze
   end
 
-  # Resets Opal.paths to the default value (includes `corelib`, `stdlib`, `opal/lib`)
+  # Resets Opal.paths to the default value
+  # (includes `corelib`, `stdlib`, `opal/lib`, `ast` gem and `parser` gem)
   def self.reset_paths!
     @paths = [core_dir.untaint, std_dir.untaint, gem_dir.untaint]
+    if RUBY_ENGINE != 'opal'
+      use_gem 'ast'
+      use_gem 'parser'
+    end
     nil
   end
 

data/lib/opal/regexp_anchors.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Opal
   REGEXP_START = RUBY_ENGINE == 'opal' ? '^' : '\A'.freeze
   REGEXP_END = RUBY_ENGINE == 'opal' ? '$' : '\z'.freeze

data/lib/opal/rewriter.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+require 'opal/rewriters/opal_engine_check'
+require 'opal/rewriters/explicit_writer_return'
+require 'opal/rewriters/js_reserved_words'
+require 'opal/rewriters/block_to_iter'
+require 'opal/rewriters/dot_js_syntax'
+require 'opal/rewriters/logical_operator_assignment'
+require 'opal/rewriters/binary_operator_assignment'
+
+module Opal
+  class Rewriter
+    class << self
+      def list
+        @list ||= []
+      end
+
+      def use(rewriter)
+        list << rewriter
+      end
+
+      def delete(rewriter)
+        list.delete(rewriter)
+      end
+
+      def disable
+        @disabled = true
+        yield
+      ensure
+        @disabled = false
+      end
+
+      def disabled?
+        @disabled
+      end
+    end
+
+    use Rewriters::OpalEngineCheck
+    use Rewriters::BlockToIter
+    use Rewriters::DotJsSyntax
+    use Rewriters::JsReservedWords
+    use Rewriters::LogicalOperatorAssignment
+    use Rewriters::BinaryOperatorAssignment
+    use Rewriters::ExplicitWriterReturn
+
+    def initialize(sexp)
+      @sexp = sexp
+    end
+
+    def process
+      return @sexp if self.class.disabled?
+
+      self.class.list.each do |rewriter_class|
+        rewriter = rewriter_class.new
+        @sexp = rewriter.process(@sexp)
+      end
+
+      @sexp
+    end
+  end
+end

data/lib/opal/rewriters/base.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+require 'parser'
+require 'opal/ast/node'
+
+module Opal
+  module Rewriters
+    class Base < ::Parser::AST::Processor
+      def s(type, *children)
+        ::Opal::AST::Node.new(type, children)
+      end
+
+      def self.s(type, *children)
+        ::Opal::AST::Node.new(type, children)
+      end
+
+      alias on_iter process_regular_node
+      alias on_top  process_regular_node
+
+      # TODO: remove patches above after releasing
+      # https://github.com/whitequark/parser/commit/cd8d5db
+      def on_vasgn(node)
+        name, value_node = *node
+
+        if !value_node.nil?
+          node.updated(nil, [
+            name, process(value_node)
+          ])
+        else
+          node
+        end
+      end
+
+      def on_casgn(node)
+        scope_node, name, value_node = *node
+
+        if !value_node.nil?
+          node.updated(nil, [
+            process(scope_node), name, process(value_node)
+          ])
+        else
+          node.updated(nil, [
+            process(scope_node), name
+          ])
+        end
+      end
+
+      def on_argument(node)
+        arg_name, value_node = *node
+
+        if !value_node.nil?
+          node.updated(nil, [
+            arg_name, process(value_node)
+          ])
+        else
+          node
+        end
+      end
+    end
+  end
+end

data/lib/opal/rewriters/binary_operator_assignment.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+require 'opal/rewriters/base'
+
+module Opal
+  module Rewriters
+    class BinaryOperatorAssignment < Base
+      def self.reset_tmp_counter!
+        @@counter = 0
+      end
+
+      def self.new_temp
+        @@counter ||= 0
+        @@counter += 1
+        :"$binary_op_recvr_tmp_#{@@counter}"
+      end
+
+      GET_SET = ->(get_type, set_type) {
+
+        ->(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
+        }
+
+      }
+
+      # Takes    `lhs += rhs`
+      # Produces `lhs = lhs + rhs`
+      LocalVariableHandler = GET_SET[:lvar, :lvasgn]
+
+      # Takes    `@lhs += rhs`
+      # Produces `@lhs = @lhs + rhs`
+      InstanceVariableHandler = GET_SET[:ivar, :ivasgn]
+
+      # Takes    `LHS += rhs`
+      # Produces `LHS = LHS + rhs`
+      ConstantHandler = GET_SET[:const, :casgn]
+
+      # Takes    `$lhs += rhs`
+      # Produces `$lhs = $lhs + rhs`
+      GlobalVariableHandler = GET_SET[:gvar, :gvasgn]
+
+      # Takes    `@@lhs += rhs`
+      # Produces `@@lhs = @@lhs + rhs`
+      ClassVariableHandler = GET_SET[:cvar, :cvasgn]
+
+      # Takes    `recvr.meth += rhs`
+      # Produces `recvr.meth = recvr.meth + rhs`
+      # (lhs is a recvr.meth, op is :+)
+      class SendHandler < self
+        def self.call(lhs, op, 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
+            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_writer = lhs.updated(:send, [recvr, writer_method, *args, call_op]) # $tmp.meth = $tmp.meth + rhs
+
+          if cache_recvr
+            s(:begin, cache_recvr, call_writer)
+          else
+            call_writer
+          end
+        end
+      end
+
+      # Takes    `recvr.meth += rhs`
+      # Produces `recvr.nil? ? nil : recvr.meth += rhs`
+      #   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)
+          root_type = :op_asgn
+
+          recvr, meth, *args = *lhs
+
+          recvr_tmp = new_temp
+          cache_recvr = s(:lvasgn, recvr_tmp, recvr)          # $tmp = recvr
+          recvr = s(:js_tmp, recvr_tmp)
+
+          recvr_is_nil = s(:send, recvr, :nil?)                 # recvr.nil?
+          nil_node = s(:nil)                                    # nil
+          plain_send = lhs.updated(:send, [recvr, meth, *args]) # recvr.meth
+          plain_op_asgn = s(:op_asgn, plain_send, op, 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
+        end
+      end
+
+      HANDLERS = {
+        lvasgn: LocalVariableHandler,
+        ivasgn: InstanceVariableHandler,
+        casgn:  ConstantHandler,
+        gvasgn: GlobalVariableHandler,
+        cvasgn: ClassVariableHandler,
+        send:   SendHandler,
+        csend:  ConditionalSendHandler
+      }
+
+      # lhs += rhs
+      def on_op_asgn(node)
+        lhs, op, rhs = *node
+
+        result = HANDLERS
+          .fetch(lhs.type) { raise NotImplementedError }
+          .call(lhs, op, rhs)
+
+        process(result)
+      end
+
+      ASSIGNMENT_STRING_NODE = s(:str, 'assignment')
+
+      # Rewrites any or_asgn and and_asgn node like
+      #   `defined?(a ||= 1)`
+      # and
+      #   `defined?(a &&= 1)`
+      # to a static "assignment" string node
+      def on_defined?(node)
+        inner, _ = *node
+        if inner.type == :op_asgn
+          ASSIGNMENT_STRING_NODE
+        else
+          super(node)
+        end
+      end
+    end
+  end
+end

data/lib/opal/rewriters/block_to_iter.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+require 'opal/rewriters/base'
+
+module Opal
+  module Rewriters
+    class BlockToIter < Base
+      def on_block(node)
+        recvr, args, body = *super
+        iter_node = s(:iter, args, body)
+        recvr.updated(
+          nil,
+          recvr.children + [iter_node]
+        )
+      end
+    end
+  end
+end

data/lib/opal/rewriters/break_finder.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+require 'opal/rewriter'
+
+module Opal
+  module Rewriters
+    class BreakFinder < Opal::Rewriters::Base
+      def initialize
+        @found_break = false
+      end
+
+      def found_break?
+        @found_break
+      end
+
+      def on_break(node)
+        @found_break = true
+        node
+      end
+
+      def stop_lookup(node)
+      end
+
+      # regular loops
+      alias on_for        stop_lookup
+      alias on_while      stop_lookup
+      alias on_while_post stop_lookup
+      alias on_until      stop_lookup
+      alias on_until_post stop_lookup
+
+      # nested block
+      alias on_block      stop_lookup
+    end
+  end
+end

data/lib/opal/rewriters/dot_js_syntax.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+require 'opal/rewriters/base'
+
+module Opal
+  module Rewriters
+    class DotJsSyntax < Base
+      def on_send(node)
+        recv, meth, *args = *node
+        if recv && recv.type == :send
+          recv_of_recv, meth_of_recv, _ = *recv
+          if meth_of_recv == :JS
+            case meth
+            when :[]
+              if args.size != 1
+                raise SyntaxError, ".JS[:property] syntax supports only one argument"
+              end
+              property = args.first
+
+              node = to_js_attr_call(recv_of_recv, property)
+            when :[]=
+              if args.size != 2
+                raise SyntaxError, '.JS[:property]= syntax supports only two arguments'
+              end
+
+              property, value = *args
+              node = to_js_attr_assign_call(recv_of_recv, property, value)
+            else
+              node = to_native_js_call(recv_of_recv, meth, args)
+            end
+            super(node)
+          else
+            super
+          end
+        else
+          super
+        end
+      end
+
+      # @param recv [AST::Node] receiver of .JS. method
+      # @param meth [Symbol] name of the JS method
+      # @param args [Array<AST::Node>] list of the arguments passed to JS method
+      def to_native_js_call(recv, meth, args)
+        s(:jscall, recv, meth, *args)
+      end
+
+      # @param recv [AST::Node] receiver of .JS[] method
+      # @param property [AST::Node] argument passed to .JS[] method
+      def to_js_attr_call(recv, property)
+        s(:jsattr, recv, property)
+      end
+
+      # @param recv [AST::Node] receiver of .JS[]= method
+      # @param property [AST::Node] property passed to brackets
+      # @param value [AST::Node] value of assignment
+      def to_js_attr_assign_call(recv, property, value)
+        s(:jsattrasgn, recv, property, value)
+      end
+    end
+  end
+end

data/lib/opal/rewriters/explicit_writer_return.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+require 'opal/rewriters/base'
+
+module Opal
+  module Rewriters
+    class ExplicitWriterReturn < Base
+      def initialize
+        @in_masgn = false
+      end
+
+      TMP_NAME = '$writer'
+      GET_ARGS_NODE = s(:lvar, TMP_NAME)
+      RETURN_ARGS_NODE = s(:jsattr,
+        GET_ARGS_NODE,
+        s(:send, s(:jsattr, GET_ARGS_NODE, s(:str, 'length')), :-, s(:int, 1))
+      )
+
+      def on_send(node)
+        return super if @in_masgn
+
+        recv, method_name, *args = *node
+
+        if method_name.to_s =~ /#{REGEXP_START}\w+=#{REGEXP_END}/ || method_name.to_s == "[]="
+          set_args_node = s(:lvasgn, TMP_NAME, s(:array, *process_all(args)))
+
+          s(:begin,
+            set_args_node,
+            node.updated(nil, [recv, method_name, s(:splat, GET_ARGS_NODE)]),
+            RETURN_ARGS_NODE
+          )
+        else
+          super
+        end
+      end
+
+      # Multiple assignment is handled by Opal::Nodes::MassAssignNode
+      #
+      # For example, "self.a, self.b = 1, 2" parses to:
+      # s(:masgn,
+      #   s(:mlhs,
+      #     s(:send,
+      #       s(:self), :a=),
+      #     s(:send,
+      #       s(:self), :b=)),
+      #   s(:array,
+      #     s(:int, 1),
+      #     s(:int, 2)))
+      #
+      # And this AST rewriter skips this node.
+      def on_masgn(node)
+        @in_masgn = true
+        result = super
+        @in_masgn = false
+        result
+      end
+    end
+  end
+end