laser 0.7.0.pre1

data/spec/analysis_specs/control_flow_specs/spec_helper.rb

@@ -0,0 +1,110 @@
+require_relative '../spec_helper'
+
+def cfg_builder_for(input)
+  ControlFlow::GraphBuilder.new(annotate_all(input)[1][0][3])
+end
+
+RSpec::Matchers.define :have_error do |klass|
+  chain :on_line do |number|
+    @line = number
+  end
+  
+  chain :with_message do |message|
+    @message_matcher = message
+  end
+  
+  match do |graph|
+    graph.all_errors.any? do |err|
+      @matches_class = err.is_a?(klass)
+      @matches_line = !@line || err.line_number == @line
+      @matches_message = if String === @message_matcher
+                          err.message == @message_matcher
+                        elsif Regexp === @message_matcher
+                          err.message =~ @message_matcher
+                        else
+                          true
+                        end
+      @matches_message && @matches_line && @matches_class
+    end
+  end
+  
+  failure_message_for_should do |graph|
+    result = 'expected an error that'
+    result << " was of the class #{klass.name}" if !@matches_message
+    result << " was on line #@line" if !@matches_line
+    if !@matches_message
+      result << " matches the regex #{@message_matcher}" if Regexp === @message_matcher
+      result << " matches the regex #{@message_matcher}" if String === @message_matcher
+    end
+    result
+  end
+  
+  failure_message_for_should_not do |graph|
+    "Expected to not find any errors of class #{klass.name}"
+  end
+end
+
+RSpec::Matchers.define :have_constant do |name|
+  chain :with_value do |value|
+    @value = value
+  end
+  
+  match do |graph|
+    graph.constants.keys.find do |var|
+      next unless var.non_ssa_name == name
+      @constant = var
+      @value ||= nil
+      if @value
+        @constant && (@constant.value == @value)
+      else
+        @constant
+      end
+    end
+  end
+  
+  failure_message_for_should do |graph|
+    if !@constant
+      "Expected variable '#{name}' to be inferred as a constant, but it was not."
+    elsif @constant.value != @value
+      "Expected variable '#{name}' to have value #{@value}, but it was #{@constant.value}."
+    else
+      "UNEXPECTED FAILURE?!"
+    end
+  end
+  
+  failure_message_for_should_not do |graph|
+    if @constant && @constant.value == @value
+      "Expected variable '#{name}' to not have value #{@value}, but it was #{@constant.value}."
+    elsif @constant
+      "Expected variable '#{name}' to not be inferred as a constant, but it was."
+    else
+      "UNEXPECTED FAILURE?!"
+    end
+  end
+end
+
+
+include Laser::Analysis
+def annotate_all_cfg(body)
+  inputs = [['(stdin)', body]]
+  inputs.map! do |filename, text|
+    [filename, text, Sexp.new(RipperPlus.sexp(text), filename, text)]
+  end
+  Annotations.apply_inherited_attributes(inputs)
+  inputs[0][2]
+end
+def cfg(input)
+  cfg_builder = ControlFlow::GraphBuilder.new(annotate_all_cfg(input))
+  graph = cfg_builder.build
+  graph.analyze
+  graph
+end
+def cfg_method(input)
+  method_tree = annotate_all_cfg(input)
+  body = method_tree.find_type(:bodystmt)
+  cfg_builder = ControlFlow::GraphBuilder.new(
+      body, Signature.arg_list_for_arglist(body.prev))
+  graph = cfg_builder.build
+  graph.analyze
+  graph
+end

data/spec/analysis_specs/control_flow_specs/tuple_misuse_inference_spec.rb

