opal 0.10.6 → 0.11.0.rc1

data/spec/lib/rewriters/explicit_writer_return_spec.rb

@@ -0,0 +1,186 @@
+require 'lib/spec_helper'
+
+describe Opal::Rewriters::ExplicitWriterReturn do
+  def s(type, *children)
+    ::Opal::AST::Node.new(type, children)
+  end
+
+  let(:rewriter) { Opal::Rewriters::ExplicitWriterReturn.new }
+  let(:processed) { rewriter.process(input) }
+
+  def expect_rewritten(sexp)
+    processed = rewriter.process(sexp)
+    expect(processed)
+  end
+
+  def expect_no_rewriting_for(sexp)
+    expect_rewritten(sexp).to eq(sexp)
+  end
+
+  let(:receiver) do
+    # self.a
+    s(:send, nil, :a)
+  end
+
+  let(:single_argument) do
+    # self.c
+    s(:send, nil, :c)
+  end
+
+  let(:multiple_arguments) do
+    # [self.d, self.e]
+    s(:array,
+      s(:send, nil, :d),
+      s(:send, nil, :e)
+    )
+  end
+
+  let(:constant_returner) do
+    # $writer[$writer.length - 1]
+    s(:jsattr,
+      s(:lvar, "$writer"),
+      s(:send, s(:jsattr, s(:lvar, "$writer"), s(:str, "length")), :-, s(:int, 1))
+    )
+  end
+
+  shared_examples 'always returns a temporary argument' do
+    it 'returns a temporary argument' do
+      expect(processed.children[2]).to eq(constant_returner)
+    end
+  end
+
+  describe 'rewriting a.b = c' do
+    let(:input) do
+      s(:send, receiver, :b=, single_argument)
+    end
+
+    it 'generates a temporary argument for a method argument' do
+      expect(processed.children[0]).to eq(
+        s(:lvasgn, "$writer", s(:array, single_argument))
+      )
+    end
+
+    it 'calls receiver with this temporary argument as a splat' do
+      expect(processed.children[1]).to eq(
+        s(:send, receiver, :b=,
+          s(:splat, s(:lvar, "$writer"))
+        )
+      )
+    end
+
+    include_examples 'always returns a temporary argument'
+  end
+
+  describe 'rewriting a.b = c, d' do
+    let(:input) do
+      s(:send, receiver, :b=, multiple_arguments)
+    end
+
+    it 'generates a temporary argument for array of method arguments' do
+      expect(processed.children[0]).to eq(
+        s(:lvasgn, "$writer", s(:array, multiple_arguments))
+      )
+    end
+
+    it 'calls receiver with this temporary argument as a splat' do
+      expect(processed.children[1]).to eq(
+        s(:send, receiver, :b=,
+          s(:splat, s(:lvar, "$writer"))
+        )
+      )
+    end
+
+    include_examples 'always returns a temporary argument'
+  end
+
+  describe "[]= method" do
+    let(:idx) { s(:send, nil, :b) }
+
+    describe 'rewriting a[b] = c' do
+      let(:input) do
+        s(:send, receiver, :[]=, idx, single_argument)
+      end
+
+      it 'generates a temporary argument for all passed method arguments' do
+        expect(processed.children[0]).to eq(
+          s(:lvasgn, "$writer", s(:array, idx, single_argument))
+        )
+      end
+
+      it 'calls receiver with this temporary argument as a splat' do
+        expect(processed.children[1]).to eq(
+          s(:send, receiver, :[]=,
+            s(:splat, s(:lvar, "$writer"))
+          )
+        )
+      end
+
+      include_examples 'always returns a temporary argument'
+    end
+
+    describe 'rewriting a[b] = c, d' do
+      let(:input) do
+        s(:send, receiver, :[]=, idx, multiple_arguments)
+      end
+
+      it 'generates a temporary argument for array of method arguments' do
+        expect(processed.children[0]).to eq(
+          s(:lvasgn, "$writer", s(:array, idx, multiple_arguments))
+        )
+      end
+
+      it 'calls receiver with this temporary argument as a splat' do
+        expect(processed.children[1]).to eq(
+          s(:send, receiver, :[]=,
+            s(:splat, s(:lvar, "$writer"))
+          )
+        )
+      end
+
+      include_examples 'always returns a temporary argument'
+    end
+  end
+
+  describe 'mass assignment' do
+    let(:input) do
+      # a, b = c, d
+      s(:masgn,
+        s(:mlhs,
+          s(:lvasgn, :a),
+          s(:lvasgn, :b)),
+        s(:array,
+          s(:send, nil, :c),
+          s(:send, nil, :d)))
+    end
+
+    it 'does not affect it' do
+      expect_no_rewriting_for(input)
+    end
+  end
+
+  describe '.JS. syntax' do
+    let(:input) do
+      # a.JS.b = c
+      s(:jscall,
+        s(:send, nil, :a), :b=,
+        s(:send, nil, :c))
+    end
+
+    it 'does not affect it' do
+      expect_no_rewriting_for(input)
+    end
+  end
+
+  describe '.JS[] syntax' do
+    let(:input) do
+      s(:jsattrasgn,
+        s(:send, nil, :a),
+        s(:sym, :b),
+        s(:send, nil, :c))
+    end
+
+    it 'does not affect it' do
+      expect_no_rewriting_for(input)
+    end
+  end
+end

