opal 1.5.0 → 1.6.0.alpha1

data/lib/opal/nodes/top.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'pathname'
+require 'json'
 require 'opal/version'
 require 'opal/nodes/scope'
 
@@ -32,7 +33,9 @@ module Opal
           in_scope do
             line '"use strict";' if compiler.use_strict?
 
-            body_code = stmt(stmts)
+            body_code = in_closure(Closure::JS_FUNCTION | Closure::TOP) do
+              stmt(stmts)
+            end
             body_code = [body_code] unless body_code.is_a?(Array)
 
             if compiler.eval?
@@ -60,12 +63,18 @@ module Opal
           definition
           closing
         end
+
+        add_file_source_embed if compiler.enable_file_source_embed?
+      end
+
+      def module_name
+        Opal::Compiler.module_name(compiler.file).inspect
       end
 
       def definition
         if compiler.requirable?
-          unshift "Opal.modules[#{Opal::Compiler.module_name(compiler.file).inspect}] = "
-        elsif compiler.esm?
+          unshift "Opal.modules[#{module_name}] = "
+        elsif compiler.esm? && !compiler.no_export?
           unshift 'export default '
         end
       end
@@ -85,6 +94,14 @@ module Opal
       def closing
         if compiler.requirable?
           line "};\n"
+
+          if compiler.load?
+            # Opal.load normalizes the path, so that we can't
+            # require absolute paths from CLI. For other cases
+            # we can expect the module names to be normalized
+            # already.
+            line "Opal.load_normalized(#{module_name});"
+          end
         elsif compiler.eval?
           line "})(Opal, self);"
         else
@@ -109,7 +126,7 @@ module Opal
       end
 
       def add_used_helpers
-        compiler.helpers.to_a.each { |h| add_temp "$#{h} = Opal.#{h}" }
+        compiler.helpers.to_a.reverse_each { |h| prepend_scope_temp "$#{h} = Opal.#{h}" }
       end
 
       def compile_method_stubs
@@ -131,6 +148,12 @@ module Opal
       def version_comment
         "/* Generated by Opal #{Opal::VERSION} */"
       end
+
+      def add_file_source_embed
+        filename = compiler.file
+        source = compiler.source
+        unshift "Opal.file_sources[#{filename.to_json}] = #{source.to_json};\n"
+      end
     end
   end
 end

data/lib/opal/nodes/while.rb

@@ -12,20 +12,27 @@ module Opal
       def compile
         test_code = js_truthy(test)
 
-        with_temp do |redo_var|
-          compiler.in_while do
-            while_loop[:closure] = true if wrap_in_closure?
-            while_loop[:redo_var] = redo_var
+        @redo_var = scope.new_temp if uses_redo?
+
+        compiler.in_while do
+          while_loop[:closure] = true if wrap_in_closure?
+          while_loop[:redo_var] = @redo_var
+
+          in_closure(Closure::LOOP | Closure::JS_LOOP | (wrap_in_closure? ? Closure::JS_FUNCTION : 0)) do
+            in_closure(Closure::LOOP_INSIDE | Closure::JS_LOOP_INSIDE) do
+              line(indent { stmt(body) })
+            end
 
-            body_code = indent { stmt(body) }
             if uses_redo?
-              compile_with_redo(test_code, body_code, redo_var)
+              compile_with_redo(test_code)
             else
-              compile_without_redo(test_code, body_code)
+              compile_without_redo(test_code)
             end
           end
         end
 
+        scope.queue_temp(@redo_var) if uses_redo?
+
         if wrap_in_closure?
           if scope.await_encountered
             wrap '(await (async function() {', '; return nil; })())'
@@ -37,26 +44,27 @@ module Opal
 
       private
 
-      def compile_with_redo(test_code, body_code, redo_var)
-        push "#{redo_var} = false; "
-        compile_while(
-          [redo_var, " || ", test_code],
-          ["#{redo_var} = false;", body_code]
-        )
+      def compile_with_redo(test_code)
+        compile_while(test_code, "#{@redo_var} = false;")
       end
 
-      def compile_without_redo(test_code, body_code)
-        compile_while([test_code], [body_code])
+      def compile_without_redo(test_code)
+        compile_while(test_code)
       end
 
-      def compile_while(test_code, body_code)
-        push while_open, *test_code, while_close
-        indent { line(*body_code) }
+      def compile_while(test_code, redo_code = nil)
+        unshift redo_code if redo_code
+        unshift while_open, test_code, while_close
+        unshift redo_code if redo_code
         line '}'
       end
 
       def while_open
-        'while ('
+        if uses_redo?
+          redo_part = "#{@redo_var} || "
+        end
+
+        "while (#{redo_part}"
       end
 
       def while_close
@@ -64,7 +72,7 @@ module Opal
       end
 
       def uses_redo?
-        while_loop[:use_redo]
+        @sexp.meta[:has_redo]
       end
 
       def wrap_in_closure?
@@ -78,7 +86,11 @@ module Opal
       private
 
       def while_open
