laser 0.7.0.pre1

data/spec/analysis_specs/sexp_spec.rb

@@ -0,0 +1,167 @@
+require_relative 'spec_helper'
+
+describe Sexp do
+  before do
+    @sexp = Sexp.new([:if, [:abc, 2, 3], [:def, 4, 5], nil])
+  end
+  
+  describe '#type' do
+    it 'returns the type of the sexp' do
+      @sexp.type.should == :if
+      @sexp[1].type.should == :abc
+      @sexp[2].type.should == :def
+    end
+  end
+  
+  describe '#children' do
+    it 'returns the children of a normal sexp' do
+      @sexp.children.should == [[:abc, 2, 3], [:def, 4, 5], nil]
+      @sexp[1].children.should == [2, 3]
+      @sexp[2].children.should == [4, 5]
+    end
+    
+    it 'returns everything in an array if a whole-array sexp' do
+      Sexp.new([[:abc], 2, 3, [:def, 3, 4]]).children.should == [[:abc], 2, 3, [:def, 3, 4]]
+    end
+  end
+  
+  describe '#all_errors' do
+    it 'should return all errors in the tree, in DFS order' do
+      sexp = Sexp.new([[:abc], [:d, 2, [:e, 1]], [:def, [:a], [:b]]])
+      sexp.errors = ['hi']
+      sexp[0].errors = []
+      sexp[1].errors = ['world']
+      sexp[1][2].errors = ['another']
+      sexp[2].errors = [2]
+      sexp[2][1].errors = [3, 4]
+      sexp[2][2].errors = [5, 6, 7]
+      sexp.all_errors.should == ['hi', 'world', 'another', 2, 3, 4, 5, 6, 7]
+    end
+  end
+  
+  describe 'performing DFS operations' do
+    before do
+      @hard_sexp = Sexp.new([:program,
+                   [[:class,
+                     [:const_ref, [:@const, "A", [1, 6]]],
+                     [:var_ref, [:@const, "String", [1, 10]]],
+                     [:bodystmt,
+                      [[:defs,
+                        [:var_ref, [:@kw, "self", [1, 22]]],
+                        [:@period, ".", [1, 26]],
+                        [:@ident, "silly", [1, 27]],
+                        [:paren,
+                         [:params,
+                          [[:@ident, "x", [1, 33]]], nil,
+                          [:rest_param, [:@ident, "y", [1, 37]]], nil, nil]],
+                        [:bodystmt,
+                         [[:void_stmt],
+                          [:massign,
+                           [:mlhs_paren, [[:@ident, "x", [1, 42]], [:@ident, "y", [1, 45]]]],
+                           [:mrhs_add_star, [], [:var_ref, [:@ident, "y", [1, 51]]]]]],
+                         nil, nil, nil]]],
+                      nil, nil, nil]]]])
+      # While I had to manually figure this out, a simple look at the indices used
+      # shows that it is a proper DFS order.
+      @correct_order = [@hard_sexp,
+                        @hard_sexp[1][0],
+                        @hard_sexp[1][0][1],
+                        @hard_sexp[1][0][1][1],
+                        @hard_sexp[1][0][2],
+                        @hard_sexp[1][0][2][1],
+                        @hard_sexp[1][0][3],
+                        @hard_sexp[1][0][3][1][0],
+                        @hard_sexp[1][0][3][1][0][1],
+                        @hard_sexp[1][0][3][1][0][1][1],
+                        @hard_sexp[1][0][3][1][0][2],
+                        @hard_sexp[1][0][3][1][0][3],
+                        @hard_sexp[1][0][3][1][0][4],
+                        @hard_sexp[1][0][3][1][0][4][1],
+                        @hard_sexp[1][0][3][1][0][4][1][1][0],
+                        @hard_sexp[1][0][3][1][0][4][1][3],
+                        @hard_sexp[1][0][3][1][0][4][1][3][1],
+                        @hard_sexp[1][0][3][1][0][5],
+                        @hard_sexp[1][0][3][1][0][5][1][0],
+                        @hard_sexp[1][0][3][1][0][5][1][1],
+                        @hard_sexp[1][0][3][1][0][5][1][1][1],
+                        @hard_sexp[1][0][3][1][0][5][1][1][1][1][0],
+                        @hard_sexp[1][0][3][1][0][5][1][1][1][1][1],
+                        @hard_sexp[1][0][3][1][0][5][1][1][2],
+                        @hard_sexp[1][0][3][1][0][5][1][1][2][2],
+                        @hard_sexp[1][0][3][1][0][5][1][1][2][2][1]]
+    end
+    describe '#dfs' do
+      # this test sucked to write.
+      it 'yields the nodes of the tree in DFS order' do
+        result = []
+        @hard_sexp.dfs { |node| result << node }
+        result.should == @correct_order
+      end
+    end
+  
+    describe '#dfs_enumerator' do
+      it 'should enumerate every element in DFS order' do
+        enumerator = @hard_sexp.dfs_enumerator
+        enumerator.entries.should == @correct_order
+      end
+    end
+  end
+  
+  describe '#expanded_identifier' do
+    ['abc', '@abc', 'ABC', '@@abc', '$abc'].each do |id|
+      tree = Sexp.new(Ripper.sexp(id))
+      actual_ident = tree[1][0][1]
+      it "discovers expanded identifiers for simple identifiers of type #{actual_ident[0]}" do
+        actual_ident.expanded_identifier.should == id
+      end
+    end
+
+    # [:program,
+    #  [[:assign,
+    #    [:var_field, [:@ident, "abc", [1, 0]]],
+    #    [:var_ref, [:@const, "ABC", [1, 6]]]]]]
+    it 'handles var_ref and var_field nodes' do
+      input = 'abc = ABC'
+      tree = Sexp.new(Ripper.sexp(input))
+      assign = tree[1][0]
+      assign[1].expanded_identifier.should == 'abc'
+      assign[2].expanded_identifier.should == 'ABC'
+    end
+
+    # [:program,
+    # [[:assign,
+    #   [:top_const_field, [:@const, "ABC", [1, 2]]],
+    #   [:top_const_ref, [:@const, "DEF", [1, 10]]]]]]
+    it 'handles top_const_ref and top_const_field nodes' do
+      input = '::ABC = ::DEF'
+      tree = Sexp.new(Ripper.sexp(input))
+      assign = tree[1][0]
+      assign[1].expanded_identifier.should == '::ABC'
+      assign[2].expanded_identifier.should == '::DEF'
+    end
+
+    # [:program,
+    #  [[:class,
+    #    [:const_ref, [:@const, "ABC", [1, 6]]],
+    #    nil,
+    #    [:bodystmt, [[:void_stmt]], nil, nil, nil]]]]
+    it 'handles const_ref nodes (found in module/class declarations)' do
+      input = 'class ABC; end'
+      tree = Sexp.new(Ripper.sexp(input))
+      klass = tree[1][0]
+      klass[1].expanded_identifier.should == 'ABC'
+    end
+
+    # [:program,
+    # [[:assign,
+    #   [:top_const_field, [:@const, "ABC", [1, 2]]],
+    #   [:top_const_ref, [:@const, "DEF", [1, 10]]]]]]
+    it 'handles top_const_ref and top_const_field nodes' do
+      input = '::ABC::DEF = ::DEF::XYZ'
+      tree = Sexp.new(Ripper.sexp(input))
+      assign = tree[1][0]
+      assign[1].expanded_identifier.should == '::ABC::DEF'
+      assign[2].expanded_identifier.should == '::DEF::XYZ'
+    end
+  end
+end

