opal 1.4.1 → 1.5.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f199262b85612cb61bd3f3fa1d05ec8a7fb3fa6fabbd63a36baa03859e241c5c
-  data.tar.gz: e4af60acb540708612fbed3e4aa04fef968b750b0ff588774bda6d979586fc8f
+  metadata.gz: 6ac3c5ae91f1f31b94c292f0aed320bdba76511abd34bb6dc45294c11958e802
+  data.tar.gz: 473ca0893f427b05c88c64805dc0f64668816b263b136863b903f5262aba7aef
 SHA512:
-  metadata.gz: a4ece0468468bc541c155cb53185550f35b4277c89e18f32990a7bb8abff6c20beaeb9f962f02f80b1afc251a75c0916d35dd8d2944fa8153aa4a6454a7ddf8a
-  data.tar.gz: 81539b2993e44bfa8217cda753badaa292c26117de8366d04e50922309b95654f5c09f983a02f329b36ea1405affc52c3831c7122f4215a90e7a78c9084b9b31
+  metadata.gz: 5ba1e5223c56695db351ede10b36872590b29701f4576c9a1962502686434548d855d71fdd147e5b34492bb70964db72bed3229cc552dfa139a2db747dd4caa1
+  data.tar.gz: 30e97d6c8293b918084145f15cd9f42d6495989405d97ebbccc414440c281a8297405f651560e8a65ea21dda191631d9bd20fda058d5693af1c25b8b61cc1e40

data/.eslintrc.js

@@ -24,12 +24,14 @@ module.exports = {
     "no-control-regex": "off",
   },
   "globals": {
-    "Opal": "readonly",
-    "DataView": "readonly",
     "ArrayBuffer": "readonly",
+    "DataView": "readonly",
     "globalThis": "readonly",
-    "Uint8Array": "readonly",
+    "Opal": "readonly",
     "Promise": "readonly",
+    "Proxy": "readonly",
+    "Reflect": "readonly",
+    "Uint8Array": "readonly",
     "WeakRef": "readonly",
   }
 };

data/.rubocop.yml

@@ -365,6 +365,7 @@ Naming/FileName:
     - 'stdlib/opal-parser.rb'
     - 'stdlib/opal-platform.rb'
     - 'stdlib/opal-source-maps.rb'
+    - 'stdlib/opal-replutils.rb'
 
 Naming/ConstantName:
   Exclude:

data/UNRELEASED.md

