laser 0.7.0.pre1

data/spec/analysis_specs/annotations_specs/spec_helper.rb

@@ -0,0 +1,33 @@
+require_relative '../spec_helper'
+
+# Runs a shit-ton of expectations common among annotations. Since an annotaiton
+# just adds an attribute to a Sexp, we have a very common set of examples o
+# the form:
+#   tree[0].new_attribute.should == some_val
+#   tree[1][0].new_attribute.should == some_val
+#   ...
+#   tree[2][2].new_attribute.should == cool_inferred_val
+# and so on. A ton of repetitiveness can be captured by using hashes in the form:
+#
+#     {new_attribute: { some_val => [tree[1][0], tree[0], ...],
+#                        { cool_inferred_val => [tree[2][2], ...] }}}
+#
+# Each attribute is a key in the toplevel hash, and each possible value is a key
+# in the second-level hash. Technically this doesn't remove all duplication, but
+# it's good.
+def expectalot(expectation)
+  messages = expectation.keys
+  messages.each do |message|
+    examples = expectation[message]
+    examples.each do |expected_value, recipients|
+      recipients.each do |recipient|
+        begin
+          recipient.send(message).should == expected_value
+        rescue Exception => err
+          p "#{recipient.inspect}'s #{message} should be #{expected_value.inspect}"
+          raise err
+        end
+      end
+    end
+  end 
+end

data/spec/analysis_specs/argument_expansion_spec.rb

@@ -0,0 +1,113 @@
+require_relative 'spec_helper'
+
+describe Analysis::ArgumentExpansion do
+  describe '#arity' do
+    it 'can figure out the arity of a simple method call with no arguments' do
+      tree = annotate_all('foo(  )')[1][0][2]
+      ArgumentExpansion.new(tree).arity.should == (0..0)
+    end
+
+    it 'can figure out the arity of a simple method call' do
+      tree = annotate_all('foo(1, 2, 3)')[1][0][2]
+      ArgumentExpansion.new(tree).arity.should == (3..3)
+    end
+    
+    it 'does not count block arguments in arity' do
+      tree = annotate_all('foo(1, 2, 3, &d())')[1][0][2]
+      ArgumentExpansion.new(tree).arity.should == (3..3)
+    end
+    
+    it 'has an infinite maximum arity in the presence of un-computable splats' do
+      tree = annotate_all('foo(1, 2, 3, *foobar())')[1][0][2]
+      ArgumentExpansion.new(tree).arity.should == (3..Float::INFINITY)
+    end
+    
+    it 'count arguments after splats' do
+      tree = annotate_all('foo(1, 2, 3, *foobar(), 4, 5)')[1][0][2]
+      ArgumentExpansion.new(tree).arity.should == (5..Float::INFINITY)
+    end
+    
+    it 'splats constant arguments to precise arity' do
+      tree = annotate_all('foo(1, 2, 3, *[:a, :b, :c], 4, 5)')[1][0][2]
+      ArgumentExpansion.new(tree).arity.should == (8..8)
+    end
+    
+    it 'splats constant range arguments to precise arity' do
+      tree = annotate_all('foo(1, 2, 3, *(2...10), 4, 5)')[1][0][2]
+      ArgumentExpansion.new(tree).arity.should == (13..13)
+    end
+  end
+  
+  describe '#empty?' do
+    it 'returns true when no args are being passed' do
+      tree = annotate_all('foo(  )')[1][0][2]
+      ArgumentExpansion.new(tree).should be_empty
+    end
+    
+    it 'returns false when args are being passed' do
+      tree = annotate_all('foo( 2 )')[1][0][2]
+      ArgumentExpansion.new(tree).should_not be_empty
+    end
+  end
+  
+  describe '#has_block?' do
+    it 'returns false with no arguments given' do
+      tree = annotate_all('foo()')[1][0][2]
+      ArgumentExpansion.new(tree).has_block?.should be false
+    end
+
+    it 'returns true if there is an explicit block argument' do
+      tree = annotate_all('foo(1, 2, 3, &d)')[1][0][2]
+      ArgumentExpansion.new(tree).has_block?.should be_true
+    end
+    
+    it 'returns false if there is an explicit block argument' do
+      tree = annotate_all('foo(1, 2, 3, *foobar())')[1][0][2]
+      ArgumentExpansion.new(tree).has_block?.should be false
+    end
+  end
+  
+  describe '#is_constant?' do
+    it 'returns true for no params' do
+      tree = annotate_all('foo()')[1][0][2]
+      ArgumentExpansion.new(tree).is_constant?.should be_true
+    end
+    it 'returns true if all constituent arguments are constant' do
+      tree = annotate_all('foo(1, 2, 3)')[1][0][2]
+      ArgumentExpansion.new(tree).is_constant?.should be_true
+    end
+    
+    it 'returns true if all constituent arguments are constant in the presenece of splats' do
+      tree = annotate_all('foo(1, 2, *[1, 2], 4, *("a"..."d"))')[1][0][2]
+      ArgumentExpansion.new(tree).is_constant?.should be_true
+    end
+    
+    it 'returns false in the presence of non-constant arguments' do
+      tree = annotate_all('foo(1, foobar(), 3)')[1][0][2]
+      ArgumentExpansion.new(tree).is_constant?.should be_false
+    end
+  end
+
+  describe '#constant_values' do
+    it 'returns true for no params' do
+      tree = annotate_all('foo()')[1][0][2]
+      ArgumentExpansion.new(tree).constant_values.should == []
+    end
+    it 'returns true if all constituent arguments are constant' do
+      tree = annotate_all('foo(1, 2, 3)')[1][0][2]
+      ArgumentExpansion.new(tree).constant_values.should == [1, 2, 3]
+    end
+    
+    it 'returns true if all constituent arguments are constant in the presence of splats' do
+      tree = annotate_all('foo(1, 2, *[1, 2], 4, *("a"..."d"))')[1][0][2]
+      ArgumentExpansion.new(tree).constant_values.should == [1, 2, 1, 2, 4, 'a', 'b', 'c']
+    end
+    
+    it 'expands a splatted literal array' do
+      tree = annotate_all('foobar *[:a, :b]')[1][0][2]
+      expansion = ArgumentExpansion.new(tree)
+      expansion.is_constant?.should be_true
+      expansion.constant_values.should == [:a, :b]
+    end
+  end
+end

