opal 0.5.5 → 0.6.0

data/spec/cli/parser/op_asgn2_spec.rb

@@ -0,0 +1,23 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe "op_asgn2" do
+  it "returns s(:op_asgn2)" do
+    parsed('self.foo += 1')[0].should == :op_asgn2
+  end
+
+  it "correctly assigns the receiver" do
+    parsed("self.foo += 1")[1].should == [:self]
+  end
+
+  it "appends '=' onto the identifier in the sexp" do
+    parsed("self.foo += 1")[2].should == :foo=
+  end
+
+  it "only uses the operator, not with '=' appended" do
+    parsed("self.foo += 1")[3].should == :+
+  end
+
+  it "uses a simple sexp, not an arglist" do
+    parsed("self.foo += 1")[4].should == [:int, 1]
+  end
+end

data/spec/cli/parser/or_spec.rb

@@ -0,0 +1,13 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe "The or statement" do
+  it "should always return s(:or)" do
+    parsed("1 or 2").should == [:or, [:int, 1], [:int, 2]]
+  end
+end
+
+describe "The || expression" do
+  it "should always return s(:or)" do
+    parsed("1 || 2").should == [:or, [:int, 1], [:int, 2]]
+  end
+end

data/spec/cli/parser/return_spec.rb

@@ -0,0 +1,17 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe "The return keyword" do
+  it "should return s(:return) when given no arguments" do
+    parsed("return").should == [:return]
+  end
+
+  it "returns s(:return) with the direct argument when given one argument" do
+    parsed("return 1").should == [:return, [:int, 1]]
+    parsed("return *2").should == [:return, [:splat, [:int, 2]]]
+  end
+
+  it "returns s(:return) with an s(:array) when args size > 1" do
+    parsed("return 1, 2").should == [:return, [:array, [:int, 1], [:int, 2]]]
+    parsed("return 1, *2").should == [:return, [:array, [:int, 1], [:splat, [:int, 2]]]]
+  end
+end

data/spec/cli/parser/sclass_spec.rb

@@ -0,0 +1,21 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe "Singleton classes" do
+  it "returns an empty s(:block) when given an empty body" do
+    parsed('class << A; end')[2].should == [:block]
+  end
+
+  it "does not place single expressions into an s(:block)" do
+    parsed('class << A; 1; end')[2].should == [:int, 1]
+  end
+
+  it "adds multiple body expressions into a s(:block)" do
+    parsed('class << A; 1; 2; end')[2].should == [:block, [:int, 1], [:int, 2]]
+  end
+
+  it "should accept any expressions for singleton part" do
+    parsed('class << A; end').should == [:sclass, [:const, :A], [:block]]
+    parsed('class << self; end').should == [:sclass, [:self], [:block]]
+  end
+end
+

data/spec/cli/parser/string_spec.rb