@@ -0,0 +1,125 @@
+require_relative 'spec_helper'
+
+describe 'Tuple misuse inference' do
+  it 'should find code that has statically too few mlhs for mrhs' do
+    g = cfg_method <<-EOF
+def foo(x)
+  a, b, c, d = x, x
+end
+EOF
+    g.should have_error(Laser::UnassignedLHSError).on_line(2).with_message(/\(c\)/)
+    g.should have_error(Laser::UnassignedLHSError).on_line(2).with_message(/\(d\)/)
+  end
+
+  it 'should find code that has statically too many mlhs for mrhs' do
+    g = cfg_method <<-EOF
+def foo(x)
+  a, d = x, x, x
+end
+EOF
+    g.should have_error(Laser::DiscardedRHSError).on_line(2)
+  end
+
+  it 'should find statically useless LHS splats' do
+g = cfg_method <<-EOF
+def foo(x)
+  a, *b, d = x, x
+end
+EOF
+    g.should have_error(Laser::UnassignedLHSError).on_line(2).with_message(/\(b\)/)
+  end
+
+  it 'should find statically useless LHS unnamed splats and report them differently' do
+g = cfg_method <<-EOF
+def foo(x)
+  a, *, d = x, x
+end
+EOF
+    g.should have_error(Laser::UnassignedLHSError).on_line(2).with_message(/Unnamed LHS/i)
+  end
+
+  it 'should find statically discarded RHS splats' do
+g = cfg_method <<-EOF
+def foo(x)
+  a, b, c = x, x, x, *x
+end
+EOF
+    g.should have_error(Laser::DiscardedRHSError).on_line(2).with_message(/splat/i)
+  end
+
+  it 'should find dynamically-proven unassigned LHS vars' do
+    g = cfg <<-EOF
+class TupleMisuse1
+  def foo(x)
+    a, b, c = bar(x)
+  end
+  def bar(x)
+    [x, x]
+  end
+end
+TupleMisuse1.new.foo(gets)
+EOF
+    g.should have_error(Laser::UnassignedLHSError).on_line(3)
+  end
+
+  it 'should find dynamically-proven discarded RHS vals' do
+    g = cfg <<-EOF
+class TupleMisuse1
+  def foo(x)
+    a, b = bar(x)
+  end
+  def bar(x)
+    [x, x, x]
+  end
+end
+TupleMisuse1.new.foo(gets)
+EOF
+    g.should have_error(Laser::DiscardedRHSError).on_line(3)
+  end
+
+  it 'should find dynamically-proven unassigned LHS splats' do
+    g = cfg <<-EOF
+class TupleMisuse1
+  def foo(x)
+    a, *b, c = bar(x)
+  end
+  def bar(x)
+    [x, x]
+  end
+end
+TupleMisuse1.new.foo(gets)
+EOF
+    g.should have_error(Laser::UnassignedLHSError).on_line(3)
+  end
+
+  it 'should find dynamically-proven wasted RHS splat vals' do
+    g = cfg <<-EOF
+class TupleMisuse1
+  def foo(x)
+    a, b, c = x, x, *bar(x)
+  end
+  def bar(x)
+    [x, x]
+  end
+end
+TupleMisuse1.new.foo(gets)
+EOF
+    g.should have_error(Laser::DiscardedRHSError).on_line(3)
+  end
+
+
+  it 'should find dynamically-proven unassigned LHS splats with an RHS splat too' do
+    g = cfg <<-EOF
+class TupleMisuse1
+  def foo(x)
+    a, *b, c, d = x, *bar(x)
+  end
+  def bar(x)
+    [x, x]
+  end
+end
+TupleMisuse1.new.foo(gets)
+EOF
+    g.should have_error(Laser::UnassignedLHSError).on_line(3)
+  end
+end

data/spec/analysis_specs/control_flow_specs/unreachability_analysis_spec.rb

@@ -0,0 +1,76 @@
+require_relative 'spec_helper'
+
+describe ControlFlow::UnreachabilityAnalysis do
+  it 'should find code that follows explicit return' do
+    g = cfg_method <<-EOF
+def foo(x)
+y = gets() * 2
+return y
+p y
+end
+EOF
+    g.should have_error(Laser::DeadCodeWarning).on_line(4)
+  end
+
+  %w{next break redo}.each do |keyword|
+    it "should find code that follows a #{keyword}" do
+      g = cfg_method <<-EOF
+def foo(x)
+while y = gets() * 2
+  p y
+  #{keyword}
+  z = y.foo
+end
+end
+EOF
+      g.should have_error(Laser::DeadCodeWarning).on_line(5)
+    end
+  end
+
+  it 'should find code that follows an if/else/elsif in which each branch jumps' do
+    g = cfg_method <<-EOF
+def foo(x)
+y = gets() * 2
+if y.size > 10
+  return y
+elsif y.size < 10
+  return y[0..4]
+else
+  return 'hello'
+end
+puts y
+end
+EOF
+    g.should have_error(Laser::DeadCodeWarning).on_line(10)
+  end
+
+  it 'should find code that never runs due to constant propagation' do
+    g = cfg_method <<-EOF
+def foo(x)
+y = 'hello' * 3
+if y == 'hellohellohello'
+  puts gets
+  z = 3
+else
+  z = 10
+end
+a = z
+end
+EOF
+    g.should have_error(Laser::DeadCodeWarning).on_line(7)
+  end
+  
+  it 'should find code that never runs due to CP + local type inference' do
+    g = cfg_method <<-EOF
+def foo
+  a = gets
+  if a.strip  # no !, always returns a String
+    10
+  else
+    20  # dead code
+  end
+end
+EOF
+    g.should have_error(Laser::DeadCodeWarning).on_line(6)
+  end
+end