data/spec/analysis_specs/bindings_spec.rb

@@ -0,0 +1,36 @@
+require_relative 'spec_helper'
+
+describe Analysis::Bindings::Base do
+  describe '#initialize' do
+    it 'has a simple struct-like initializer' do
+      name, value = many_mocks(2)
+      sym = Analysis::Bindings::Base.new(name, value)
+      sym.name.should == name
+      sym.value.should == value
+    end
+  end
+  
+  describe '#<=>' do
+    it 'should compare based on name alone' do
+      value = mock
+      sym1 = Analysis::Bindings::Base.new('hello', value)
+      sym2 = Analysis::Bindings::Base.new('helga', value)
+      sym1.should > sym2
+    end
+  end
+end
+
+describe Analysis::Bindings::ConstantBinding do
+  describe '#bind!' do
+    it 'should raise on a rebinding when not forcing' do
+      sym = Analysis::Bindings::ConstantBinding.new('hi', 1)
+      expect { sym.bind!(2) }.to raise_error(TypeError)
+    end
+    
+    it 'should not raise on a rebinding when forcing' do
+      sym = Analysis::Bindings::ConstantBinding.new('hi', 3)
+      sym.bind!(4, true)
+      sym.value.should == 4
+    end
+  end
+end

data/spec/analysis_specs/comment_spec.rb