@@ -0,0 +1,269 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe "Strings" do
+  it "parses empty strings" do
+    parsed('""').should == [:str, ""]
+    parsed("''").should == [:str, ""]
+  end
+
+  it "parses a simple string without interpolation as s(:str)" do
+    parsed('"foo # { } bar"').should == [:str, "foo # { } bar"]
+  end
+
+  it "does not interpolate with single quotes" do
+    parsed("'\#{foo}'").should == [:str, "\#{foo}"]
+    parsed("'\#@foo'").should == [:str, "\#@foo"]
+    parsed("'\#$foo'").should == [:str, "\#$foo"]
+    parsed("'\#@@foo'").should == [:str, "\#@@foo"]
+  end
+
+  it "supports interpolation with double quotes" do
+    parsed('"#{foo}"').should == [:dstr, "", [:evstr, [:call, nil, :foo, [:arglist]]]]
+    parsed('"#@foo"').should == [:dstr, "", [:evstr, [:ivar, :@foo]]]
+    parsed('"#$foo"').should == [:dstr, "", [:evstr, [:gvar, :$foo]]]
+    parsed('"#@@foo"').should == [:dstr, "", [:evstr, [:cvar, :@@foo]]]
+  end
+
+  it "allows underscores in ivar, gvar and cvar interpolation" do
+    parsed('"#@foo_bar"').should == [:dstr, "", [:evstr, [:ivar, :@foo_bar]]]
+    parsed('"#$foo_bar"').should == [:dstr, "", [:evstr, [:gvar, :$foo_bar]]]
+    parsed('"#@@foo_bar"').should == [:dstr, "", [:evstr, [:cvar, :@@foo_bar]]]
+  end
+
+  describe "from %Q construction" do
+    it "can use '[', '(', '{' or '<' matching pairs for string boundry" do
+      parsed('%Q{foo}').should == [:str, "foo"]
+      parsed('%Q[foo]').should == [:str, "foo"]
+      parsed('%Q(foo)').should == [:str, "foo"]
+      parsed('%Q<foo>').should == [:str, "foo"]
+    end
+
+    it "can use valid characters as string boundrys" do
+      parsed('%q!Ford!').should == [:str, 'Ford']
+      parsed('%qaForda').should == [:str, 'Ford']
+      parsed('%q?Ford?').should == [:str, 'Ford']
+    end
+
+    it "can parse empty strings" do
+      parsed('%Q{}').should == [:str, ""]
+      parsed('%Q[]').should == [:str, ""]
+      parsed('%Q()').should == [:str, ""]
+    end
+
+    it "should allow interpolation" do
+      parsed('%Q(#{foo})').should == [:dstr, "", [:evstr, [:call, nil, :foo, [:arglist]]]]
+      parsed('%Q[#{foo}]').should == [:dstr, "", [:evstr, [:call, nil, :foo, [:arglist]]]]
+      parsed('%Q{#{foo}}').should == [:dstr, "", [:evstr, [:call, nil, :foo, [:arglist]]]]
+    end
+
+    it "should allow ivar, gvar and cvar interpolation" do
+      parsed('%Q{#@foo}').should == [:dstr, "", [:evstr, [:ivar, :@foo]]]
+      parsed('%Q{#$foo}').should == [:dstr, "", [:evstr, [:gvar, :$foo]]]
+      parsed('%Q{#@@foo}').should == [:dstr, "", [:evstr, [:cvar, :@@foo]]]
+    end
+
+    it "should match '{' and '}' pairs used to start string before ending match" do
+      parsed('%Q{{}}').should == [:str, "{}"]
+      parsed('%Q{foo{bar}baz}').should == [:str, "foo{bar}baz"]
+      parsed('%Q{{foo}bar}').should == [:str, "{foo}bar"]
+      parsed('%Q{foo{bar}}').should == [:str, "foo{bar}"]
+      parsed('%Q{foo#{bar}baz}').should == [:dstr, "foo", [:evstr, [:call, nil, :bar, [:arglist]]], [:str, "baz"]]
+      parsed('%Q{a{b{c}d{e}f}g}').should == [:str, "a{b{c}d{e}f}g"]
+      parsed('%Q{a{b{c}#{foo}d}e}').should == [:dstr, "a{b{c}", [:evstr, [:call, nil, :foo, [:arglist]]], [:str, "d}e"]]
+    end
+
+    it "should match '(' and ')' pairs used to start string before ending match" do
+      parsed('%Q(())').should == [:str, "()"]
+      parsed('%Q(foo(bar)baz)').should == [:str, "foo(bar)baz"]
+      parsed('%Q((foo)bar)').should == [:str, "(foo)bar"]
+      parsed('%Q(foo(bar))').should == [:str, "foo(bar)"]
+      parsed('%Q(foo#{bar}baz)').should == [:dstr, "foo", [:evstr, [:call, nil, :bar, [:arglist]]], [:str, "baz"]]
+      parsed('%Q(a(b(c)d(e)f)g)').should == [:str, "a(b(c)d(e)f)g"]
+      parsed('%Q(a(b(c)#{foo}d)e)').should == [:dstr, "a(b(c)", [:evstr, [:call, nil, :foo, [:arglist]]], [:str, "d)e"]]
+    end
+
+    it "should match '[' and ']' pairs used to start string before ending match" do
+      parsed('%Q[[]]').should == [:str, "[]"]
+      parsed('%Q[foo[bar]baz]').should == [:str, "foo[bar]baz"]
+      parsed('%Q[[foo]bar]').should == [:str, "[foo]bar"]
+      parsed('%Q[foo[bar]]').should == [:str, "foo[bar]"]
+      parsed('%Q[foo#{bar}baz]').should == [:dstr, "foo", [:evstr, [:call, nil, :bar, [:arglist]]], [:str, "baz"]]
+      parsed('%Q[a[b[c]d[e]f]g]').should == [:str, "a[b[c]d[e]f]g"]
+      parsed('%Q[a[b[c]#{foo}d]e]').should == [:dstr, "a[b[c]", [:evstr, [:call, nil, :foo, [:arglist]]], [:str, "d]e"]]
+    end
+
+    it "correctly parses block braces within interpolations" do
+      parsed('%Q{#{each { nil } }}').should == [:dstr, "", [:evstr, [:call, nil, :each, [:arglist], [:iter, nil, [:nil]]]]]
+    end
+
+    it "parses other Qstrings within interpolations" do
+      parsed('%Q{#{ %Q{} }}').should == [:dstr, "", [:evstr, [:str, ""]]]
+    end
+  end
+
+  describe "from character shortcuts" do
+    it "produces a string sexp" do
+      parsed("?a").should == [:str, "a"]
+      parsed("?&").should == [:str, "&"]
+    end
+
+    it "parses escape sequences" do
+      parsed("?\\n").should == [:str, "\n"]
+      parsed("?\\t").should == [:str, "\t"]
+    end
+
+    it "parses a string sexp as a command arg" do
+      parsed("foo ?a").should == [:call, nil, :foo, [:arglist, [:str, "a"]]]
+    end
+  end
+
+  it "parses %[] strings" do
+    parsed('%[]').should == [:str, '']
+    parsed('%[foo]').should == [:str, 'foo']
+  end
+end
+
+
+describe "x-strings" do
+  it "parses simple xstring as s(:xstr)" do
+    parsed("`foo`").should == [:xstr, "foo"]
+  end
+
+  it "parses new lines within xstring" do
+    parsed("`\nfoo\n\nbar`").should == [:xstr, "\nfoo\n\nbar"]
+  end
+
+  it "allows interpolation within xstring" do
+    parsed('`#{bar}`').should == [:dxstr, "", [:evstr, [:call, nil, :bar, [:arglist]]]]
+    parsed('`#{bar}#{baz}`').should == [:dxstr, "", [:evstr, [:call, nil, :bar, [:arglist]]], [:evstr, [:call, nil, :baz, [:arglist]]]]
+  end
+
+  it "supports ivar interpolation" do
+    parsed('`#@foo`').should == [:dxstr, "", [:evstr, [:ivar, :@foo]]]
+    parsed('`#@foo.bar`').should == [:dxstr, "", [:evstr, [:ivar, :@foo]], [:str, ".bar"]]
+  end
+
+  it "supports gvar interpolation" do
+    parsed('`#$foo`').should == [:dxstr, "", [:evstr, [:gvar, :$foo]]]
+    parsed('`#$foo.bar`').should == [:dxstr, "", [:evstr, [:gvar, :$foo]], [:str, ".bar"]]
+  end
+
+  it "supports cvar interpolation" do
+    parsed('`#@@foo`').should == [:dxstr, "", [:evstr, [:cvar, :@@foo]]]
+  end
+
+  it "correctly parses block braces within interpolations" do
+    parsed('`#{ each { nil } }`').should == [:dxstr, "", [:evstr, [:call, nil, :each, [:arglist], [:iter, nil, [:nil]]]]]
+  end
+
+  it "parses xstrings within interpolations" do
+    parsed('`#{ `bar` }`').should == [:dxstr, "", [:evstr, [:xstr, "bar"]]]
+  end
+
+  it "parses multiple levels of interpolation" do
+    parsed('`#{ `#{`bar`}` }`').should == [:dxstr, "", [:evstr, [:dxstr, "", [:evstr, [:xstr, "bar"]]]]]
+  end
+
+  describe "created using %x notation" do
+    it "can use '[', '(' or '{' matching pairs for string boundry" do
+      parsed('%x{foo}').should == [:xstr, "foo"]
+      parsed('%x[foo]').should == [:xstr, "foo"]
+      parsed('%x(foo)').should == [:xstr, "foo"]
+    end
+
+    it "can parse empty strings" do
+      parsed('%x{}').should == [:xstr, ""]
+      parsed('%x[]').should == [:xstr, ""]
+      parsed('%x()').should == [:xstr, ""]
+    end
+
+    it "should allow interpolation" do
+      parsed('%x{#{foo}}').should == [:dxstr, "", [:evstr, [:call, nil, :foo, [:arglist]]]]
+      parsed('%x[#{foo}]').should == [:dxstr, "", [:evstr, [:call, nil, :foo, [:arglist]]]]
+      parsed('%x(#{foo})').should == [:dxstr, "", [:evstr, [:call, nil, :foo, [:arglist]]]]
+    end
+
+    it "should allow ivar, gvar and cvar interpolation" do
+      parsed('%x{#@foo}').should == [:dxstr, "", [:evstr, [:ivar, :@foo]]]
+      parsed('%x{#$foo}').should == [:dxstr, "", [:evstr, [:gvar, :$foo]]]
+      parsed('%x{#@@foo}').should == [:dxstr, "", [:evstr, [:cvar, :@@foo]]]
+    end
+
+    it "should match '{' and '}' pairs used to start string before ending match" do
+      parsed('%x{{}}').should == [:xstr, "{}"]
+      parsed('%x{foo{bar}baz}').should == [:xstr, "foo{bar}baz"]
+      parsed('%x{{foo}bar}').should == [:xstr, "{foo}bar"]
+      parsed('%x{foo{bar}}').should == [:xstr, "foo{bar}"]
+      parsed('%x{foo#{bar}baz}').should == [:dxstr, "foo", [:evstr, [:call, nil, :bar, [:arglist]]], [:str, "baz"]]
+      parsed('%x{a{b{c}d{e}f}g}').should == [:xstr, "a{b{c}d{e}f}g"]
+      parsed('%x{a{b{c}#{foo}d}e}').should == [:dxstr, "a{b{c}", [:evstr, [:call, nil, :foo, [:arglist]]], [:str, "d}e"]]
+    end
+
+    it "should match '(' and ')' pairs used to start string before ending match" do
+      parsed('%x(())').should == [:xstr, "()"]
+      parsed('%x(foo(bar)baz)').should == [:xstr, "foo(bar)baz"]
+      parsed('%x((foo)bar)').should == [:xstr, "(foo)bar"]
+      parsed('%x(foo(bar))').should == [:xstr, "foo(bar)"]
+      parsed('%x(foo#{bar}baz)').should == [:dxstr, "foo", [:evstr, [:call, nil, :bar, [:arglist]]], [:str, "baz"]]
+      parsed('%x(a(b(c)d(e)f)g)').should == [:xstr, "a(b(c)d(e)f)g"]
+      parsed('%x(a(b(c)#{foo}d)e)').should == [:dxstr, "a(b(c)", [:evstr, [:call, nil, :foo, [:arglist]]], [:str, "d)e"]]
+    end
+
+    it "should match '[' and ']' pairs used to start string before ending match" do
+      parsed('%x[[]]').should == [:xstr, "[]"]
+      parsed('%x[foo[bar]baz]').should == [:xstr, "foo[bar]baz"]
+      parsed('%x[[foo]bar]').should == [:xstr, "[foo]bar"]
+      parsed('%x[foo[bar]]').should == [:xstr, "foo[bar]"]
+      parsed('%x[foo#{bar}baz]').should == [:dxstr, "foo", [:evstr, [:call, nil, :bar, [:arglist]]], [:str, "baz"]]
+      parsed('%x[a[b[c]d[e]f]g]').should == [:xstr, "a[b[c]d[e]f]g"]
+      parsed('%x[a[b[c]#{foo}d]e]').should == [:dxstr, "a[b[c]", [:evstr, [:call, nil, :foo, [:arglist]]], [:str, "d]e"]]
+    end
+
+    it "correctly parses block braces within interpolations" do
+      parsed('%x{#{each { nil } }}').should == [:dxstr, "", [:evstr, [:call, nil, :each, [:arglist], [:iter, nil, [:nil]]]]]
+    end
+
+    it "parses other Xstrings within interpolations" do
+      parsed('%x{#{ %x{} }}').should == [:dxstr, "", [:evstr, [:xstr, ""]]]
+      parsed('%x{#{ `` }}').should == [:dxstr, "", [:evstr, [:xstr, ""]]]
+      parsed('%x{#{ `foo` }}').should == [:dxstr, "", [:evstr, [:xstr, "foo"]]]
+    end
+  end
+
+  describe "cannot be created with %X notation" do
+    it "should not parse" do
+      lambda {
+        parsed('%X{}')
+      }.should raise_error(Exception)
+    end
+  end
+end
+
+describe "Heredocs" do
+
+  it "parses as a s(:str)" do
+    parsed("a = <<-FOO\nbar\nFOO")[2].should == [:str, "bar\n"]
+  end
+
+  it "allows start marker to be wrapped in quotes" do
+    parsed("a = <<-'FOO'\nbar\nFOO")[2].should == [:str, "bar\n"]
+    parsed("a = <<-\"FOO\"\nbar\nFOO")[2].should == [:str, "bar\n"]
+  end
+
+  it "does not parse EOS unless beginning of line" do
+    parsed("<<-FOO\ncontentFOO\nFOO").should == [:str, "contentFOO\n"]
+  end
+
+  it "does not parse EOS unless end of line" do
+    parsed("<<-FOO\nsome FOO content\nFOO").should == [:str, "some FOO content\n"]
+  end
+
+  it "parses postfix code as if it appeared after heredoc" do
+    parsed("<<-FOO.class\ncode\nFOO").should == [:call, [:str, "code\n"], :class, [:arglist]]
+    parsed("bar(<<-FOO, 1, 2, 3)\ncode\nFOO").should == [:call, nil, :bar,
+                                                              [:arglist, [:str, "code\n"],
+                                                                         [:int, 1],
+                                                                         [:int, 2],
+                                                                         [:int, 3]]]
+  end
+end

