laser 0.7.0.pre1

data/spec/analysis_specs/sexp_extension_specs/source_location_spec.rb

@@ -0,0 +1,231 @@
+require_relative 'spec_helper'
+
+describe Sexp do
+  describe '#source_begin/#source_end' do
+    # [:program,
+    #  [[:assign,
+    #    [:var_field, [:@ident, "arr", [1, 0]]],
+    #    [:mrhs_new_from_args,
+    #     [[:var_ref, [:@kw, "true", [1, 6]]],
+    #      [:var_ref, [:@kw, "nil", [1, 12]]],
+    #      [:@int, "314", [1, 17]],
+    #      [:@float, "4.155", [1, 22]],
+    #      [:@CHAR, "?x", [1, 29]],
+    #      [:regexp_literal,
+    #       [[:@tstring_content, "ac", [1, 34]]],
+    #       [:@regexp_end, "/ix", [1, 36]]],
+    #      [:string_literal,
+    #       [:string_content,
+    #        [:@tstring_content, "Abc", [1, 42]],
+    #        [:string_embexpr, [[:var_ref, [:@ident, "hi", [1, 47]]]]]]],
+    #      [:dyna_symbol,
+    #       [[:@tstring_content, "hello ", [1, 55]],
+    #        [:string_embexpr, [[:var_ref, [:@ident, "there", [1, 63]]]]]]]],
+    #     [:hash,
+    #      [:assoclist_from_args,
+    #       [[:assoc_new,
+    #         [:@label, "a:", [1, 74]],
+    #         [:symbol_literal, [:symbol, [:@ident, "b", [1, 78]]]]]]]]]]]]
+
+    it 'discovers the source begin location for a variety of literals and their containing nodes' do
+      input = 'arr = true, nil, 314, 4.155, ?x, /ac/ix, "Abc#{hi}", :"hello #{there}", { a: :b }'
+      tree = Sexp.new(Ripper.sexp(input), '(stdin)', input)
+      list = tree[1]
+
+      list[0][1][1].source_begin.should == [1, 0]
+      list[0][1].source_begin.should == [1, 0]
+      list[0].source_begin.should == [1, 0]
+
+      arglist = list[0][2]
+      arglist.source_begin.should == [1, 6]
+      args = arglist[1]
+      # true
+      args[0].source_begin.should == [1, 6]
+      args[0][1].source_begin.should == [1, 6]
+      # nil
+      args[1].source_begin.should == [1, 12]
+      args[1][1].source_begin.should == [1, 12]
+      # 314
+      args[2].source_begin.should == [1, 17]
+      # 4.155
+      args[3].source_begin.should == [1, 22]
+      # ?x
+      args[4].source_begin.should == [1, 29]
+      # /ac/ix
+      args[5].source_begin.should == [1, 33]
+      args[5][1].source_begin.should == [1, 34]
+      args[5][1][0].source_begin.should == [1, 34]
+      args[5][2].source_begin.should == [1, 36]
+      # "Abc#{hi}"
+      args[6].source_begin.should == [1, 41]
+      args[6][1].source_begin.should == [1, 42]
+      args[6][1][1].source_begin.should == [1, 42]
+      args[6][1][2].source_begin.should == [1, 45]
+      args[6][1][2][1].source_begin.should == [1, 47]
+      args[6][1][2][1][0].source_begin.should == [1, 47]
+      args[6][1][2][1][0][1].source_begin.should == [1, 47]
+      # :"hello #{there}"
+      args[7].source_begin.should == [1, 53]
+      args[7][1].source_begin.should == [1, 55]
+      args[7][1][0].source_begin.should == [1, 55]
+      args[7][1][1].source_begin.should == [1, 61]
+      args[7][1][1][1].source_begin.should == [1, 63]
+      args[7][1][1][1][0].source_begin.should == [1, 63]
+      args[7][1][1][1][0][1].source_begin.should == [1, 63]
+
+      # { a: :b }
+      hash = arglist[2]
+      hash.source_begin.should == [1, 72]
+      hash[1].source_begin.should == [1, 74]
+      hash[1][1].source_begin.should == [1, 74]
+      hash[1][1][0].source_begin.should == [1, 74]
+      hash[1][1][0][1].source_begin.should == [1, 74]
+      hash[1][1][0][2].source_begin.should == [1, 77]
+      hash[1][1][0][2][1].source_begin.should == [1, 78]
+      hash[1][1][0][2][1][1].source_begin.should == [1, 78]
+    end
+
+    # [:program,
+    #  [[:assign,
+    #    [:var_field, [:@ident, "arr", [1, 0]]],
+    #    [:mrhs_new_from_args,
+    #     [[:var_ref, [:@kw, "true", [1, 6]]],
+    #      [:var_ref, [:@kw, "nil", [1, 12]]],
+    #      [:@int, "314", [1, 17]],
+    #      [:@float, "4.155", [1, 22]],
+    #      [:@CHAR, "?x", [1, 29]],
+    #      [:regexp_literal,
+    #       [[:@tstring_content, "ac", [1, 34]]],
+    #       [:@regexp_end, "/ix", [1, 36]]],
+    #      [:string_literal,
+    #       [:string_content,
+    #        [:@tstring_content, "Abc", [1, 42]],
+    #        [:string_embexpr, [[:var_ref, [:@ident, "hi", [1, 47]]]]]]],
+    #      [:dyna_symbol,
+    #       [[:@tstring_content, "hello ", [1, 55]],
+    #        [:string_embexpr, [[:var_ref, [:@ident, "there", [1, 63]]]]]]]],
+    #     [:hash,
+    #      [:assoclist_from_args,
+    #       [[:assoc_new,
+    #         [:@label, "a:", [1, 74]],
+    #         [:symbol_literal, [:symbol, [:@ident, "b", [1, 78]]]]]]]]]]]]
+
+    it 'discovers the source end location for a variety of literals and their containing nodes' do
+      input = 'arr = true, nil, 314, 4.155, ?x, /ac/ix, "Abc#{hi}", :"hello #{there}", { a: :b }'
+      tree = Sexp.new(Ripper.sexp(input), '(stdin)', input)
+      list = tree[1]
+
+      list[0][1][1].source_end.should == [1, 3]
+      list[0][1].source_end.should == [1, 3]
+      list[0].source_end.should == [1, 81]  # requires that we get the hash right, which we don't. TODO(adgar)
+
+      arglist = list[0][2]
+      arglist.source_end.should == [1, 81]  # for all rhs, requires forward-tracking
+      args = arglist[1]
+      args[0].source_end.should == [1, 10]
+      args[0][1].source_end.should == [1, 10]
+      args[1].source_end.should == [1, 15]
+      args[1][1].source_end.should == [1, 15]
+      args[2].source_end.should == [1, 20]
+      args[3].source_end.should == [1, 27]
+      args[4].source_end.should == [1, 31]
+      args[5].source_end.should == [1, 39]
+      args[5][1].source_end.should == [1, 36]
+      args[5][1][0].source_end.should == [1, 36]
+      args[5][2].source_end.should == [1, 39]
+      args[6].source_end.should == [1, 51]
+      args[6][1].source_end.should == [1, 50]
+      args[6][1][1].source_end.should == [1, 45]
+      args[6][1][2].source_end.should == [1, 50]
+      args[6][1][2][1].source_end.should == [1, 49]
+      args[6][1][2][1][0].source_end.should == [1, 49]
+      args[6][1][2][1][0][1].source_end.should == [1, 49]
+      args[7].source_end.should == [1, 70]
+      args[7][1].source_end.should == [1, 69]
+      args[7][1][0].source_end.should == [1, 61]
+      args[7][1][1].source_end.should == [1, 69]
+      args[7][1][1][1].source_end.should == [1, 68]
+      args[7][1][1][1][0].source_end.should == [1, 68]
+      args[7][1][1][1][0][1].source_end.should == [1, 68]
+      # 
+      hash = arglist[2]
+      hash.source_end.should == [1, 81]
+      hash[1].source_end.should == [1, 79]
+      hash[1][1].source_end.should == [1, 79]
+      hash[1][1][0].source_end.should == [1, 79]
+      hash[1][1][0][1].source_end.should == [1, 76]
+      hash[1][1][0][2].source_end.should == [1, 79]
+      hash[1][1][0][2][1].source_end.should == [1, 79]
+      hash[1][1][0][2][1][1].source_end.should == [1, 79]
+    end
+
+    # [:program,
+    #  [[:assign,
+    #    [:var_field, [:@ident, "arr", [1, 0]]],
+    #    [:array, [[:@int, "1", [1, 8]], [:@int, "2", [2, 0]]]]]]]
+
+    it 'discovers the locations of array literals' do
+      input = "arr = [ 1, \n2 ]"
+      tree = Sexp.new(Ripper.sexp(input), '(stdin)', input)
+      assign = tree[1][0]
+      assign.source_begin.should == [1, 0]
+      assign[1].source_begin.should == [1, 0]
+      assign[1].source_end.should == [1, 3]
+      assign[2].source_begin.should == [1, 6]
+      assign[2].source_end.should == [2, 3]
+    end
+
+    # [:program,
+    #  [[:def,
+    #    [:@ident, "abc", [2, 0]],
+    #    [:params, nil, nil, nil, nil, nil],
+    #    [:bodystmt,
+    #     [[:assign, [:var_field, [:@ident, "x", [3, 2]]], [:@int, "10", [3, 6]]]],
+    #     nil, nil, nil]]]]
+    it 'discovers the locations of method definitons' do
+      input = " def \nabc\n  x = 10\n end"
+      tree = Sexp.new(Ripper.sexp(input), '(stdin)', input)
+      definition = tree[1][0]
+      definition.source_begin.should == [1, 1]
+    end
+
+    it 'discovers the locations of operator definitons' do
+      input = " def <=>(other)\n  x = 10\n end"
+      tree = Sexp.new(Ripper.sexp(input), '(stdin)', input)
+      definition = tree[1][0]
+      definition.source_begin.should == [1, 1]
+    end
+
+    it 'discovers the locations of singleton method definitons' do
+      input = " def \n self.abc\n  x = 10\n end"
+      tree = Sexp.new(Ripper.sexp(input), '(stdin)', input)
+      definition = tree[1][0]
+      definition.source_begin.should == [1, 1]
+    end
+
+    # [:program,
+    #  [[:class,
+    #    [:const_ref, [:@const, "A", [2, 0]]],
+    #    [:var_ref, [:@const, "B", [2, 4]]],
+    #    [:bodystmt,
+    #     [[:module,
+    #       [:const_ref, [:@const, "D", [4, 0]]],
+    #       [:bodystmt, [[:void_stmt]], nil, nil, nil]]],
+    #     nil, nil, nil]]]]
+    it 'discovers the locations of class and module definitons' do
+      input = "   class\nA < B; module\n\nD;end\n   end"
+      tree = Sexp.new(Ripper.sexp(input), '(stdin)', input)
+      klass = tree[1][0]
+      klass.source_begin.should == [1, 3]
+      klass[3][1][0].source_begin.should == [2, 7]
+    end
+
+    it 'discovers the locations of singleton class definitons' do
+      input = "   class\nA < B;   class <<\nB;end\n   end"
+      tree = Sexp.new(Ripper.sexp(input), '(stdin)', input)
+      klass = tree[1][0]
+      klass.source_begin.should == [1, 3]
+      klass[3][1][0].source_begin.should == [2, 9]
+    end
+  end
+end