@@ -0,0 +1,93 @@
+require_relative 'spec_helper'
+
+describe Laser::Comment do
+  before do
+    body = <<-EOF
+##
+# Returns a repository object for the given path. Should respond to the standard repository
+# API to the best of its ability, and raise a CapabilityError if asked to do something it
+# cannot do from the API.
+#
+# @param [AmpConfig] config the configuration of the current environment, loaded from
+#    appropriate configuration files
+# @param [String] path the path/URL in which to open the repository.
+# @param [Boolean] create should a repository be created in the given directory/URL?
+# @return [AbstractLocalRepository] the repository for the given URL
+# @example
+#    Repo.pick('abc/def') do |foo|
+#      File.open(foo + '/.hg/hgrc')
+#    end
+EOF
+    @comment = Laser::Comment.new(body, 2, 4)
+    normal_annotated_body = <<-EOF
+##
+# Returns a repository object for the given path. Should respond to the standard repository
+# cannot do from the API.
+#
+# config: AmpConfig
+# path: String=
+# create: TrueClass | FalseClass
+# return: AbstractLocalRepository
+# @example
+#    Repo.pick('abc/def') do |foo|
+#      File.open(foo + '/.hg/hgrc')
+#    end
+EOF
+    @annotated_comment = Laser::Comment.new(normal_annotated_body, 8, 12)
+  end
+  
+  describe '#location' do
+    it 'packs up the line and column' do
+      @comment.location.should == [2, 4]
+    end
+  end
+  
+  describe '#features' do
+    it 'should extract features based on whether line breaks are followed by many spaces' do
+      @comment.features.should == [
+        'Returns a repository object for the given path. Should respond to the standard repository',
+        'API to the best of its ability, and raise a CapabilityError if asked to do something it',
+        'cannot do from the API.',
+        "@param [AmpConfig] config the configuration of the current environment, loaded from\n"+
+        "   appropriate configuration files",
+        '@param [String] path the path/URL in which to open the repository.',
+        '@param [Boolean] create should a repository be created in the given directory/URL?',
+        '@return [AbstractLocalRepository] the repository for the given URL',
+        "@example\n"+
+        "   Repo.pick('abc/def') do |foo|\n"+
+        "     File.open(foo + '/.hg/hgrc')\n"+
+        "   end"
+        ]
+    end
+  end
+  
+  describe '#annotations' do
+    it 'should extract annotations and parse them' do
+      notes = @annotated_comment.annotations
+      parts = notes.map(&:name).zip notes.map(&:type)
+      parts.should == [
+        ['config', Types::ClassType.new('AmpConfig', :covariant)],
+        ['path', Types::ClassType.new('String', :invariant)],
+        ['create', Types::UnionType.new([
+          Types::ClassType.new('TrueClass', :covariant),
+          Types::ClassType.new('FalseClass', :covariant)])],
+        ['return', Types::ClassType.new('AbstractLocalRepository', :covariant)]
+      ]
+    end
+  end
+  
+  describe '#annotation_map' do
+    it 'should extract annotations and convert them to a hash keyed by name' do
+      map = @annotated_comment.annotation_map.to_a
+      parts = map.map { |name, note| [name, note[0].name, note[0].type] }
+      parts.should == [
+        ['config', 'config', Types::ClassType.new('AmpConfig', :covariant)],
+        ['path', 'path', Types::ClassType.new('String', :invariant)],
+        ['create', 'create', Types::UnionType.new([
+          Types::ClassType.new('TrueClass', :covariant),
+          Types::ClassType.new('FalseClass', :covariant)])],
+        ['return', 'return', Types::ClassType.new('AbstractLocalRepository', :covariant)]
+      ]
+    end
+  end
+end

data/spec/analysis_specs/control_flow_specs/cfg_instruction_spec.rb