data/spec/cli/parser/super_spec.rb

@@ -0,0 +1,20 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe "The super keyword" do
+  it "should return s(:super) for any arguments" do
+    parsed("super 1").should == [:super, [:arglist, [:int, 1]]]
+    parsed("super 1, 2").should == [:super, [:arglist, [:int, 1], [:int, 2]]]
+    parsed("super 1, *2").should == [:super, [:arglist, [:int, 1], [:splat, [:int, 2]]]]
+  end
+
+  it "should set nil for args when no arguments or parans" do
+    parsed("super").should == [:super, nil]
+  end
+
+  it "should always return s(:super) with :arglist when parans are used" do
+    parsed("super()").should == [:super, [:arglist]]
+    parsed("super(1)").should == [:super, [:arglist, [:int, 1]]]
+    parsed("super(1, 2)").should == [:super, [:arglist, [:int, 1], [:int, 2]]]
+    parsed("super(1, *2)").should == [:super, [:arglist, [:int, 1], [:splat, [:int, 2]]]]
+  end
+end

data/spec/cli/parser/undef_spec.rb

@@ -0,0 +1,15 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe "The undef keyword" do
+  it "returns s(:undef) with the argument as an s(:lit)" do
+    parsed("undef a").should == [:undef, [:sym, :a]]
+  end
+
+  it "appends multiple parts onto end of list" do
+    parsed("undef a, b").should == [:undef, [:sym, :a], [:sym, :b]]
+  end
+
+  it "can take symbols or fitems" do
+    parsed("undef :foo").should == [:undef, [:sym, :foo]]
+  end
+end