data/spec/analysis_specs/spec_helper.rb

@@ -0,0 +1,27 @@
+require_relative '../spec_helper'
+include Analysis
+
+module AnalysisHelpers
+  def clean_registry
+    before do
+      @backup_map = ProtocolRegistry.class_protocols.dup
+    end
+
+    after do
+      ProtocolRegistry.class_protocols.replace @backup_map
+    end
+  end
+end
+shared_examples_for 'an annotator' do
+  it 'should be in the global annotation list' do
+    expect do
+      Annotations.global_annotations.any? do |annotation|
+        annotation.is_a?(described_class)
+      end
+    end.to be_true
+  end
+end
+
+def annotate_all(body)
+  Annotations.annotate_inputs([['(stdin)', body]]).first[1]
+end

data/spec/analysis_specs/unused_methods_spec.rb

@@ -0,0 +1,65 @@
+require_relative 'spec_helper'
+
+describe UnusedMethodDetection do
+  before(:all) do
+    Laser::Analysis::LaserMethod.default_dispatched = false
+  end
+
+  # We don't want unused methods flowing into the next test, so
+  # mark each unused method as used afterward.
+  after(:each) do
+    @methods.each do |method|
+      method.been_used!
+    end
+  end
+
+  after(:all) do
+    Laser::Analysis::LaserMethod.default_dispatched = true
+  end
+
+  it 'can discover a simple case of an unused method' do
+    cfg <<-EOF
+class UnusedMethod1
+  def foo(x)
+    bar(x)
+  end
+  def bar(x, y=x)
+  end
+  def baz
+  end
+end
+UnusedMethod1.new.foo(gets)
+EOF
+    @methods = UnusedMethodDetection.unused_methods
+    @methods.should == [ClassRegistry['UnusedMethod1'].instance_method(:baz)]
+  end
+
+  it 'discovers method use through super' do
+cfg <<-EOF
+class UnusedMethod2
+  def foo(x)
+    x
+  end
+  def bar(x, y=x)
+  end
+end
+class UnusedMethod3 < UnusedMethod2
+  def foo(x)
+    bar(x)
+  end
+  def bar(x, y=x)
+    super
+    y
+  end
+  def baz
+  end
+end
+UnusedMethod3.new.foo(gets)
+EOF
+    @methods = UnusedMethodDetection.unused_methods
+
+    Set.new(@methods).should ==
+      Set[ClassRegistry['UnusedMethod2'].instance_method(:foo),
+          ClassRegistry['UnusedMethod3'].instance_method(:baz)]
+  end
+end