data/spec/lib/rewriters/js_reserved_words_spec.rb

@@ -0,0 +1,116 @@
+require 'lib/spec_helper'
+
+describe Opal::Rewriters::JsReservedWords do
+  def s(type, *children)
+    ::Opal::AST::Node.new(type, children)
+  end
+
+  def expect_rewritten(sexp)
+    processed = Opal::Rewriters::JsReservedWords.new.process(sexp)
+    expect(processed)
+  end
+
+  def expect_no_rewriting_for(sexp)
+    expect_rewritten(sexp).to eq(sexp)
+  end
+
+  reserved_lvars = %i(
+    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
+
+    int byte char goto long final float short double native
+    throws boolean abstract volatile transient synchronized
+
+    NaN Infinity undefined
+  )
+
+  reserved_ivars = %i(
+    @constructor @displayName
+    @hasOwnProperty @valueOf
+    @__proto__ @__parent__
+    @__noSuchMethod__ @__count__
+  )
+
+  context 'reserved lvars' do
+    reserved_lvars.each do |lvar_name|
+      context 'as lvars' do
+        it "appends '$'" do
+          expect_rewritten(
+            s(:lvar, lvar_name)
+          ).to eq(
+            s(:lvar, :"#{lvar_name}$")
+          )
+
+          expect_rewritten(
+            s(:lvasgn, lvar_name, s(:int, 1))
+          ).to eq(
+            s(:lvasgn, :"#{lvar_name}$", s(:int, 1))
+          )
+        end
+      end
+
+      context 'as arguments' do
+        it "appends '$'" do
+          [:arg, :restarg, :blockarg, :shadowarg, :kwarg, :kwrestarg].each do |type|
+            expect_rewritten(
+              s(type, lvar_name)
+            ).to eq(
+              s(type, :"#{lvar_name}$")
+            )
+          end
+
+          [:optarg, :kwoptarg].each do |type|
+            expect_rewritten(
+              s(type, lvar_name, s(:nil))
+            ).to eq(
+              s(type, :"#{lvar_name}$", s(:nil))
+            )
+          end
+        end
+      end
+    end
+  end
+
+  context 'reserved ivars' do
+    reserved_ivars.each do |ivar_name|
+      it "appends '$' to :ivar #{ivar_name}" do
+        expect_rewritten(
+          s(:ivar, ivar_name)
+        ).to eq(
+          s(:ivar, :"#{ivar_name}$")
+        )
+      end
+
+      it "appends '$' to :ivasgn #{ivar_name}" do
+        expect_rewritten(
+          s(:ivasgn, ivar_name, s(:nil))
+        ).to eq(
+          s(:ivasgn, :"#{ivar_name}$", s(:nil))
+        )
+      end
+    end
+  end
+
+  context 'normal lvar name' do
+    it 'does not modify AST' do
+      expect_no_rewriting_for(s(:lvar, :a))
+      expect_no_rewriting_for(s(:lvasgn, :a))
+    end
+  end
+
+  context 'normal ivar name' do
+    it 'does not modify AST' do
+      [:arg, :restarg, :blockarg, :shadowarg, :kwarg, :kwrestarg].each do |type|
+        expect_no_rewriting_for(s(type, :a))
+      end
+
+      [:optarg, :kwoptarg].each do |type|
+        expect_no_rewriting_for(s(type, :a, s(:nil)))
+      end
+    end
+  end
+end

data/spec/lib/rewriters/logical_operator_assignment_spec.rb