data/spec/cli/parser/unless_spec.rb

@@ -0,0 +1,13 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe "The unless keyword" do
+  it "returns s(:if) with reversed true and false bodies" do
+    parsed("unless 10; 20; end").should == [:if, [:int, 10], nil, [:int, 20]]
+    parsed("unless 10; 20; 30; end").should == [:if, [:int, 10], nil, [:block, [:int, 20], [:int, 30]]]
+    parsed("unless 10; 20; else; 30; end").should == [:if, [:int, 10], [:int, 30], [:int, 20]]
+  end
+
+  it "returns s(:if) with reversed true and false bodies for prefix unless" do
+    parsed("20 unless 10").should == [:if, [:int, 10], nil, [:int, 20]]
+  end
+end

data/spec/cli/parser/variables_spec.rb

@@ -0,0 +1,92 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe Opal::Parser do
+  it "parses instance variables" do
+    parsed("@a").should == [:ivar, :@a]
+    parsed("@A").should == [:ivar, :@A]
+    parsed("@class").should == [:ivar, :@class]
+  end
+
+  it "parses instance variable assignment" do
+    parsed("@a = 1").should == [:iasgn, :@a, [:int, 1]]
+    parsed("@A = 1").should == [:iasgn, :@A, [:int, 1]]
+    parsed("@class = 1").should == [:iasgn, :@class, [:int, 1]]
+  end
+
+  describe "parses local variables" do
+    it "should be created when an identifier is previously assigned to" do
+      parsed("a = 1; a").should == [:block, [:lasgn, :a, [:int, 1]], [:lvar, :a]]
+      parsed("a = 1; a; a").should == [:block, [:lasgn, :a, [:int, 1]], [:lvar, :a], [:lvar, :a]]
+    end
+
+    it "should not be created when no lasgn is previously used on name" do
+      parsed("a").should == [:call, nil, :a, [:arglist]]
+      parsed("a = 1; b").should == [:block, [:lasgn, :a, [:int, 1]], [:call, nil, :b, [:arglist]]]
+    end
+  end
+
+  describe "parses local variables inside a def" do
+    it "should created by a norm arg" do
+      parsed("def a(b); b; end").should == [:def, nil, :a, [:args, :b], [:block, [:lvar, :b]]]
+      parsed("def a(b, c); c; end").should == [:def, nil, :a, [:args, :b, :c], [:block, [:lvar, :c]]]
+    end
+
+    it "should be created by an opt arg" do
+      parsed("def a(b=10); b; end").should == [:def, nil, :a, [:args, :b, [:block, [:lasgn, :b, [:int, 10]]]], [:block, [:lvar, :b]]]
+    end
+
+    it "should be created by a rest arg" do
+      parsed("def a(*b); b; end").should == [:def, nil, :a, [:args, :"*b"], [:block, [:lvar, :b]]]
+    end
+
+    it "should be created by a block arg" do
+      parsed("def a(&b); b; end").should == [:def, nil, :a, [:args, :"&b"], [:block, [:lvar, :b]]]
+    end
+
+    it "should not be created from locals outside the def" do
+      parsed("a = 10; def b; a; end").should == [:block, [:lasgn, :a, [:int, 10]], [:def, nil, :b, [:args], [:block, [:call, nil, :a, [:arglist]]]]]
+    end
+  end
+
+  it "parses local var assignment" do
+    parsed("a = 1").should == [:lasgn, :a, [:int, 1]]
+    parsed("a = 1; b = 2").should == [:block, [:lasgn, :a, [:int, 1]], [:lasgn, :b, [:int, 2]]]
+  end
+
+  it "parses class variables" do
+    parsed("@@foo").should == [:cvar, :@@foo]
+  end
+
+  it "parses class variable assignment" do
+    parsed("@@foo = 100").should == [:cvdecl, :@@foo, [:int, 100]]
+  end
+
+  it "parses global variables" do
+    parsed("$foo").should == [:gvar, :$foo]
+    parsed("$:").should == [:gvar, :$:]
+  end
+
+  it "parses global var assignment" do
+    parsed("$foo = 1").should == [:gasgn, :$foo, [:int, 1]]
+    parsed("$: = 1").should == [:gasgn, :$:, [:int, 1]]
+  end
+
+  it "parses as s(:nth_ref)" do
+    parsed('$1').first.should == :nth_ref
+  end
+
+  it "references the number 1..9 as first part" do
+    parsed('$1').should == [:nth_ref, '1']
+    parsed('$9').should == [:nth_ref, '9']
+  end
+
+  it "parses constants" do
+    parsed("FOO").should == [:const, :FOO]
+    parsed("BAR").should == [:const, :BAR]
+  end
+
+  it "parses constant assignment" do
+    parsed("FOO = 1").should == [:cdecl, :FOO, [:int, 1]]
+    parsed("FOO = BAR").should == [:cdecl, :FOO, [:const, :BAR]]
+  end
+end