data/spec/analysis_specs/visitor_spec.rb

@@ -0,0 +1,64 @@
+require_relative 'spec_helper'
+require 'ostruct'
+
+describe Visitor do
+  before do
+    @class = Class.new do
+      include Visitor
+      add :foo do |node|
+        node.visited = node[1]
+      end
+      add :bar do |node|
+        node.product = node[1] * node[2]
+      end
+      add(proc {|node| node.children.any? && node[1] == 5 }) do |node|
+        node.lotto_winner = true
+      end
+    end
+  end
+  
+  describe '#visit' do
+    it 'runs the matching method when one is defined' do
+      a = Sexp.new([:foo, true])
+      a.should_receive(:visited=).with(true)
+      @class.new.visit(a)
+    end
+    it 'matches symbol-based filters as a shortcut for node type matching' do
+      b = Sexp.new([:bar, 3, 2])
+      b.should_receive(:product=).with(6)
+      @class.new.visit(b)
+    end
+    it 'uses arbitrary procs to match nodes' do
+      c = Sexp.new([:lotto_entry, 5])
+      c.should_receive(:lotto_winner=).with(true)
+      @class.new.visit(c)
+    end
+    
+    it 'automatically DFSs the tree to visit nodes when they are not handled' do
+      a = Sexp.new([:a, [:b, [:foo, false], 2, 3], [:c, [:bar, 19, 22], [:bar, 23, 2]]])
+      a[1][1].should_receive(:visited=).with(false)
+      a[2][1].should_receive(:product=).with(19 * 22)
+      a[2][2].should_receive(:product=).with(46)
+      @class.new.visit(a)
+    end
+    
+    it 'calls #default_visit when it encounters an unknown AST node' do
+      klass = Class.new do
+        include Visitor
+        def default_visit(node)
+          node.count = (@count ||= 1)
+          @count += 1
+          node.children.select {|x| Sexp === x}.each {|x| visit(x)}
+        end
+        add :bar do |node|
+        end
+      end
+      a = Sexp.new([:a, [:b, [:foo, false], 2, 3], [:c, [:bar, 19, 22], [:bar, 23, 2]]])
+      a.should_receive(:count=).with(1)
+      a[1].should_receive(:count=).with(2)
+      a[1][1].should_receive(:count=).with(3)
+      a[2].should_receive(:count=).with(4)
+      klass.new.visit(a)
+    end
+  end
+end