data/spec/analysis_specs/control_flow_specs/unused_variable_spec.rb

@@ -0,0 +1,99 @@
+require_relative 'spec_helper'
+
+describe ControlFlow::UnusedVariables do
+  it 'should find a simple unused variable' do
+    g = cfg_method <<-EOF
+def foo(x)
+y = gets() * 2
+z = y
+c = z * z
+end
+EOF
+    g.should have_error(Laser::UnusedVariableWarning).on_line(4).with_message(/\b c \b/x)
+  end
+
+  it 'should find a more complex unused variable showing off ssa' do
+    g = cfg_method <<-EOF
+def foo(x)
+z = gets * 10
+if z.size > 50
+  y = z  # this y is used as return value
+else
+  y = z * 2
+  puts y
+end
+end
+EOF
+    g.should have_error(Laser::UnusedVariableWarning).on_line(4).with_message(/\b y \b/x)
+  end
+  
+  it 'should see when a variable is assigned and used to compute only unused vars' do
+    g = cfg_method <<-EOF
+def foo(x)
+z = gets * 10
+d = z * 2
+a = d
+puts z
+nil
+end
+EOF
+    g.should have_error(Laser::UnusedVariableWarning).on_line(3).with_message(/\b d \b/x)
+    g.should have_error(Laser::UnusedVariableWarning).on_line(4).with_message(/\b a \b/x)
+    g.should_not have_error(Laser::UnusedVariableWarning).with_message(/\b z \b/x)
+  end
+
+  it 'should ignore SSA variables assigned and used to compute only unused vars' do
+    g = cfg_method <<-EOF
+def foo(x)
+z = gets * 10
+if z.size > 3
+  d = z * 2
+  c = z
+else
+  d = z * 10
+  c = 30
+end
+j = d
+c
+end
+EOF
+
+    g.should have_error(Laser::UnusedVariableWarning).on_line(4).with_message(/\b d \b/x)
+    g.should have_error(Laser::UnusedVariableWarning).on_line(7).with_message(/\b d \b/x)
+    g.should have_error(Laser::UnusedVariableWarning).on_line(10).with_message(/\b j \b/x)
+  end
+  
+  it 'is improved by constant propagation' do
+    g = cfg_method <<-EOF
+def foo(x)
+z = (10 ** 5).to_s(5)
+if z == "11200000"
+  d = z * 2
+  c = z
+else
+  d = z * 10
+  c = 30
+end
+j = d
+c
+end
+EOF
+
+    g.should have_error(Laser::UnusedVariableWarning).on_line(4).with_message(/\b d \b/x)
+    g.should have_error(Laser::UnusedVariableWarning).on_line(7).with_message(/\b d \b/x)
+    g.should have_error(Laser::UnusedVariableWarning).on_line(8).with_message(/\b c \b/x)
+    g.should have_error(Laser::UnusedVariableWarning).on_line(10).with_message(/\b j \b/x)
+  end
+  
+  it 'recognizes unused variables introduced through multiple assignment' do
+    g = cfg_method <<-EOF
+def foo(x)
+y = gets() * 2
+z, i = y, 3
+c = z * z
+end
+EOF
+    g.should have_error(Laser::UnusedVariableWarning).on_line(3).with_message(/\b i \b/x)
+    g.should have_error(Laser::UnusedVariableWarning).on_line(4).with_message(/\b c \b/x)
+  end
+end

data/spec/analysis_specs/control_flow_specs/yield_properties_spec.rb