-        'while (!('
+        if uses_redo?
+          redo_part = "#{@redo_var} || "
+        end
+
+        "while (#{redo_part}!("
       end
 
       def while_close
@@ -91,10 +103,10 @@ module Opal
 
       private
 
-      def compile_while(test_code, body_code)
-        push "do {"
-        indent { line(*body_code) }
-        line "} ", while_open, *test_code, while_close
+      def compile_while(test_code, redo_code = nil)
+        unshift redo_code if redo_code
+        unshift "do {"
+        line "} ", while_open, test_code, while_close
       end
 
       def while_close
@@ -108,7 +120,11 @@ module Opal
       private
 
       def while_open
-        'while(!('
+        if uses_redo?
+          redo_part = "#{@redo_var} || "
+        end
+
+        "while (#{redo_part}!("
       end
 
       def while_close

data/lib/opal/nodes.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'opal/nodes/closure'
 require 'opal/nodes/base'
 require 'opal/nodes/literal'
 require 'opal/nodes/variables'

data/lib/opal/os.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Opal
+  module OS
+    module_function
+
+    def windows?
+      /bccwin|cygwin|djgpp|mingw|mswin|wince/.match?(RbConfig::CONFIG['host_os'])
+    end
+
+    def macos?
+      /darwin|mac os/.match?(RbConfig::CONFIG['host_os'])
+    end
+
+    def shellescape(str)
+      if windows?
+        '"' + str.gsub('"', '""') + '"'
+      else
+        str.shellescape
+      end
+    end
+
+    def env_sep
+      windows? ? ';' : ':'
+    end
+
+    def path_sep
+      windows? ? '\\' : '/'
+    end
+
+    def cmd_sep
+      windows? ? ' & ' : ' ; '
+    end
+
+    def dev_null
+      windows? ? 'NUL' : '/dev/null'
+    end
+
+    def bash_c(*commands)
+      cmd = if windows?
+              [
+                'bundle',
+                'exec',
+                'cmd',
+                '/c',
+              ]
+            else
+              [
+                'bundle',
+                'exec',
+                'bash',
+                '-c',
+              ]
+            end
+
+      cmd << commands.join(cmd_sep)
+    end
+  end
+end

data/lib/opal/rewriter.rb

@@ -15,6 +15,7 @@ require 'opal/rewriters/inline_args'
 require 'opal/rewriters/numblocks'
 require 'opal/rewriters/returnable_logic'
 require 'opal/rewriters/forward_args'
+require 'opal/rewriters/thrower_finder'
 
 module Opal
   class Rewriter
@@ -66,6 +67,7 @@ module Opal
     use Rewriters::DumpArgs
     use Rewriters::MlhsArgs
     use Rewriters::InlineArgs
+    use Rewriters::ThrowerFinder
 
     def initialize(sexp)
       @sexp = sexp

data/lib/opal/rewriters/returnable_logic.rb

@@ -21,6 +21,9 @@ module Opal
 
       def on_if(node)
         test, = *node.children
+
+        check_control_flow!(test)
+
         # The if_test metadata signifies that we don't care about the return value except if it's
         # truthy or falsy. And those tests will be carried out by the respective $truthy helper calls.
         test.meta[:if_test] = true if test
@@ -41,6 +44,8 @@ module Opal
       def on_or(node)
         lhs, rhs = *node.children
 
+        check_control_flow!(lhs)
+
         if node.meta[:if_test]
           # Let's forward the if_test to the lhs and rhs - since we don't care about the exact return
           # value of our or, we neither do care about a return value of our lhs or rhs.
@@ -58,6 +63,8 @@ module Opal
       def on_and(node)
         lhs, rhs = *node.children
 
+        check_control_flow!(lhs)
+
         if node.meta[:if_test]
           lhs.meta[:if_test] = rhs.meta[:if_test] = true
           out = process(node.updated(:if, [lhs, rhs, s(:false)]))
@@ -81,6 +88,13 @@ module Opal
 
       private
 
+      def check_control_flow!(node)
+        case node.type
+        when :break, :next, :redo, :retry, :return
+          error 'void value expression'
+        end
+      end
+
       def build_if_from_when(node, lhs, lhs_tmp, whens, els)
         first_when, *next_whens = *whens
 