@@ -0,0 +1,202 @@
+require 'lib/spec_helper'
+
+describe Opal::Rewriters::LogicalOperatorAssignment do
+  def s(type, *children)
+    ::Opal::AST::Node.new(type, children)
+  end
+
+  let(:rewriter) { Opal::Rewriters::LogicalOperatorAssignment.new }
+
+  def parse(source)
+    parser = Opal::Parser.default_parser
+    buffer = ::Parser::Source::Buffer.new('(eval)')
+    buffer.source = source
+    parser.parse(buffer)
+  end
+
+  def rewrite(ast)
+    rewriter.process(ast)
+  end
+
+  around(:each) do |e|
+    Opal::Rewriters::LogicalOperatorAssignment.reset_tmp_counter!
+    Opal::Rewriter.disable { e.run }
+  end
+  let(:cache_tmp_name) { :$logical_op_recvr_tmp_1 }
+  let(:cached) { s(:js_tmp, cache_tmp_name) }
+
+  shared_examples 'it rewrites' do |from, to|
+    it "rewrites #{from.inspect} to #{to.inspect}" do
+      input = parse(from)
+      rewritten = rewrite(input)
+      expected = parse(to)
+
+      expect(rewritten).to eq(expected)
+    end
+  end
+
+  context 'rewriting or_asgn and and_asgn nodes' do
+    context 'local variable' do
+      include_examples 'it rewrites', 'a = local; a ||= 1', 'a = local; a = a || 1'
+      include_examples 'it rewrites', 'a = local; a &&= 1', 'a = local; a = a && 1'
+    end
+
+    context 'instance variable' do
+      include_examples 'it rewrites', '@a ||= 1', '@a = @a || 1'
+      include_examples 'it rewrites', '@a &&= 1', '@a = @a && 1'
+    end
+
+    context 'constant' do
+      include_examples 'it rewrites', 'CONST ||= 1', 'CONST = CONST || 1'
+      include_examples 'it rewrites', 'CONST &&= 1', 'CONST = CONST && 1'
+    end
+
+    context 'global variable' do
+      include_examples 'it rewrites', '$g ||= 1', '$g = $g || 1'
+      include_examples 'it rewrites', '$g &&= 1', '$g = $g && 1'
+    end
+
+    context 'class variable' do
+      include_examples 'it rewrites', '@@a ||= 1', '@@a = @@a || 1'
+      include_examples 'it rewrites', '@@a &&= 1', '@@a = @@a && 1'
+    end
+
+    context 'simple method call' do
+      include_examples 'it rewrites', 'recvr = 1; recvr.meth ||= rhs', 'recvr = 1; recvr.meth || recvr.meth = rhs'
+      include_examples 'it rewrites', 'recvr = 1; recvr.meth &&= rhs', 'recvr = 1; recvr.meth && recvr.meth = rhs'
+    end
+
+    context '[] / []= method call' do
+      include_examples 'it rewrites', 'recvr = 1; recvr[idx] ||= rhs', 'recvr = 1; recvr[idx] || recvr[idx] = rhs'
+      include_examples 'it rewrites', 'recvr = 1; recvr[idx] &&= rhs', 'recvr = 1; recvr[idx] && recvr[idx] = rhs'
+    end
+
+    context '[] / []= method call with multiple arguments' do
+      include_examples 'it rewrites',
+        'recvr = 1; recvr[idx1, idx2] ||= rhs',
+          'recvr = 1; recvr[idx1, idx2] || recvr[idx1, idx2] = rhs'
+
+      include_examples 'it rewrites',
+        'recvr = 1; recvr[idx1, idx2] &&= rhs',
+          'recvr = 1; recvr[idx1, idx2] && recvr[idx1, idx2] = rhs'
+    end
+
+    context 'chain of method calls' do
+      it 'rewrites ||= by caching receiver to a temporary local variable' do
+        input = parse('recvr.a.b ||= rhs')
+        rewritten = rewrite(input)
+
+        expected = s(:begin,
+          s(:lvasgn, cache_tmp_name, parse('recvr.a')), # cached = recvr.a
+          s(:or,
+            s(:send, cached, :b),                       # cached.b
+            s(:send, cached, :b=, parse('rhs'))))       # cached.b = rhs
+
+        expect(rewritten).to eq(expected)
+      end
+
+      it 'rewrites &&= by caching receiver to a temporary local variable' do
+        input = parse('recvr.a.b &&= rhs')
+        rewritten = rewrite(input)
+
+        expected = s(:begin,
+          s(:lvasgn, cache_tmp_name, parse('recvr.a')), # cached = recvr.a
+          s(:and,
+            s(:send, cached, :b),                       # cached.b
+            s(:send, cached, :b=, parse('rhs'))))       # cached.b = rhs
+
+        expect(rewritten).to eq(expected)
+      end
+    end
+
+    context 'method call using safe nafigator' do
+      it 'rewrites ||= by caching receiver and rewriting it to if and or_asgn' do
+        input = parse('recvr&.meth ||= rhs')
+        rewritten = rewrite(input)
+
+        expected = s(:begin,
+          s(:lvasgn, cache_tmp_name, parse('recvr')), # cached = recvr
+          s(:if, s(:send, cached, :nil?),             # if cached.nil?
+            s(:nil),                                  #   nil
+                                                      # else
+            s(:or,
+              s(:send, cached, :meth),                #   cached.meth ||
+              s(:send, cached, :meth=, parse('rhs'))) #     cached.meth = rhs
+            )                                         # end
+          )
+
+        expect(rewritten).to eq(expected)
+      end
+
+      it 'rewrites &&= by caching receiver and rewriting it to if and or_asgn' do
+        input = parse('recvr&.meth &&= rhs')
+        rewritten = rewrite(input)
+
+        expected = s(:begin,
+          s(:lvasgn, cache_tmp_name, parse('recvr')), # cached = recvr
+          s(:if, s(:send, cached, :nil?),             # if cached.nil?
+            s(:nil),                                  #   nil
+                                                      # else
+            s(:and,
+              s(:send, cached, :meth),                #   cached.meth ||
+              s(:send, cached, :meth=, parse('rhs'))) #     cached.meth = rhs
+            )                                         # end
+          )
+
+        expect(rewritten).to eq(expected)
+      end
+    end
+  end
+
+  context 'rewriting defined?(or_asgn) and defined?(and_asgn)' do
+    context 'local variable' do
+      include_examples 'it rewrites', 'a = nil; defined?(a ||= 1)', 'a = nil; "assignment"'
+      include_examples 'it rewrites', 'a = nil; defined?(a &&= 1)', 'a = nil; "assignment"'
+    end
+
+    context 'instance variable' do
+      include_examples 'it rewrites', 'defined?(@a ||= 1)', %q("assignment")
+      include_examples 'it rewrites', 'defined?(@a &&= 1)', %q("assignment")
+    end
+
+    context 'constant' do
+      include_examples 'it rewrites', 'defined?(CONST ||= 1)', %q("assignment")
+      include_examples 'it rewrites', 'defined?(CONST &&= 1)', %q("assignment")
+    end
+
+    context 'global variable' do
+      include_examples 'it rewrites', 'defined?($g ||= 1)', %q("assignment")
+      include_examples 'it rewrites', 'defined?($g &&= 1)', %q("assignment")
+    end
+
+    context 'class variable' do
+      include_examples 'it rewrites', 'defined?(@@a ||= 1)', %q("assignment")
+      include_examples 'it rewrites', 'defined?(@@a &&= 1)', %q("assignment")
+    end
+
+    context 'simple method call' do
+      include_examples 'it rewrites', 'defined?(recvr.meth ||= rhs)', %q("assignment")
+      include_examples 'it rewrites', 'defined?(recvr.meth &&= rhs)', %q("assignment")
+    end
+
+    context '[] / []= method call' do
+      include_examples 'it rewrites', 'defined?(recvr[idx] ||= rhs)', %q("assignment")
+      include_examples 'it rewrites', 'defined?(recvr[idx] &&= rhs)', %q("assignment")
+    end
+
+    context '[] / []= method call with multiple arguments' do
+      include_examples 'it rewrites', 'defined?(recvr[idx1, idx2] ||= rhs)', %q("assignment")
+      include_examples 'it rewrites', 'defined?(recvr[idx1, idx2] &&= rhs)', %q("assignment")
+    end
+
+    context 'chain of method calls' do
+      include_examples 'it rewrites', 'defined?(recvr.a.b.c ||= rhs)', %q("assignment")
+      include_examples 'it rewrites', 'defined?(recvr.a.b.c &&= rhs)', %q("assignment")
+    end
+
+    context 'method call using safe nafigator' do
+      include_examples 'it rewrites', 'defined?(recvr&.meth ||= rhs)', %q("assignment")
+      include_examples 'it rewrites', 'defined?(recvr&.meth &&= rhs)', %q("assignment")
+    end
+  end
+end