data/spec/annotation_parser_specs/annotations_parser_spec.rb

@@ -0,0 +1,89 @@
+require_relative 'spec_helper'
+
+describe Parsers::AnnotationParser do
+  before do
+    @parser = Parsers::AnnotationParser.new
+  end
+  
+  describe 'a self type' do
+    it 'should parse as a single self type constraint' do
+      'self'.should parse_to(Types::SelfType.new)
+    end
+  end
+
+  describe 'the top type' do
+    it 'should have no constraints' do
+      'Top'.should parse_to([])
+    end
+  end
+  
+  describe 'union types' do
+    it 'should parse to a Types::UnionType instance' do
+      'TrueClass= | FalseClass= | NilClass='.should parse_to(
+        Types::UnionType.new([
+          Types::ClassType.new('TrueClass', :invariant),
+          Types::ClassType.new('FalseClass', :invariant),
+          Types::ClassType.new('NilClass', :invariant)
+        ])
+      )
+    end
+    
+    it 'should handle more complicated types' do
+      'TrueClass= | #write(#to_s -> String, Integer) -> Boolean'.should parse_to(
+        Types::UnionType.new([
+          Types::ClassType.new('TrueClass', :invariant),
+          Types::StructuralType.new('write', [
+            Types::StructuralType.new('to_s', [], Types::ClassType.new('String', :covariant)),
+            Types::ClassType.new('Integer', :covariant)
+          ], Types::BOOLEAN)
+        ])
+      )
+    end
+  end
+  
+  describe 'named type annotations' do
+    it 'should provide a name string' do
+      result = @parser.parse('foo: Symbol => Integer')
+      result.name.should == 'foo'
+    end
+    
+    it 'should parse the type' do
+      result = @parser.parse('foo: Symbol => Integer')
+      result.type.should == Types::GenericType.new(Types::ClassType.new('Hash', :covariant),
+          [Types::ClassType.new('Symbol', :covariant),
+           Types::ClassType.new('Integer', :covariant)])
+    end
+
+    it 'should return false for #literal?' do
+      result = @parser.parse('foo: Symbol => Integer')
+      result.should_not be_literal
+    end
+    
+    it 'should return true for #type?' do
+      result = @parser.parse('foo:  Symbol => Integer')
+      result.should be_type
+    end
+  end
+  
+  describe 'named literal annotations' do
+    it 'should provide a name string' do
+      result = @parser.parse('foo: nil')
+      result.name.should == 'foo'
+    end
+    
+    it 'should parse the literal' do
+      result = @parser.parse('foo: nil')
+      result.literal.should == nil
+    end
+    
+    it 'should return true for #literal?' do
+      result = @parser.parse('foo: nil')
+      result.should be_literal
+    end
+    
+    it 'should return false for #type?' do
+      result = @parser.parse('foo: nil')
+      result.should_not be_type
+    end
+  end
+end

data/spec/annotation_parser_specs/class_annotation_parser_spec.rb