@@ -0,0 +1,111 @@
+require 'set'
+require_relative 'spec_helper'
+
+describe ControlFlow::Instruction do
+  describe '#explicit_targets' do
+    before do
+      @temp = Bindings::TemporaryBinding.new('%t1', nil)
+      @call_target = Bindings::TemporaryBinding.new('%t2', nil)
+      @ary = Bindings::TemporaryBinding.new('%t3', nil)
+    end
+
+    it 'should return an empty set for a return node' do
+      ControlFlow::Instruction.new([:return, 1, 2]).
+          explicit_targets.should == ::Set[]
+    end
+
+    it 'should return an empty set for a jump node' do
+      ControlFlow::Instruction.new([:jump, 'B1']).
+          explicit_targets.should == ::Set[]
+    end
+
+    it 'should return an empty set for a branch node' do
+      ControlFlow::Instruction.new([:branch, 't1', 'b2', 'b3']).
+          explicit_targets.should == ::Set[]
+    end
+    
+    it 'should return the target for an assign instruction' do
+      ControlFlow::Instruction.new([:assign, @temp, 2]).
+          explicit_targets.should == ::Set[@temp]
+    end
+
+    it 'should return the target for a call instruction' do
+      ControlFlow::Instruction.new([:call, @call_target, @temp, 'to_i', :block => false]).
+          explicit_targets.should == ::Set[@call_target]
+    end
+    
+    it 'should return the target for a call_vararg instruction' do
+      ControlFlow::Instruction.new([:call_vararg, @call_target, @temp, 'to_i', @ary, :block => false]).
+          explicit_targets.should == ::Set[@call_target]
+    end
+
+    it 'should return the target for a super instruction' do
+      ControlFlow::Instruction.new([:super, @call_target, :block => false]).
+          explicit_targets.should == ::Set[@call_target]
+    end
+    
+    it 'should return the target for a super_vararg instruction' do
+      ControlFlow::Instruction.new([:super_vararg, @call_target, @ary, :block => false]).
+          explicit_targets.should == ::Set[@call_target]
+    end
+    
+    it 'should return the target for a lambda instruction' do
+      ControlFlow::Instruction.new([:lambda, @temp, 'B2']).
+          explicit_targets.should == ::Set[@temp]
+    end
+  end
+
+  describe '#operands' do
+    before(:all) do
+      @temp = Bindings::TemporaryBinding.new('%t1', nil)
+      @call_target = Bindings::TemporaryBinding.new('%t2', nil)
+      @ary = Bindings::TemporaryBinding.new('%t3', nil)
+      @temp_2 = Bindings::TemporaryBinding.new('%t4', nil)
+    end
+
+    it 'should return a set with the returned value for a return node' do
+      ControlFlow::Instruction.new([:return, @temp]).
+          operands.should == [@temp]
+    end
+
+    it 'should return an empty set for a jump node' do
+      ControlFlow::Instruction.new([:jump, 'B1']).
+          operands.should == []
+    end
+
+    it 'should return a set with the branched-on value for a branch node' do
+      ControlFlow::Instruction.new([:branch, @temp, 'b2', 'b3']).
+          operands.should == [@temp]
+    end
+    
+    it 'should return the value temporary for an assign instruction' do
+      ControlFlow::Instruction.new([:assign, @temp, @ary]).
+          operands.should == [@ary]
+    end
+
+    it 'should return the receiver and arguments for a call instruction' do
+      ControlFlow::Instruction.new([:call, @call_target, @temp, 'to_i', @temp_2, :block => false]).
+          operands.should == [@temp, @temp_2]
+    end
+    
+    it 'should return the receiver and arguments for a call_vararg instruction' do
+      ControlFlow::Instruction.new([:call_vararg, @call_target, @temp, 'to_i', @ary, :block => false]).
+          operands.should == [@temp, @ary]
+    end
+
+    it 'should return the arguments for a super instruction' do
+      ControlFlow::Instruction.new([:super, @call_target, @temp_2, :block => false]).
+          operands.should == [@temp_2]
+    end
+    
+    it 'should return the arguments for a super_vararg instruction' do
+      ControlFlow::Instruction.new([:super_vararg, @call_target, @ary, :block => false]).
+          operands.should == [@ary]
+    end
+    
+    it 'should return the empty set for a lambda instruction' do
+      ControlFlow::Instruction.new([:lambda, @temp, 'B2']).
+          operands.should == []
+    end
+  end
+end