@@ -1,8 +1,43 @@
-<!--
+### Added
+
+- Introduce timezone support for Time (#2394)
+- DateTime and Date refactor (#2398)
+- Implement `Number#prev_float`/`#next_float` (#2404)
+- Support `binding.irb` anywhere in the code, for both browsers and node (#2392)
+- Added `URI.decode_www_form` (#2387)
+
+### Changed
+
+- Move Math IE11-supporting polyfills to a separate file (#2395)
+- String methods always return Strings even when overloaded (#2413)
+- `alias` calls will not add the "old name" method to the list of stubs for method missing (#2414)
+- Optimize writer/setter methods, up to 4% performance gain (#2402)
+
+### Performance
+
+- Improve performance of argument coertion, fast-track `Integer`, `String`, and calling the designed coertion method (#2383)
+- Optimize `Array#[]=` by moving the implementation to JavaScript and inlining type checks (#2383)
+- Optimize internal runtime passing of block-options (#2383)
+- Compile `case` statements as `switch` whenever possible (#2411)
+- Improve performance with optimized common method/iter implementation shortcuts (#2401)
+
 ### Fixed
+
+- Fix `Regexp.new`, previously `\A` and `\z` didn't match beginning and end of input (#2079)
+- Fix exception during `Hash#each` and `Hash#each_key` if keys get deleted during the loop (#2403)
+- Fix defining multiple methods with the same block (#2397)
+- A few edge cases of conditional calls combined with setters, e.g. `foo&.bar = 123` (#2402)
+- Correct String#to_proc and method_missing compatibility (#2418)
+- Exit REPL respecting the exit status number (#2396)
+
+### Internal
+
+- Rewriters refactor, fix interaction between cache and inverted runner (#2400)
+
+<!--
+### Internal
 ### Changed
 ### Added
 ### Removed
 ### Deprecated
-### Internal
 -->

data/benchmark-ips/bm_js_symbols_vs_strings.rb

@@ -1,33 +1,58 @@
 Benchmark.ips do |x|
   %x{
+    const c_foo = 'foo'
+    const v_foo = 'foo'
+    const cfoo = Symbol('foo')
+    var vfoo = Symbol('foo')
+    const cgfoo = Symbol.for('foo')
+    var vgfoo = Symbol.for('foo')
+
     var o = {}
-    o[Symbol.for('foo')] = 123
-    o.foo = 123
-    var foo = Symbol('foo')
-    var gfoo = Symbol.for('foo')
-    o[foo] = 123
-    var a = 0, b = 0, c = 0
+    o[cfoo] = 1
+    o[cgfoo] = 1
+    o[c_foo] = 1
+    o[vfoo] = 1
+
+    let a1 = 0, a2 = 0, a3 = 0, a4 = 0, a5 = 0, a6 = 0, a7 = 0, a8 = 0
   }
 
+  x.report('const string ref') do
+    `a1 += o[c_foo]`
+  end
+
+  x.report('var string ref') do
+    `a2 += o[v_foo]`
+  end
+
   x.report('live global symbol') do
-    `a += o[Symbol.for('foo')]`
+    `a3 += o[Symbol.for('foo')]`
   end
 
-  x.report('stored global symbol') do
-    `a += o[gfoo]`
+  x.report('const global symbol') do
+    `a4 += o[cgfoo]`
   end
 
-  x.report('stored symbol') do
-    `a += o[foo]`
+  x.report('var global symbol') do
+    `a5 += o[vgfoo]`
+  end
+
+  x.report('const symbol') do
+    `a6 += o[cfoo]`
+  end
+
+  x.report('var symbol') do
+    `a6 += o[vfoo]`
   end
 
   x.report('ident') do
-    `b += o.foo`
+    `a7 += o.foo`
   end
 
-  x.report('string') do
-    `c += o['foo']`
+  x.report('live string') do
+    `a8 += o['foo']`
   end
 
+  x.time = 10
+
   x.compare!
 end

data/docs/releasing.md

@@ -10,8 +10,8 @@ _This guide is a work-in-progress._
 ## Updating the changelog
 
 - Ensure all the unreleased changes are documented in UNRELEASED.md
-- Run `bin/rake changelog VERSION=v1.2.3` specifying the version number you're about to release
-- Empty UNRELEASED.md
+- [skip for pre-releases] Run `bin/rake changelog VERSION=v1.2.3` specifying the version number you're about to release
+- [skip for pre-releases] Empty UNRELEASED.md
 
 ## The commit
 
@@ -34,3 +34,11 @@ _This guide is a work-in-progress._
 ## Opal CDN
 
 - Run `bin/release v1.2.3`
+
+## Prepare for the next release
+
+- Skip this step if releasing a stable release
+- Create a new pull request that:
+  - Updates a version to `v1.x.0.dev` in both `lib/opal/version.rb` and `opal/corelib/constants.rb`
+- Remember to merge that PR before merging anything else next once we decide to not release any more point releases from `master`.
+

data/lib/opal/ast/matcher.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require 'ast'
+require 'parser/ast/node'
+
+module Opal
+  module AST
+    class Matcher
+      def initialize(&block)
+        @root = instance_exec(&block)
+      end
+
+      def s(type, *children)
+        Node.new(type, children)
+      end
+
+      def cap(capture)
+        Node.new(:capture, [capture])
+      end
+
+      def match(ast)
+        @captures = []
+        @root.match(ast, self) || (return false)
+        @captures
+      end
+
+      def inspect
+        "#<Opal::AST::Matcher: #{@root.inspect}>"
+      end
+
+      attr_accessor :captures
+
+      Node = Struct.new(:type, :children) do
+        def match(ast, matcher)
+          return false if ast.nil?
+
+          ast_parts = [ast.type] + ast.children
+          self_parts = [type] + children
+
+          return false if ast_parts.length != self_parts.length
+
+          ast_parts.length.times.all? do |i|
+            ast_elem = ast_parts[i]
+            self_elem = self_parts[i]
+
+            if self_elem.is_a?(Node) && self_elem.type == :capture
+              capture = true
+              self_elem = self_elem.children.first
+            end
+
+            res = case self_elem
+                  when Node
+                    self_elem.match(ast_elem, matcher)
+                  when Array
+                    self_elem.include?(ast_elem)
+                  when :*
+                    true
+                  else
+                    self_elem == ast_elem
+                  end
+
+            matcher.captures << ast_elem if capture
+            res
+          end
+        end
+
+        def inspect
+          if type == :capture
+            "{#{children.first.inspect}}"
+          else
+            "s(#{type.inspect}, #{children.inspect[1..-2]})"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/opal/cache.rb

@@ -41,7 +41,7 @@ module Opal
 
       data || begin
                 compiler = yield
-                cache.set(key, compiler)
+                cache.set(key, compiler) unless compiler.dynamic_cache_result
                 compiler
               end
     end

data/lib/opal/cli_runners/applescript.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'opal/cli_runners/system_runner'
+
 module Opal
   module CliRunners
     class Applescript

data/lib/opal/compiler.rb

@@ -217,9 +217,16 @@ module Opal
     # Comments from the source code
     attr_reader :comments
 
+    # Method calls made in this file
+    attr_reader :method_calls
+
     # Magic comment flags extracted from the leading comments
     attr_reader :magic_comments
 
+    # Set if some rewritter caused a dynamic cache result, meaning it's not
+    # fit to be cached
+    attr_accessor :dynamic_cache_result
+
     def initialize(source, options = {})
       @source = source
       @indent = ''
@@ -227,8 +234,10 @@ module Opal
       @options = options
       @comments = Hash.new([])
       @case_stmt = nil
+      @method_calls = Set.new
       @option_values = {}
       @magic_comments = {}
+      @dynamic_cache_result = false
     end
 
     # Compile some ruby code to a string.
@@ -260,9 +269,12 @@ module Opal
                :main
              end
 
-      @sexp = s(:top, sexp || s(:nil)).tap { |i| i.meta[:kind] = kind }
-      @comments = ::Parser::Source::Comment.associate_locations(sexp, comments)
-      @magic_comments = MagicComments.parse(sexp, comments)
+      @sexp = sexp.tap { |i| i.meta[:kind] = kind }
+
+      first_node = sexp.children.first if sexp.children.first.location
+
+      @comments = ::Parser::Source::Comment.associate_locations(first_node, comments)
+      @magic_comments = MagicComments.parse(first_node, comments)
       @eof_content = EofContent.new(tokens, @source).eof
     end
 
@@ -287,9 +299,8 @@ module Opal
       )
     end
 
-    # Method calls made in this file
-    def method_calls
-      @method_calls ||= Set.new
+    def record_method_call(mid)
+      @method_calls << mid
     end
 
     alias async_await_before_typecasting async_await
@@ -353,9 +364,7 @@ module Opal
       @indent
     end
 
-    # Create a new sexp using the given parts. Even though this just
-    # returns an array, it must be used incase the internal structure
-    # of sexps does change.
+    # Create a new sexp using the given parts.
     def s(type, *children)
       ::Opal::AST::Node.new(type, children)
     end

data/lib/opal/nodes/call.rb

@@ -8,7 +8,7 @@ require 'opal/rewriters/break_finder'
 module Opal
   module Nodes
     class CallNode < Base
-      handle :send
+      handle :send, :csend
 
       attr_reader :recvr, :meth, :arglist, :iter
 
@@ -43,15 +43,19 @@ module Opal
         # handle some methods specially
         # some special methods need to skip compilation, so we pass the default as a block
         handle_special do
-          compiler.method_calls << meth.to_sym if record_method?
-
-          # if trying to access an lvar in eval or irb mode
-          return compile_eval_var if using_eval?
-
-          # if trying to access an lvar in irb mode
-          return compile_irb_var if using_irb?
-
-          default_compile
+          compiler.record_method_call meth
+
+          with_wrapper do
+            if using_eval?
+              # if trying to access an lvar in eval or irb mode
+              compile_eval_var
+            elsif using_irb?
+              # if trying to access an lvar in irb mode
+              compile_irb_var
+            else
+              default_compile
+            end
+          end
         end
       end
 
@@ -81,13 +85,18 @@ module Opal
       # to a method body. This is some kind of protection from method calls
       # like 'a(a {}) { 1 }'.
       def invoke_using_send?
-        iter || splat?
+        iter || splat? || call_is_writer_that_needs_handling?
       end
 
       def invoke_using_refinement?
         !scope.scope.collect_refinements_temps.empty?
       end
 
+      # Is it a conditional send, ie. `foo&.bar`?
+      def csend?
+        @sexp.type == :csend
+      end
+
       def default_compile
         if auto_await?
           push 'await '
@@ -143,17 +152,19 @@ module Opal
       end
 
       def compile_receiver
-        push recv(receiver_sexp)
+        push @conditional_recvr || recv(receiver_sexp)
       end
 
       def compile_method_name
         push ", '#{meth}'"
       end
 
-      def compile_arguments
-        push ', '
+      def compile_arguments(skip_comma = false)
+        push ', ' unless skip_comma
 
-        if splat?
+        if @with_writer_temp
+          push @with_writer_temp
+        elsif splat?
           push expr(arglist)
         elsif arglist.children.empty?
           push '[]'
@@ -197,16 +208,13 @@ module Opal
         mid_to_jsid meth.to_s
       end
 
-      def record_method?
-        true
-      end
-
       # Used to generate the code to use this sexp as an ivar var reference
       def compile_irb_var
         with_temp do |tmp|
           lvar = meth
           call = s(:send, s(:self), meth.intern, s(:arglist))
-          push "((#{tmp} = Opal.irb_vars.#{lvar}) == null ? ", expr(call), " : #{tmp})"
+          ref = "(typeof #{lvar} !== 'undefined') ? #{lvar} : "
+          push "((#{tmp} = Opal.irb_vars.#{lvar}) == null ? ", ref, expr(call), " : #{tmp})"
         end
       end
 
@@ -255,7 +263,7 @@ module Opal
           if invoke_using_refinement?
             compile_default.call
           elsif compiler.inline_operators?
-            compiler.method_calls << operator.to_sym if record_method?
+            compiler.record_method_call operator
             helper :"rb_#{name}"
             lhs, rhs = expr(recvr), expr(arglist)
 
@@ -414,13 +422,8 @@ module Opal
 
         scope.nesting
         push "Opal.Binding.$new("
-        push "  function($code, $value) {"
-        push "    if (typeof $value === 'undefined') {"
-        push "      return eval($code);"
-        push "    }"
-        push "    else {"
-        push "      return eval($code + ' = $value');"
-        push "    }"
+        push "  function($code) {"
+        push "    return eval($code);"
         push "  },"
         push "  ", scope.scope_locals.map(&:to_s).inspect, ","
         push "  ", scope.self, ","
@@ -450,6 +453,48 @@ module Opal
         )
       end
 
+      def with_wrapper(&block)
+        if csend? && !@conditional_recvr
+          handle_conditional_send do
+            with_wrapper(&block)
+          end
+        elsif call_is_writer_that_needs_handling?
+          handle_writer(&block)
+        else
+          yield
+        end
+      end
+
+      def call_is_writer_that_needs_handling?
+        (expr? || recv?) && (meth.to_s =~ /^\w+=$/ || meth == :[]=)
+      end
+
+      # Handle safe-operator calls: foo&.bar / foo&.bar ||= baz / ...
+      def handle_conditional_send
+        # temporary variable that stores method receiver
+        receiver_temp = scope.new_temp
+        push "#{receiver_temp} = ", expr(recvr)
+
+        # execute the sexp only if the receiver isn't nil
+        push ", (#{receiver_temp} === nil || #{receiver_temp} == null) ? nil : "
+        @conditional_recvr = receiver_temp
+        yield
+        wrap '(', ')'
+      end
+
+      def handle_writer
+        with_temp do |temp|
+          push "(#{temp} = "
+          compile_arguments(true)
+          push ", "
+          @with_writer_temp = temp
+          yield
+          @with_writer_temp = false
+          push ", "
+          push "#{temp}[#{temp}.length - 1])"
+        end
+      end
+
       class DependencyResolver
         def initialize(compiler, sexp, missing_dynamic_require = nil)
           @compiler = compiler

data/lib/opal/nodes/def.rb

@@ -10,6 +10,37 @@ module Opal
       children :mid, :inline_args, :stmts
 
       def compile
+        compile_body_or_shortcut
+
+        blockopts = []
+
+        blockopts << "$$arity: #{arity}"
+
+        if compiler.arity_check?
+          blockopts << "$$parameters: #{parameters_code}"
+        end
+
+        if compiler.parse_comments?
+          blockopts << "$$comments: #{comments_code}"
+        end
+
+        if compiler.enable_source_location?
+          blockopts << "$$source_location: #{source_location}"
+        end
+
+        if blockopts.length == 1
+          push ", #{arity}"
+        elsif blockopts.length > 1
+          push ', {', blockopts.join(', '), '}'
+        end
+
+        wrap_with_definition
+
+        scope.nesting if @define_nesting
+        scope.relative_access if @define_relative_access
+      end
+
+      def compile_body
         inline_params = nil
         scope_name = nil
 
@@ -51,33 +82,6 @@ module Opal
           unshift "async "
         end
         line '}'
-
-        blockopts = []
-
-        blockopts << "$$arity: #{arity}"
-
-        if compiler.arity_check?
-          blockopts << "$$parameters: #{parameters_code}"
-        end
-
-        if compiler.parse_comments?
-          blockopts << "$$comments: #{comments_code}"
-        end
-
-        if compiler.enable_source_location?
-          blockopts << "$$source_location: #{source_location}"
-        end
-
-        if blockopts.length == 1
-          push ", #{arity}"
-        elsif blockopts.length > 1
-          push ', {', blockopts.join(', '), '}'
-        end
-
-        wrap_with_definition
-
-        scope.nesting if @define_nesting
-        scope.relative_access if @define_relative_access
       end
 
       def wrap_with_definition

data/lib/opal/nodes/definitions.rb

@@ -31,6 +31,8 @@ module Opal
           push '$alias_gvar(', new_name_str, ', ', old_name_str, ')'
         when :dsym, :sym # This is a method alias: alias a b
           helper :alias
+          compiler.record_method_call old_name.children.last if old_name.type == :sym
+
           push "$alias(#{scope.self}, ", expr(new_name), ', ', expr(old_name), ')'
         else # Nothing else is available, but just in case, drop an error
           error "Opal doesn't know yet how to alias with #{new_name.type}"

data/lib/opal/nodes/helpers.rb

@@ -72,22 +72,22 @@ module Opal
             case mid
             when :==
               helper :eqeq
-              compiler.method_calls << mid
+              compiler.record_method_call mid
               [fragment('$eqeq('), expr(receiver), fragment(', '), expr(args.first), fragment(')')]
             when :===
               helper :eqeqeq
-              compiler.method_calls << mid
+              compiler.record_method_call mid
               [fragment('$eqeqeq('), expr(receiver), fragment(', '), expr(args.first), fragment(')')]
             when :!=
               helper :neqeq
-              compiler.method_calls << mid
+              compiler.record_method_call mid
               [fragment('$neqeq('), expr(receiver), fragment(', '), expr(args.first), fragment(')')]
             end
           elsif args.count == 0
             case mid
             when :!
               helper :not
-              compiler.method_calls << mid
+              compiler.record_method_call mid
               [fragment('$not('), expr(receiver), fragment(')')]
             end
           end
@@ -114,25 +114,6 @@ module Opal
           end
         end
       end
-
-      # Usefule for safe-operator calls: foo&.bar / foo&.bar ||= baz / ...
-      #
-      # @param recvr [sexp_pushable] The receiver of the call that will be
-      #        stored in a temporary variable
-      # @yields receiver_temp [String] the name of the temporary variable
-      #         holding the ref to the original receiver, inside the block
-      #         an expr() should be pushed.
-      #
-      def conditional_send(recvr)
-        # temporary variable that stores method receiver
-        receiver_temp = scope.new_temp
-        push "#{receiver_temp} = ", recvr
-
-        # execute the sexp only if the receiver isn't nil
-        push ", (#{receiver_temp} === nil || #{receiver_temp} == null) ? nil : "
-        yield receiver_temp
-        wrap '(', ')'
-      end
     end
   end
 end