@@ -0,0 +1,120 @@
+require_relative 'spec_helper'
+
+describe Parsers::ClassParser do
+  before do
+    @parser = Parsers::AnnotationParser.new
+  end
+  
+  describe 'a simple class name' do
+    it 'is parsed into a single covariant constraint' do
+      'Hello'.should parse_to(Types::ClassType.new('Hello', :covariant))
+      'Hello'.should_not parse_to(Types::ClassType.new('Hello', :contravariant))
+    end
+  end
+  
+  describe 'the Boolean shorthand' do
+    it 'is parsed as the union of TrueClass and FalseClass' do
+      'Boolean'.should parse_to(Types::UnionType.new([Types::TRUECLASS, Types::FALSECLASS]))
+    end
+  end
+  
+  describe "a complex class path" do
+    it "is parsed into a single covariant constraint" do
+      '::Hello::World::Is::Here'.should parse_to(
+          Types::ClassType.new('::Hello::World::Is::Here', :covariant))
+    end
+  end
+  
+  describe 'a class name followed by -' do
+    it "is parsed into a contravariant class constraint" do
+      'World::Is::Here-'.should parse_to(
+          Types::ClassType.new('World::Is::Here', :contravariant))
+    end
+  end
+  
+  describe 'a class name followed by =' do
+    it "is parsed into a contravariant class constraint" do
+      'World::Is::Here='.should parse_to(
+          Types::ClassType.new('World::Is::Here', :invariant))
+    end
+  end
+  
+  describe 'two constraints separated by =>' do
+    it 'is parsed as a Hash<C1, C2>' do
+      ['Symbol => String', 'Symbol=>String', 'Symbol  =>   String'].each do |input|
+        input.should parse_to(
+            Types::GenericType.new(Types::ClassType.new('Hash', :covariant),
+                [Types::ClassType.new('Symbol', :covariant),
+                 Types::ClassType.new('String', :covariant)]))
+      end
+    end
+    
+    it 'allows variance constraints on the key and value types' do
+      '::Hello::World==>Some::Constant-'.should parse_to(
+          Types::GenericType.new(Types::ClassType.new('Hash', :covariant),
+              [Types::ClassType.new('::Hello::World', :invariant),
+               Types::ClassType.new('Some::Constant', :contravariant)]))
+    end
+  end
+  
+  describe 'a generic Array definition' do
+    it 'is parsed as a GenericType' do
+      'Array<String>'.should parse_to(
+          Types::GenericType.new(Types::ClassType.new('Array', :covariant),
+              [Types::ClassType.new('String', :covariant)]))
+    end
+  end
+  
+  describe 'a generic Hash definition' do
+    it 'is parsed as a GenericType' do
+      'Hash- < Symbol=,   String  >'.should parse_to(
+          Types::GenericType.new(Types::ClassType.new('Hash', :contravariant),
+              [Types::ClassType.new('Symbol', :invariant),
+               Types::ClassType.new('String', :covariant)]))
+    end
+  end
+  
+  describe 'a nested generic definition' do
+    it 'should parse correctly as nested GenericType' do
+      'Array<Hash<Symbol, String>>'.should parse_to(
+          Types::GenericType.new(Types::ClassType.new('Array', :covariant),
+              [Types::GenericType.new(Types::ClassType.new('Hash', :covariant),
+                  [Types::ClassType.new('Symbol', :covariant),
+                   Types::ClassType.new('String', :covariant)])]))
+    end
+  end
+  
+  describe 'an array generic shorthand' do
+    it 'should parse as a covariant generic array constraint' do
+      '[   String= ]'.should parse_to(
+          Types::GenericType.new(Types::ClassType.new('Array', :covariant),
+              [Types::ClassType.new('String', :invariant)]))
+    end
+  end
+  
+  describe 'a dont-care shorthand' do
+    it 'should parse as a covariant Object constraint, which matches any object' do
+      '_'.should parse_to(Types::ClassType.new('Object', :covariant))
+    end
+  end
+
+  describe 'tuples' do
+    describe 'a simple tuple type' do
+      it 'should parse to a TupleType' do
+        '(String- , _ , Symbol= => Fixnum)'.should parse_to(
+            Types::TupleType.new(
+              [Types::ClassType.new('String', :contravariant),
+               Types::ClassType.new('Object', :covariant),
+               Types::GenericType.new(Types::ClassType.new('Hash', :covariant),
+                   [Types::ClassType.new('Symbol', :invariant),
+                    Types::ClassType.new('Fixnum', :covariant)])]))
+      end
+    end
+  
+    describe 'an empty tuple type' do
+      it 'should parse to a (relatively useless) TupleType' do
+        '(  )'.should parse_to(Types::TupleType.new([]))
+      end
+    end
+  end
+end