data/spec/analysis_specs/control_flow_specs/constant_propagation_spec.rb

@@ -0,0 +1,560 @@
+require_relative 'spec_helper'
+
+describe ControlFlow::ConstantPropagation do
+  it 'should propagate simple constants along linear code' do
+    g = cfg_method <<-EOF
+def foo(x)
+  z = 1024
+  y = z
+  w = y
+end
+EOF
+    g.should have_constant('w').with_value(1024)
+  end
+  
+  it 'should infer constants due to semantics of mismatched parallel assignments' do
+    g = cfg_method <<-EOF
+def foo(x)
+  a, b, c = x, 10
+end
+EOF
+    g.should have_constant('b').with_value(10)
+    g.should have_constant('c').with_value(nil)
+    g.should_not have_constant('a')
+  end
+
+  it 'should infer constants due to semantics of 1-to-N parallel assignment' do
+    g = cfg_method <<-EOF
+def foo(x)
+  a = 1, (2 ** 10), 3
+end
+EOF
+    g.should have_constant('a').with_value([1, 1024, 3])
+  end
+
+  it 'should infer constants due to semantics of 1-to-N parallel assignment with splats' do
+    g = cfg_method <<-EOF
+def foo(x)
+  a = 1, (2 ** 10), 3, *(1..3), 'hi', :a
+end
+EOF
+    g.should have_constant('a').with_value([1, 1024, 3, 1, 2, 3, 'hi', :a])
+  end
+
+  it 'should infer constants due to semantics of N-to-1 parallel assignment' do
+    g = cfg_method <<-EOF
+def foo(x)
+  a, b, c = [1, 2, 3]
+end
+EOF
+    g.should have_constant('a').with_value(1)
+    g.should have_constant('b').with_value(2)
+    g.should have_constant('c').with_value(3)
+  end
+
+  it 'should infer constants due to semantics of mismatched N-to-1 parallel assignment and Array indexing' do
+    g = cfg_method <<-EOF
+def foo(x)
+  a, b, c, d = [1, 2, 3]
+end
+EOF
+    g.should have_constant('a').with_value(1)
+    g.should have_constant('b').with_value(2)
+    g.should have_constant('c').with_value(3)
+    g.should have_constant('d').with_value(nil)
+  end
+
+  it 'should infer constants with LHS star and no RHS star' do
+    g = cfg_method <<-EOF
+def foo(x)
+  a, *b, d = 1, 2, 3, 4
+end
+EOF
+    g.should have_constant('a').with_value(1)
+    g.should have_constant('b').with_value([2, 3])
+    g.should have_constant('d').with_value(4)
+  end
+
+  it 'should infer constants with discarded LHS star and no RHS star' do
+    g = cfg_method <<-EOF
+def foo(x)
+  a, *, d = 1, 2, 3, :a, 'hi', gets, 4
+end
+EOF
+    g.should have_constant('a').with_value(1)
+    g.should have_constant('d').with_value(4)
+  end
+
+  it 'should infer constants with LHS star and no RHS star and mismatched sizes' do
+    g = cfg_method <<-EOF
+def foo(x)
+  a, *b, d, e = 1, 2
+end
+EOF
+    g.should have_constant('a').with_value(1)
+    g.should have_constant('b').with_value([])
+    g.should have_constant('d').with_value(2)
+    g.should have_constant('e').with_value(nil)
+  end
+
+  it 'should infer constants with LHS star and no RHS star and mismatched sizes: part two' do
+    g = cfg_method <<-EOF
+def foo(x)
+  a, b, c, *d = 1, 2
+end
+EOF
+    g.should have_constant('a').with_value(1)
+    g.should have_constant('b').with_value(2)
+    g.should have_constant('c').with_value(nil)
+    g.should have_constant('d').with_value([])
+  end
+  
+  context 'with implicitly-splatted single RHS' do
+    it 'should infer constants with LHS star and no RHS star' do
+      g = cfg_method <<-EOF
+def foo(x)
+  a, *b, d = [1, 2, 3, 4]
+  x = a
+  y = b
+  z = d
+end
+EOF
+      g.should have_constant('x').with_value(1)
+      g.should have_constant('y').with_value([2, 3])
+      g.should have_constant('z').with_value(4)
+    end
+
+    it 'should infer constants with discarded LHS star and no RHS star' do
+      g = cfg_method <<-EOF
+def foo(x)
+  a, *, d = [1, 2, 3, :a, 'hi', {}, 4]
+  x = a
+  y = d
+end
+EOF
+      g.should have_constant('x').with_value(1)
+      g.should have_constant('y').with_value(4)
+    end
+
+    it 'should infer constants with LHS star and no RHS star and mismatched sizes' do
+      g = cfg_method <<-EOF
+def foo(x)
+  a, *b, d, e = [1, 2]
+  rest = b
+  x = d
+  y = e
+end
+EOF
+      g.should have_constant('a').with_value(1)
+      g.should have_constant('rest').with_value([])
+      g.should have_constant('x').with_value(2)
+      g.should have_constant('y').with_value(nil)
+    end
+
+    it 'should infer constants with LHS star and no RHS star and mismatched sizes: part two' do
+      g = cfg_method <<-EOF
+def foo(x)
+  a, b, c, *d = [1, 2]
+  rest = d
+end
+EOF
+      g.should have_constant('a').with_value(1)
+      g.should have_constant('b').with_value(2)
+      g.should have_constant('c').with_value(nil)
+      g.should have_constant('rest').with_value([])
+    end
+  end
+
+  it 'should infer constants with an RHS star' do
+    g = cfg_method <<-EOF
+def foo(x)
+  a, b, c, d, e, f, g, h = *[2, 3, 4], :a, *[5], *['hi'], 9, 10, 11, 12
+end
+EOF
+    g.should have_constant('a').with_value(2)
+    g.should have_constant('b').with_value(3)
+    g.should have_constant('c').with_value(4)
+    g.should have_constant('d').with_value(:a)
+    g.should have_constant('e').with_value(5)
+    g.should have_constant('f').with_value('hi')
+    g.should have_constant('g').with_value(9)
+    g.should have_constant('h').with_value(10)
+  end
+
+  it 'should infer constants with an RHS star and unmet lhs vars' do
+    g = cfg_method <<-EOF
+def foo(x)
+  a, b, c, d, e, f, g, h = *[2, 3, 4], :a
+end
+EOF
+    g.should have_constant('a').with_value(2)
+    g.should have_constant('b').with_value(3)
+    g.should have_constant('c').with_value(4)
+    g.should have_constant('d').with_value(:a)
+    g.should have_constant('e').with_value(nil)
+    g.should have_constant('f').with_value(nil)
+    g.should have_constant('g').with_value(nil)
+    g.should have_constant('h').with_value(nil)
+  end
+  
+  it 'should infer constants with LHS and RHS stars' do
+    g = cfg_method <<-EOF
+def foo(x)
+  a, b, *rest, f, g, h = *[2, 3, 4], :a, *[5], *['hi'], 9, 10, 11, 12
+end
+EOF
+    g.should have_constant('a').with_value(2)
+    g.should have_constant('b').with_value(3)
+    g.should have_constant('rest').with_value([4, :a, 5, 'hi', 9])
+    g.should have_constant('f').with_value(10)
+    g.should have_constant('g').with_value(11)
+    g.should have_constant('h').with_value(12)
+  end
+  
+  it 'should propagate when the same variable is assigned to the same constant in branches' do
+    g = cfg_method <<-EOF
+def foo(x)
+  if gets.size > 0
+    y = 20
+  else
+    y = 20
+  end
+  z = y
+end
+EOF
+    g.should have_constant('z').with_value(20)
+  end
+  
+  it 'should propagate manipulation of hashes' do
+    g = cfg_method <<-EOF
+def foo(x)
+  z = {a: 3, 'd' => 4.5}
+  j = z[:a]
+  arr = z.values
+end
+EOF
+    g.should have_constant('j').with_value(3)
+    g.should have_constant('arr').with_value([3, 4.5])
+  end
+  
+  it 'should not propagate when the same variable is assigned to distinct constants in branches' do
+    g = cfg_method <<-EOF
+def foo(x)
+  if gets.size > 0
+    y = 20
+  else
+    y = 30
+  end
+  z = y
+end
+EOF
+    g.should_not have_constant('z')
+  end
+  
+  it 'should ignore branches on false' do
+    g = cfg_method <<-EOF
+def foo(x)
+  if false
+    y = 40
+  else
+    y = 30
+  end
+  z = y
+end
+EOF
+    g.should have_constant('z').with_value(30)
+  end
+
+  it 'should ignore else branches on true' do
+    g = cfg_method <<-EOF
+def foo(x)
+  if true
+    y = 40
+  else
+    y = 30
+  end
+  z = y
+end
+EOF
+    g.should have_constant('z').with_value(40)
+  end
+  
+  it 'should ignore branches on constant variables' do
+    g = cfg_method <<-EOF
+def foo(x)
+  a = true ? 30 : false
+  if a
+    y = 40
+  else
+    y = 30
+  end
+  z = y
+end
+EOF
+    g.should have_constant('z').with_value(40)
+  end
+  
+  it 'should ignore branches on fixnum equality' do
+    g = cfg_method <<-EOF
+def foo(x)
+  a = true ? 30 : false
+  if a == 30
+    y = 40
+  else
+    y = 30
+  end
+  z = y
+end
+EOF
+    g.should have_constant('z').with_value(40)
+  end
+  
+  it 'should ignore branches on non-constants whose types are never be nil or false' do
+    g = cfg_method <<-EOF
+def foo(x)
+  a = x.nil? ? 30 : 'hello'
+  b = a * 2
+  if b
+    y = 40
+  else
+    y = 30
+  end
+  z = y
+end
+EOF
+    g.should have_constant('z').with_value(40)
+  end
+  
+  it 'should calculate bignum arithmetic' do
+    g = cfg_method <<-EOF
+def foo(x)
+  a = 3 * (1 << 3)
+  b = a ** a
+  c = b - a
+end
+EOF
+    g.should have_constant('c').with_value(1333735776850284124449081472843752)
+  end
+  
+  it 'should handle string constants' 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_constant('a').with_value(3)
+  end
+  
+  it 'should calculate 0 * (varying numeric) = 0' do
+    g = cfg_method <<-EOF
+def foo(x)
+  if gets.size > 0
+    a = 5
+  else
+    a = 10.11
+  end
+  b = 0 * a
+  c = a * 0
+end
+EOF
+    g.should have_constant('b').with_value(0)
+    g.should have_constant('c').with_value(0)
+  end
+
+  it 'should calculate (varying string) * 0 = ""' do
+    g = cfg_method <<-EOF
+def foo(x)
+  if gets.size > 0
+    a = 'hello'
+  else
+    a = 'world'
+  end
+  c = a * 0
+end
+EOF
+    g.should have_constant('c').with_value('')
+  end
+
+  it 'should calculate (varying array) * 0 = []' do
+    g = cfg_method <<-EOF
+def foo(x)
+  if gets.size > 0
+    a = [1, 'hello']
+  else
+    a = [2, 'world', 'thing']
+  end
+  c = a * 0
+end
+EOF
+    g.should have_constant('c').with_value([])
+  end
+
+  it 'should calculate 0 * (varying numeric | string) = varying' do
+    g = cfg_method <<-EOF
+def foo(x)
+  if gets.size > 0
+    a = 5
+  else
+    a = 'hello'
+  end
+  b = 0 * a
+  c = a * 0
+end
+EOF
+    g.should_not have_constant('b')
+    g.should_not have_constant('c')
+  end
+  
+  it 'should calculate (varying numeric) ** 0 = 1' do
+    g = cfg_method <<-EOF
+def foo(x)
+  if gets.size > 0
+    a = 5.93
+  else
+    a = 10
+  end
+  c = a ** 0
+end
+EOF
+    g.should have_constant('c').with_value(1)
+  end
+  
+  it 'should calculate (varying numeric | string) ** 0 = varying' do
+    g = cfg_method <<-EOF
+def foo(x)
+  if gets.size > 0
+    a = 5
+  else
+    a = 'hello'
+  end
+  c = a ** 0
+end
+EOF
+    g.should_not have_constant('c')
+  end
+
+  it 'should calculate 1 ** (varying numeric) = 1' do
+    g = cfg_method <<-EOF
+def foo(x)
+  if gets.size > 0
+    a = 5
+  else
+    a = 10.2
+  end
+  c = 1 ** a
+end
+EOF
+    g.should have_constant('c').with_value(1)
+  end
+
+  it 'should calculate 1 ** (varying numeric | string) = varying' do
+    g = cfg_method <<-EOF
+def foo(x)
+  if gets.size > 0
+    a = 5
+  else
+    a = 'hello'
+  end
+  c = 1 ** a
+end
+EOF
+    g.should_not have_constant('c')
+  end
+  
+  it 'should infer that assignments after a guaranteed raise do not affect CP' do
+    g = cfg_method <<-EOF
+def foo(x)
+  if gets.size > 0
+    a = 5
+  else
+    raise 'arrrrrrr'
+    a = 10.2
+  end
+  c = a
+end
+EOF
+    g.should have_constant('c').with_value(5)
+  end
+
+  it 'should infer that assignments after a guaranteed raise (by CP simulation) do not affect CP' do
+    g = cfg_method <<-EOF
+def foo(x)
+  if gets.size > 0
+    a = 5
+  else
+    a = 5 / 0
+  end
+  c = a
+end
+EOF
+    g.should have_constant('c').with_value(5)
+    g.return_type.should equal_type Types::FIXNUM
+  end
+
+  it 'should always simulate annotated-pure methods' do
+    g = cfg <<-EOF
+module CPSim1
+  # pure: true
+  def self.make(x, y)
+    {x: x, y: y}
+  end
+end
+EOF
+    g2 = cfg_method <<-EOF
+def foo(x)
+  made = CPSim1.make(3, 'foo')
+  z1 = made[:x]
+  z2 = made[:y]
+end
+EOF
+    g2.should have_constant('z1').with_value(3)
+    g2.should have_constant('z2').with_value('foo')
+    g2.return_type.should equal_type Types::STRING
+    ClassRegistry['CPSim1'].singleton_class.instance_method(:make).
+        return_type_for_types(Utilities.type_for(ClassRegistry['CPSim1']),
+          [Types::FIXNUM, Types::STRING], Types::NILCLASS).should equal_type(Types::UnionType.new([Types::HASH]))
+  end
+  
+  it 'should handle the tricky x = y unless defined? x case' do
+    g = cfg_method <<-EOF
+def foo
+  y = 5 unless defined? y
+  z = y
+end
+EOF
+    g.should have_constant('z').with_value(nil)
+  end
+
+  it 'should handle a basic positive defined?(Const) case' do
+    g = cfg <<-EOF
+module CP2
+end
+CP3 = 10 if defined?(CP2)
+EOF
+    ClassRegistry['Object'].const_get('CP3').should == 10
+  end
+
+  it 'should handle a basic negative defined?(Const) case' do
+    g = cfg <<-EOF
+CP4 = 10 unless defined?(CPNone)
+EOF
+    ClassRegistry['Object'].const_get('CP4').should == 10
+  end
+  
+  it 'should handle blocks used in constant propagation' do
+    g = cfg_method <<-EOF
+def foo_blockitized
+  z = %w(a b c).map { |y| y * 2 }
+  10
+end
+EOF
+    g.should have_constant('z').with_value(['aa', 'bb', 'cc'])
+  end
+end