data/spec/analysis_specs/sexp_extension_specs/spec_helper.rb

@@ -0,0 +1 @@
+require_relative '../spec_helper'

data/spec/analysis_specs/sexp_extension_specs/type_inference_spec.rb

@@ -0,0 +1,252 @@
+require_relative 'spec_helper'
+
+describe Sexp do
+  describe '#expr_type' do
+    # This is the AST that Ripper generates for the parsed code. It is
+    # provided here because otherwise the test is inscrutable.
+    #
+    # [:program,
+    # [[:assign,
+    #    [:var_field, [:@ident, "a", [1, 0]]], [:@int, "5", [1, 4]]]]]
+    it 'discovers the class for integer literals' do
+      tree = Sexp.new(Ripper.sexp('a = 5'))
+      list = tree[1]
+      list[0][2].expr_type.should == Types::ClassType.new('Integer', :covariant)
+    end
+
+    # This is the AST that Ripper generates for the parsed code. It is
+    # provided here because otherwise the test is inscrutable.
+    #
+    # [:program,
+    # [[:assign,
+    #   [:var_field, [:@ident, "a", [1, 0]]],
+    #   [:string_literal,
+    #    [:string_content,
+    #     [:@tstring_content, "abc = ", [1, 5]],
+    #     [:string_embexpr,
+    #      [[:binary,
+    #        [:var_ref, [:@ident, "run_method", [1, 13]]],
+    #        :-,
+    #        [:@int, "5", [1, 26]]]]]]]]]]
+    it 'discovers the class for nontrivial string literals' do
+      tree = Sexp.new(Ripper.sexp('a = "abc = #{run_method - 5}"'))
+      list = tree[1]
+      [list[0][2], list[0][2][1], list[0][2][1][1], list[0][2][1][2]].each do |entry|
+        entry.expr_type.should == Types::ClassType.new('String', :invariant)
+      end
+    end
+
+    # [:program,
+    # [[:assign,
+    #   [:var_field, [:@ident, "a", [1, 0]]],
+    #   [:xstring_literal, [[:@tstring_content, "find .", [1, 7]]]]]]]
+    it 'discovers the class for executed string literals' do
+      tree = Sexp.new(Ripper.sexp('a = %x(find .)'))
+      list = tree[1]
+      list[0][2].expr_type.should == Types::ClassType.new('String', :invariant)
+    end
+
+    # [:program,
+    #  [[:assign,
+    #     [:var_field, [:@ident, "a", [1, 0]]],
+    #     [:@CHAR, "?a", [1, 4]]]]]
+    it 'discovers the class for character literals' do
+      tree = Sexp.new(Ripper.sexp('a = ?a'))
+      list = tree[1]
+      list[0][2].expr_type.should == Types::ClassType.new('String', :invariant)
+    end
+
+    # [:program,
+    # [[:assign,
+    #    [:var_field, [:@ident, "x", [1, 0]]],
+    #    [:@float, "3.14", [1, 4]]]]]
+    it 'discovers the class for float literals' do
+      tree = Sexp.new(Ripper.sexp('x = 3.14'))
+      list = tree[1]
+      list[0][2].expr_type.should == Types::ClassType.new('Float', :invariant)
+    end
+
+    # [:program,
+    # [[:assign,
+    #   [:var_field, [:@ident, "x", [1, 0]]],
+    #   [:regexp_literal,
+    #    [[:@tstring_content, "abc", [1, 5]]],
+    #    [:@regexp_end, "/im", [1, 8]]]]]]
+    it 'discovers the class for regexp literals' do
+      tree = Sexp.new(Ripper.sexp('x = /abc/im'))
+      list = tree[1]
+      list[0][2].expr_type.should == Types::ClassType.new('Regexp', :invariant)
+    end
+
+    # [:program,
+    #  [[:assign,
+    #    [:var_field, [:@ident, "x", [1, 0]]],
+    #    [:array, [[:@int, "1", [1, 5]], [:@int, "2", [1, 8]]]]]]]
+    it 'discovers the class for array literals' do
+      tree = Sexp.new(Ripper.sexp('x = [1, 2]'))
+      list = tree[1]
+      list[0][2].expr_type.should == Types::ClassType.new('Array', :invariant)
+    end
+
+    # [:program,
+    #  [[:assign,
+    #    [:var_field, [:@ident, "x", [1, 0]]],
+    #    [:hash,
+    #     [:assoclist_from_args,
+    #      [[:assoc_new,
+    #        [:@label, "a:", [1, 5]],
+    #        [:symbol_literal, [:symbol, [:@ident, "b", [1, 9]]]]]]]]]]]
+    it 'discovers the class for hash literals' do
+      tree = Sexp.new(Ripper.sexp('x = {a: :b}'))
+      list = tree[1]
+      list[0][2].expr_type.should == Types::ClassType.new('Hash', :invariant)
+    end
+
+    # [:program,
+    #  [[:method_add_arg,
+    #    [:fcall, [:@ident, "p", [1, 0]]],
+    #    [:arg_paren,
+    #     [:args_add_block,
+    #      [[:bare_assoc_hash,
+    #        [[:assoc_new, [:@label, "a:", [1, 2]], [:@int, "3", [1, 5]]],
+    #         [:assoc_new, [:@label, "b:", [1, 8]], [:@int, "3", [1, 11]]]]]],
+    #      false]]]]]
+    it 'discovers the class for hash literals using the no-brace shorthand' do
+      tree = Sexp.new(Ripper.sexp('p(a: 3, b: 3)'))
+      list = tree[1]
+      list[0][2][1][1][0].expr_type.should == Types::ClassType.new('Hash', :invariant)
+    end
+
+    # [:program,
+    #  [[:assign,
+    #    [:var_field, [:@ident, "x", [1, 0]]],
+    #    [:symbol_literal, [:symbol, [:@ident, "abcdef", [1, 5]]]]]]]
+    it 'discovers the class for symbol literals' do
+      tree = Sexp.new(Ripper.sexp('x = :abcdef'))
+      list = tree[1]
+      list[0][2].expr_type.should == Types::ClassType.new('Symbol', :invariant)
+    end
+
+    # [:program,
+    #  [[:assign,
+    #    [:var_field, [:@ident, "x", [1, 0]]],
+    #    [:dyna_symbol,
+    #     [[:@tstring_content, "abc", [1, 6]],
+    #      [:string_embexpr, [[:var_ref, [:@ident, "xyz", [1, 11]]]]],
+    #      [:@tstring_content, "def", [1, 15]]]]]]]
+    it 'discovers the class for dynamic symbol literals' do
+      tree = Sexp.new(Ripper.sexp('x = :"abc{xyz}def"'))
+      list = tree[1]
+      list[0][2].expr_type.should == Types::ClassType.new('Symbol', :invariant)
+    end
+
+    # [:program,
+    #  [[:assign,
+    #    [:var_field, [:@ident, "x", [1, 0]]],
+    #    [:hash,
+    #     [:assoclist_from_args,
+    #      [[:assoc_new,
+    #        [:@label, "a:", [1, 5]],
+    #        [:symbol_literal, [:symbol, [:@ident, "b", [1, 9]]]]]]]]]]]
+    it 'discovers the class for the label-style symbols in Ruby 1.9' do
+      tree = Sexp.new(Ripper.sexp('x = {a: :b}'))
+      list = tree[1]
+      list[0][2][1][1][0][1].expr_type.should == Types::ClassType.new('Symbol', :invariant)
+    end
+
+    # [:program,
+    #  [[:assign,
+    #    [:var_field, [:@ident, "x", [1, 0]]],
+    #    [:var_ref, [:@kw, "true", [1, 4]]]]]]
+    it 'discovers the class for true' do
+      tree = Sexp.new(Ripper.sexp('x = true'))
+      list = tree[1]
+      list[0][2].expr_type.should == Types::ClassType.new('TrueClass', :invariant)
+    end
+
+    # [:program,
+    #  [[:assign,
+    #    [:var_field, [:@ident, "x", [1, 0]]],
+    #    [:var_ref, [:@kw, "false", [1, 4]]]]]]
+    it 'discovers the class for false' do
+      tree = Sexp.new(Ripper.sexp('x = false'))
+      list = tree[1]
+      list[0][2].expr_type.should == Types::ClassType.new('FalseClass', :invariant)
+    end
+
+    # [:program,
+    #  [[:assign,
+    #    [:var_field, [:@ident, "x", [1, 0]]],
+    #    [:var_ref, [:@kw, "nil", [1, 4]]]]]]
+    it 'discovers the class for nil' do
+      tree = Sexp.new(Ripper.sexp('x = nil'))
+      list = tree[1]
+      list[0][2].expr_type.should == Types::ClassType.new('NilClass', :invariant)
+    end
+
+    # [:program,
+    #  [[:assign,
+    #    [:var_field, [:@ident, "x", [1, 0]]],
+    #    [:var_ref, [:@kw, "__FILE__", [1, 4]]]]]]
+    it 'discovers the class for __FILE__' do
+      tree = Sexp.new(Ripper.sexp('x = __FILE__'))
+      list = tree[1]
+      list[0][2].expr_type.should == Types::ClassType.new('String', :invariant)
+    end
+
+    # [:program,
+    #  [[:assign,
+    #    [:var_field, [:@ident, "x", [1, 0]]],
+    #    [:var_ref, [:@kw, "__LINE__", [1, 4]]]]]]
+    it 'discovers the class for __LINE__' do
+      tree = Sexp.new(Ripper.sexp('x = __LINE__'))
+      list = tree[1]
+      list[0][2].expr_type.should == Types::ClassType.new('Fixnum', :invariant)
+    end
+
+
+    # [:program,
+    #  [[:assign,
+    #    [:var_field, [:@ident, "x", [1, 0]]],
+    #    [:var_ref, [:@kw, "__LINE__", [1, 4]]]]]]
+    it 'discovers the class for __ENCODING__' do
+      tree = Sexp.new(Ripper.sexp('x = __ENCODING__'))
+      list = tree[1]
+      list[0][2].expr_type.should == Types::ClassType.new('Encoding', :invariant)
+    end
+
+
+    # [:program,
+    # [[:assign,
+    #   [:var_field, [:@ident, "x", [1, 0]]],
+    #   [:dot2, [:@int, "2", [1, 4]], [:@int, "9", [1, 7]]]]]]
+    it 'discovers the class for inclusive ranges' do
+      tree = Sexp.new(Ripper.sexp('x = 2..9'))
+      list = tree[1]
+      list[0][2].expr_type.should == Types::ClassType.new('Range', :invariant)
+    end
+
+
+    # [:program,
+    # [[:assign,
+    #   [:var_field, [:@ident, "x", [1, 0]]],
+    #   [:dot3, [:@int, "2", [1, 4]], [:@int, "9", [1, 8]]]]]]
+    it 'discovers the class for exclusive ranges' do
+      tree = Sexp.new(Ripper.sexp('x = 2...9'))
+      list = tree[1]
+      list[0][2].expr_type.should == Types::ClassType.new('Range', :invariant)
+    end
+
+    # [:program,
+    #  [[:assign,
+    #    [:var_field, [:@ident, "x", [1, 0]]],
+    #    [:lambda,
+    #     [:paren, [:params, [[:@ident, "a", [1, 7]]], nil, nil, nil, nil]],
+    #     [[:var_ref, [:@ident, "a", [1, 10]]]]]]]]
+    it "discovers the class for 1.9's stabby lambdas" do
+      tree = Sexp.new(Ripper.sexp('x = ->(a, b=2){ a + b }'))
+      list = tree[1]
+      list[0][2].expr_type.should == Types::ClassType.new('Proc', :invariant)
+    end
+  end
+end