data/lib/opal/rewriters/thrower_finder.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+# rubocop:disable Layout/EmptyLineBetweenDefs, Style/SingleLineMethods
+module Opal
+  module Rewriters
+    # ThrowerFinder attempts to track the presence of throwers, like
+    # break, redo, so we can make an informed guess in the early
+    # compilation phase before traversing other nodes whether we
+    # want to track a closure. Tracking a closure is often a deoptimizing
+    # step, so we want to get that knowledge earlier.
+    class ThrowerFinder < Opal::Rewriters::Base
+      def initialize
+        @break_stack = []
+        @redo_stack = []
+        @retry_stack = []
+        @rescue_else_stack = []
+      end
+
+      def on_break(node)
+        tracking(:break, @break_stack)
+        super
+      end
+
+      def on_redo(node)
+        tracking(:redo, @redo_stack)
+        super
+      end
+
+      def on_retry(node)
+        tracking(:retry, @retry_stack)
+        super
+      end
+
+      def on_iter(node)
+        pushing([@break_stack, node]) { super }
+      end
+
+      def on_loop(node, &block)
+        pushing([@redo_stack, node], [@break_stack, nil], &block)
+      end
+
+      def on_for(node);        on_loop(node) { super }; end
+      def on_while(node);      on_loop(node) { super }; end
+      def on_while_post(node); on_loop(node) { super }; end
+      def on_until(node);      on_loop(node) { super }; end
+      def on_until_post(node); on_loop(node) { super }; end
+
+      # ignore throwers inside defined
+      def on_defined(node)
+        pushing(
+          [@redo_stack, nil],
+          [@break_stack, nil],
+          [@retry_stack, nil]
+        ) { super }
+      end
+
+      # In Opal we handle rescue-else either in ensure or in
+      # rescue. If ensure is present, we handle it in ensure.
+      # Otherwise we handle it in rescue. ensure is always
+      # above a rescue. This logic is about tracking if a given
+      # ensure node should expect a rescue-else inside a
+      # rescue node.
+      def on_ensure(node)
+        pushing([@rescue_else_stack, node]) { super }
+      end
+
+      def on_rescue(node)
+        if node.children[1..-1].detect { |sexp| sexp && sexp.type != :resbody }
+          tracking(:rescue_else, @rescue_else_stack)
+        end
+
+        pushing([@rescue_else_stack, nil], [@retry_stack, node]) { super }
+      end
+
+      private
+
+      def pushing(*stacks)
+        stacks.each { |stack, node| stack.push(node) }
+        result = yield
+        stacks.map(&:first).each(&:pop)
+        result
+      end
+
+      def tracking(breaker, stack)
+        stack.last.meta[:"has_#{breaker}"] = true if stack.last
+      end
+    end
+  end
+end
+# rubocop:enable Layout/EmptyLineBetweenDefs, Style/SingleLineMethods

data/lib/opal/simple_server.rb

@@ -11,6 +11,8 @@ require 'opal/deprecations'
 #
 # @example (CLI)
 #   rackup -ropal -ropal/simple_server -b 'Opal.append_path("app"); run Opal::SimpleServer.new'
+#   ... or use the Server runner ...
+#   opal -Rserver app.rb
 class Opal::SimpleServer
   require 'set'
   require 'erb'
@@ -54,13 +56,16 @@ class Opal::SimpleServer
     ]
   end
 
-  def fetch_asset(path)
+  def builder(path)
     builder = Opal::Builder.new
     builder.build(path.gsub(/(\.(?:rb|js|opal))*\z/, ''))
+  end
+
+  def fetch_asset(path)
+    builder = self.builder(path)
     {
       data: builder.to_s,
-      map: builder.source_map,
-      source: builder.source_for(path),
+      map: builder.source_map
     }
   end
 
@@ -86,10 +91,11 @@ class Opal::SimpleServer
       <!doctype html>
       <html>
         <head>
-          <meta charset="utf8">
-          #{javascript_include_tag(main)}
+          <meta charset="utf-8">
         </head>
-        <body></body>
+        <body>
+          #{javascript_include_tag(main)}
+        </body>
       </html>
       HTML
     end

data/lib/opal/source_map/file.rb

@@ -51,7 +51,7 @@ class Opal::SourceMap::File
       # file: "out.js", # This is optional
       sourceRoot: source_root,
       sources: [file],
-      sourcesContent: [source.force_encoding('UTF-8')],
+      sourcesContent: [source.encoding == Encoding::UTF_8 ? source : source.encode('UTF-8', undef: :replace)],
       names: names,
       mappings: Opal::SourceMap::VLQ.encode_mappings(relative_mappings),
       # x_com_opalrb_original_lines: source.count("\n"),

data/lib/opal/source_map/map.rb

@@ -9,7 +9,15 @@ module Opal::SourceMap::Map
   end
 
   def to_json
-    to_h.to_json
+    map = to_h
+    map.to_json
+  rescue Encoding::UndefinedConversionError
+    map[:sections].each do |i|
+      i.to_json
+    rescue Encoding::UndefinedConversionError
+      map[:sections].delete(i)
+    end
+    map.to_json
   end
 
   def as_json(*)

data/lib/opal/util.rb

@@ -15,7 +15,7 @@ module Opal
     # @param str [String] string to minify
     # @return [String]
     def uglify(source, mangle: false)
-      sh "bin/yarn -s run terser -c #{'-m' if mangle}", data: source
+      sh "#{'ruby ' if Gem.win_platform?}bin/yarn -s run terser -c #{'-m' if mangle}", data: source
     end
 
     # Gzip code to check file size.

data/lib/opal/version.rb

@@ -3,5 +3,5 @@
 module Opal
   # WHEN RELEASING:
   # Remember to update RUBY_ENGINE_VERSION in opal/corelib/constants.rb too!
-  VERSION = '1.5.0'
+  VERSION = '1.6.0.alpha1'
 end