@@ -0,0 +1,372 @@
+require_relative 'spec_helper'
+
+describe ControlFlow::YieldProperties do
+  it 'should recognize non-yielding methods' do
+    g = cfg_method <<-EOF
+def foo(x)
+  y = gets() * 2
+  z = y
+  c = z * z
+end
+EOF
+    g.yield_type.should be :ignored
+    g.yield_arity.should == Set[]
+  end
+
+  it 'should recognize non-yielding methods via CP' do
+    g = cfg_method <<-EOF
+def foo(x)
+  x = 2 ** 16
+  if x == 65536
+    puts x
+  else
+    yield
+  end
+end
+EOF
+    g.yield_type.should be :ignored
+    g.yield_arity.should == Set[]
+  end
+
+  it 'should recognize simple required-yield methods' do
+    g = cfg_method <<-EOF
+def tap
+  yield self
+  self
+end
+EOF
+    g.yield_type.should be :required
+    g.yield_arity.should == Set[1]
+  end
+
+  it 'denotes the method required when a branch is unprovable' do
+    g = cfg_method <<-EOF
+def one
+  if gets.size < 0
+    yield
+  else
+    1
+  end
+end
+EOF
+    g.yield_type.should be :required
+    g.yield_arity.should == Set[0]
+  end
+  ['block_given?', 'defined?(yield)', 'defined?(yield($., *$*))', 'Proc.new', 'iterator?'].each do |guard|
+    it "denotes the method optional when yield is guarded by #{guard}" do
+      g = cfg_method <<-EOF
+def one
+  if #{guard}
+    yield 1
+  else
+    1
+  end
+end
+EOF
+      g.yield_type.should be :optional
+      g.yield_arity.should == Set[1]
+    end
+
+    it "denotes the method foolish when yield is not guarded by #{guard}, but the block is unused when given" do
+      g = cfg_method <<-EOF
+def one
+  if #{guard}
+    1
+  else
+    yield 1
+  end
+end
+EOF
+      g.yield_type.should be :foolish
+      g.yield_arity.should == Set[]
+    end
+  end
+
+  it 'denotes the method optional when the explicit block arg is checked vs. nil' do
+    g = cfg_method <<-EOF
+def one(&blk)
+  if blk != nil
+    yield 1
+    yield(1, 2)
+  else
+    1
+  end
+end
+EOF
+    g.yield_type.should be :optional
+    g.yield_arity.should == Set[1, 2]
+  end
+  [['.call(', ')'], ['[', ']'], ['.===(', ')']].each do |prefix, suffix|
+    it "denotes the method optional when the explicit block arg is checked vs. nil and called with #{prefix}#{suffix}" do
+      g = cfg_method <<-EOF
+def one(&blk)
+  if blk != nil
+    blk#{prefix}2, 3#{suffix}
+  else
+    1
+  end
+end
+EOF
+      g.yield_type.should be :optional
+      g.yield_arity.should == Set[2]
+    end
+
+    it "denotes the method required when the explicit block arg is not checked vs. nil and called with #{prefix}#{suffix}" do
+      g = cfg_method <<-EOF
+def one(&blk)
+  blk#{prefix}2, 3#{suffix}
+  1
+end
+EOF
+      g.yield_type.should be :required
+      g.yield_arity.should == Set[2]
+    end
+
+    it "denotes the method foolish when the explicit block arg is checked vs. nil and called with #{prefix}#{suffix}" do
+      g = cfg_method <<-EOF
+def one(&blk)
+  if blk == nil
+    blk#{prefix}2, 3#{suffix}
+  end
+  1
+end
+EOF
+      g.yield_type.should be :foolish
+      g.yield_arity.should == Set[]
+    end
+  
+    it "denotes the method optional when the Proc.new block arg is checked vs. nil and called with #{prefix}#{suffix}" do
+      g = cfg_method <<-EOF
+def one
+  blk = Proc::new
+  if blk != nil
+    blk#{prefix}2, 3#{suffix}
+  else
+    1
+  end
+end
+EOF
+      g.yield_type.should be :optional
+      g.yield_arity.should == Set[2]
+    end
+
+    it "denotes the method required when the Proc.new block arg is not checked vs. nil and called with #{prefix}#{suffix}" do
+      g = cfg_method <<-EOF
+def one
+  blk = Proc::new
+  blk#{prefix}2, 3#{suffix}
+  1
+end
+EOF
+      g.yield_type.should be :required
+      g.yield_arity.should == Set[2]
+    end
+
+    it "denotes the method foolish when the Proc.new block arg is checked vs. nil and called with #{prefix}#{suffix}" do
+      g = cfg_method <<-EOF
+def one
+  blk = Proc::new
+  if blk == nil
+    blk#{prefix}2, 3#{suffix}
+  end
+  1
+end
+EOF
+      g.yield_type.should be :foolish
+      g.yield_arity.should == Set[]
+    end
+
+    it 'denotes the method ignored when the explicit block arg is never called' do
+      g = cfg_method <<-EOF
+def one(&blk)
+  result = blk.nil? ? 5 : 10
+  result ** result
+end
+EOF
+      g.yield_type.should be :ignored
+      g.yield_arity.should == Set[]
+    end
+
+    it "is not confused by sending #{prefix}#{suffix} to other arguments" do
+      g = cfg_method <<-EOF
+def one(other_arg, &blk)
+  other_arg#{prefix}5#{suffix}
+end
+EOF
+      g.yield_type.should be :ignored
+    end
+
+    it "uses SSA information to find aliases to the block that receive #{prefix}#{suffix}" do
+      g = cfg_method <<-EOF
+def one(other_arg, &blk)
+  if gets.size > 2
+    other_arg = blk
+  end
+  other_arg#{prefix}2#{suffix}
+end
+EOF
+      g.yield_type.should be :required
+    end
+  end
+
+  %w(LocalJumpError StandardError Exception Object Kernel BasicObject).each do |exc|
+    it "denotes the method optional when yield is guarded by rescue of #{exc}" do
+      g = cfg_method <<-EOF
+def one
+  yield 1
+  4
+rescue #{exc}
+  2
+end
+EOF
+      g.yield_type.should be :optional
+      g.yield_arity.should == Set[1]
+    end
+  end
+
+  it "denotes the method optional when yield is guarded by rescue with no handlers" do
+    g = cfg_method <<-EOF
+def one
+  yield 1
+  4
+rescue
+  2
+end
+EOF
+    g.yield_type.should be :optional
+    g.yield_arity.should == Set[1]
+  end
+
+  it 'denotes the method optional when yield is guarded by a rescue modifier' do
+    g = cfg_method <<-EOF
+def one
+  yield 1 rescue 2
+end
+EOF
+    g.yield_type.should be :optional
+    g.yield_arity.should == Set[1]
+  end
+
+  it "denotes the method required if the yield is guarded by a non-matching rescue" do
+    g = cfg_method <<-EOF
+def one
+  yield 1
+  4
+rescue RuntimeError
+  2
+end
+EOF
+    g.yield_type.should be :required
+    g.yield_arity.should == Set[1]
+  end
+  
+  it 'infers yield likelihood with to_proc block syntax' do
+    cfg <<-EOF
+class YP1
+  def foo(x)
+    yield x if block_given?
+  end
+  def bar(y, &blk)
+    foo(y, &blk)
+  end
+end
+EOF
+    method = ClassRegistry['YP1'].instance_method(:bar)
+    method.yield_type.should be :optional
+  end
+  
+  it 'infers yield likelihood with to_proc to a builtin method' do
+    cfg <<-EOF
+class YP2
+  def bar(x, &blk)
+    [1, 2, x].each(&blk)
+  end
+end
+EOF
+    method = ClassRegistry['YP2'].instance_method(:bar)
+    method.yield_type.should be :optional
+  end
+  
+  it 'proves optionality in a complex example of yield likelihood through classes and ivars' do
+    cfg <<-EOF
+class YP3
+  def initialize(data)
+    @data = data
+  end
+  def each(&blk)
+    @data.each(&blk)
+  end
+end
+class YP4
+  def initialize(data)
+    @data = data
+  end
+  def foobar(&blk)
+    @data.each(&blk)
+  end
+end
+YP4Temp1 = YP4.new(YP3.new([1, 2, 3]))
+YP4Temp2 = YP4.new(YP3.new({a: :b, c: :d}))
+YP4Temp3 = YP4.new([5, 6])
+EOF
+    method = ClassRegistry['YP4'].instance_method(:foobar)
+    method.yield_type.should be :optional
+  end
+
+  it 'infers a complex example of yield likelihood through classes and ivars' do
+    cfg <<-EOF
+class YP5
+  def each
+    yield 1
+    yield 2
+    yield 3
+  end
+end
+class YP6
+  def initialize(data)
+    @data = data
+  end
+  def foobar(&blk)
+    @data.each(&blk)
+  end
+end
+YP6Temp1 = YP6.new(YP5.new)
+EOF
+    method = ClassRegistry['YP6'].instance_method(:foobar)
+    method.yield_type.should be :required
+  end
+  
+  it 'infers yield likelihood through super-delegation' do
+    cfg <<-EOF
+class YP7
+  def each
+    yield 1 if block_given?
+  end
+end
+class YP8 < YP7
+  def each(&blk)
+    super(&blk)
+  end
+end
+EOF
+    method = ClassRegistry['YP8'].instance_method(:each)
+    method.yield_type.should be :optional
+  end
+
+  it 'infers yield likelihood through zsuper-delegation' do
+    cfg <<-EOF
+class YP9
+  def each
+    yield 1 if block_given?
+  end
+end
+class YP10 < YP9
+  def each
+    super
+  end
+end
+EOF
+    method = ClassRegistry['YP10'].instance_method(:each)
+    method.yield_type.should be :optional
+  end
+end