laser 0.7.0.pre1

data/spec/analysis_specs/control_flow_specs/return_type_inference_spec.rb

@@ -0,0 +1,431 @@
+require_relative 'spec_helper'
+
+describe 'CFG-based return type inference' do
+  it 'should infer types based on specified overloads' do
+    g = cfg <<-EOF
+module RTI2
+  def self.multiply(x, y)
+    x * y
+  end
+end
+EOF
+    method = ClassRegistry['RTI2'].singleton_class.instance_method(:multiply)
+    method.return_type_for_types(
+        Utilities.type_for(ClassRegistry['RTI2']), 
+        [Types::FIXNUM, Types::FLOAT]).should equal_type Types::UnionType.new([Types::FLOAT])
+    method.return_type_for_types(
+        Utilities.type_for(ClassRegistry['RTI2']),
+        [Types::FIXNUM, Types::FIXNUM]).should equal_type Types::UnionType.new([Types::FIXNUM, Types::BIGNUM])
+  end
+
+  it 'should infer type errors on methods with specified overloads' do
+    g = cfg <<-EOF
+module RTI3
+  def self.sim3
+    if gets.size > 2
+      x = 'hi'
+    else
+      x = :hi
+    end
+    y = 15 * x
+  end
+end
+EOF
+   ClassRegistry['RTI3'].singleton_class.instance_method(:sim3).
+       return_type_for_types(
+         Utilities.type_for(ClassRegistry['RTI3'])).should == Types::EMPTY
+   g.should have_error(NoMatchingTypeSignature).on_line(8).with_message(/\*/)
+  end
+
+  it 'should infer the type resulting from a simple chain of standard-library methods' do
+    g = cfg <<-EOF
+module RTI4
+  def self.bar
+    x = gets
+    qux(baz(x))
+  end
+  def self.baz(y)
+    y.to_sym.size
+  end
+  def self.qux(z)
+    z.zero?
+  end
+end
+EOF
+    ClassRegistry['RTI4'].singleton_class.instance_method(:bar).
+        return_type_for_types(
+          Utilities.type_for(ClassRegistry['RTI4'])).should equal_type Types::BOOLEAN
+  end
+
+  it 'should infer the type resulting from Class#new' do
+    g = cfg <<-EOF
+module RTI5
+  class Foo
+    def initialize(x, y)
+      @x = x
+      @y = y
+    end
+  end
+  def self.make_a_foo(a, b)
+    Foo.new(a, b)
+  end
+end
+EOF
+    result = Types::UnionType.new([Types::ClassType.new('RTI5::Foo', :invariant)])
+    ClassRegistry['RTI5'].singleton_class.instance_method(:make_a_foo).
+        return_type_for_types(
+          Utilities.type_for(ClassRegistry['RTI5']),
+          [Types::FIXNUM, Types::FLOAT]).should equal_type result
+  end
+
+  it 'should infer types based on SSA, when appropriate' do
+    g = cfg <<-EOF
+module RTI6
+  def self.multiply
+    if $$ > 10
+      a = 'hello'
+    else
+      a = 20
+    end
+    a * 3
+  end
+end
+EOF
+    result = Types::UnionType.new([Types::FIXNUM, Types::BIGNUM, Types::STRING])
+    ClassRegistry['RTI6'].singleton_class.instance_method(:multiply).
+        return_type_for_types(
+          Utilities.type_for(ClassRegistry['RTI6'])).should equal_type result
+  end
+
+  it 'should improve type inference due to SSA, when appropriate' do
+    g = cfg <<-EOF
+module RTI7
+  def self.multiply
+    if $$ > 10
+      a = 'hello'
+    else
+      a = 20
+    end
+    b = a * 3
+    a = 3.14
+    a * 20
+  end
+end
+EOF
+    ClassRegistry['RTI7'].singleton_class.instance_method(:multiply).
+        return_type_for_types(
+          Utilities.type_for(ClassRegistry['RTI7'])).should equal_type Types::FLOAT
+  end
+
+  it 'should handle, via SSA, uninitialized variable types' do
+    g = cfg <<-EOF
+class RTI8
+  def self.switch
+    if $$ > 10
+      a = 'hello'
+    end
+    b = a
+  end
+end
+EOF
+    ClassRegistry['RTI8'].singleton_class.instance_method(:switch).
+        return_type_for_types(
+          Utilities.type_for(ClassRegistry['RTI8'])).should equal_type(
+            Types::UnionType.new([Types::STRING, Types::NILCLASS]))
+  end
+  
+  it 'should warn against certain methods with improper return types' do
+    g = cfg <<-EOF
+class RTI8
+  def to_s
+    gets.strip!  # whoops, ! means nil sometimes
+  end
+end
+EOF
+    ClassRegistry['RTI8'].instance_method(:to_s).
+        return_type_for_types(
+          ClassRegistry['RTI8'].as_type)  # force calculation
+    ClassRegistry['RTI8'].instance_method(:to_s).proc.ast_node.should(
+        have_error(ImproperOverloadTypeError).with_message(/to_s/))
+  end
+
+  it 'should collect inferred types in global variables' do
+    g = cfg <<-EOF
+module RTI9
+  def self.bar
+    $sim9 = x = gets
+    qux(baz(x))
+  end
+  def self.baz(y)
+    $sim9 = y.to_sym.size
+  end
+  def self.qux(z)
+    $sim9
+  end
+end
+EOF
+    # First, qux should give nil
+    ClassRegistry['RTI9'].singleton_class.instance_method(:qux).
+        return_type_for_types(
+          Utilities.type_for(ClassRegistry['RTI9']), [Types::STRING]).should equal_type Types::NILCLASS
+    expected_type = Types::UnionType.new(
+        [Types::STRING, Types::FIXNUM, Types::BIGNUM, Types::NILCLASS])
+    ClassRegistry['RTI9'].singleton_class.instance_method(:bar).
+        return_type_for_types(
+          Utilities.type_for(ClassRegistry['RTI9'])).should equal_type expected_type
+    Scope::GlobalScope.lookup('$sim9').expr_type.should equal_type expected_type
+    ClassRegistry['RTI9'].singleton_class.instance_method(:qux).
+        return_type_for_types(
+          Utilities.type_for(ClassRegistry['RTI9']), [Types::STRING]).should equal_type expected_type
+  end
+  
+  it 'should collect inferred types in instance variables by class' do
+    g = cfg <<-EOF
+class TI1
+  def set_foo(x)
+    @foo = x
+  end
+  def get_foo
+    @foo
+  end
+end
+class TI2
+  def set_foo(x)
+    @foo = x
+  end
+  def get_foo
+    @foo
+  end
+end
+EOF
+    ClassRegistry['TI1'].instance_method(:get_foo).return_type_for_types(
+        ClassRegistry['TI1'].as_type).should equal_type Types::NILCLASS
+    ClassRegistry['TI1'].instance_method(:set_foo).return_type_for_types(
+        ClassRegistry['TI1'].as_type, [Types::STRING]).should equal_type Types::STRING
+    ClassRegistry['TI1'].instance_method(:get_foo).return_type_for_types(
+        ClassRegistry['TI1'].as_type).should equal_type(
+          Types::UnionType.new([Types::NILCLASS, Types::STRING]))
+    ClassRegistry['TI1'].instance_method(:set_foo).return_type_for_types(
+        ClassRegistry['TI1'].as_type, [Types::FIXNUM]).should equal_type Types::FIXNUM
+    ClassRegistry['TI1'].instance_method(:get_foo).return_type_for_types(
+        ClassRegistry['TI1'].as_type).should equal_type(
+          Types::UnionType.new([Types::NILCLASS, Types::STRING, Types::FIXNUM]))
+    
+    ClassRegistry['TI2'].instance_method(:get_foo).return_type_for_types(
+        ClassRegistry['TI2'].as_type).should equal_type Types::NILCLASS
+    ClassRegistry['TI2'].instance_method(:set_foo).return_type_for_types(
+        ClassRegistry['TI2'].as_type, [Types::FIXNUM]).should equal_type Types::FIXNUM
+    ClassRegistry['TI2'].instance_method(:get_foo).return_type_for_types(
+        ClassRegistry['TI2'].as_type).should equal_type(
+          Types::UnionType.new([Types::NILCLASS, Types::FIXNUM]))
+  end
+  
+  it 'should extract argument types from rest arguments by index' do
+    g = cfg <<-EOF
+class RTI11
+  def foo(*args)
+    args[0]
+  end
+  def bar(*args)
+    args[1]
+  end
+end
+EOF
+    ClassRegistry['RTI11'].instance_method(:foo).return_type_for_types(
+      ClassRegistry['RTI11'].as_type, [Types::FIXNUM, Types::PROC]).should equal_type Types::FIXNUM
+    ClassRegistry['RTI11'].instance_method(:bar).return_type_for_types(
+      ClassRegistry['RTI11'].as_type, [Types::FIXNUM, Types::PROC]).should equal_type Types::PROC
+  end
+  
+  it 'should extract argument types from rest arguments by range index' do
+    g = cfg <<-EOF
+class RTI12
+  def foo(*args)
+    args[0..1]
+  end
+  def bar(*args)
+    args[1..3]
+  end
+  def baz(*args)
+    args[-3..4]
+  end
+  def qux(*args)
+    args[-4..4]
+  end
+end
+EOF
+    ClassRegistry['RTI12'].instance_method(:foo).return_type_for_types(
+      ClassRegistry['RTI12'].as_type, [Types::FIXNUM, Types::PROC, Types::TRUECLASS]).should equal_type(
+        Types::TupleType.new([Types::FIXNUM, Types::PROC]))
+    ClassRegistry['RTI12'].instance_method(:bar).return_type_for_types(
+      ClassRegistry['RTI12'].as_type, [Types::STRING, Types::FLOAT, Types::HASH]).should equal_type(
+        Types::TupleType.new([Types::FLOAT, Types::HASH]))
+    ClassRegistry['RTI12'].instance_method(:baz).return_type_for_types(
+      ClassRegistry['RTI12'].as_type, [Types::STRING, Types::FLOAT, Types::HASH]).should equal_type(
+        Types::TupleType.new([Types::STRING, Types::FLOAT, Types::HASH]))
+    ClassRegistry['RTI12'].instance_method(:qux).return_type_for_types(
+      ClassRegistry['RTI12'].as_type, [Types::STRING, Types::FLOAT, Types::HASH]).should equal_type(
+        Types::NILCLASS)
+  end
+  
+  it 'infers tuple types during expansion' do
+    g = cfg <<-EOF
+class RTI13
+  def foo(*args)
+    a, b, c = args
+    a
+  end
+  def bar(*args)
+    a, b, c = args
+    b
+  end
+  def baz(*args)
+    a, b, c = args
+    c
+  end
+end
+EOF
+    ClassRegistry['RTI13'].instance_method(:foo).return_type_for_types(
+      ClassRegistry['RTI13'].as_type, [Types::FIXNUM, Types::PROC, Types::TRUECLASS]).should equal_type(
+        Types::FIXNUM)
+    ClassRegistry['RTI13'].instance_method(:bar).return_type_for_types(
+      ClassRegistry['RTI13'].as_type, [Types::FIXNUM, Types::PROC, Types::TRUECLASS]).should equal_type(
+        Types::PROC)
+    ClassRegistry['RTI13'].instance_method(:baz).return_type_for_types(
+      ClassRegistry['RTI13'].as_type, [Types::FIXNUM, Types::PROC, Types::TRUECLASS]).should equal_type(
+        Types::TRUECLASS)
+    ClassRegistry['RTI13'].instance_method(:baz).return_type_for_types(
+       ClassRegistry['RTI13'].as_type, [Types::FIXNUM, Types::PROC]).should equal_type(
+         Types::NILCLASS)
+  end
+  
+  it 'infers the result of #size on tuples' do
+    g = cfg <<-EOF
+class RTI14
+  def foo(*args)
+    args[args.size - 2]
+  end
+  def bar(*args)
+    args[args.length - 2]
+  end
+  def baz(*args)
+    args[args.size - 4]
+  end
+end
+EOF
+    ClassRegistry['RTI14'].instance_method(:foo).return_type_for_types(
+      ClassRegistry['RTI14'].as_type, [Types::FIXNUM, Types::PROC, Types::TRUECLASS]).should equal_type(
+        Types::PROC)
+    ClassRegistry['RTI14'].instance_method(:bar).return_type_for_types(
+      ClassRegistry['RTI14'].as_type, [Types::FIXNUM, Types::PROC, Types::TRUECLASS]).should equal_type(
+        Types::PROC)
+    ClassRegistry['RTI14'].instance_method(:foo).return_type_for_types(
+      ClassRegistry['RTI14'].as_type, [Types::FIXNUM, Types::PROC]).should equal_type(
+        Types::FIXNUM)
+    ClassRegistry['RTI14'].instance_method(:bar).return_type_for_types(
+      ClassRegistry['RTI14'].as_type, [Types::FIXNUM, Types::PROC]).should equal_type(
+        Types::FIXNUM)
+    ClassRegistry['RTI14'].instance_method(:baz).return_type_for_types(
+      ClassRegistry['RTI14'].as_type, [Types::FIXNUM, Types::PROC, Types::TRUECLASS]).should equal_type(
+        Types::TRUECLASS)
+  end
+  
+  it 'infers the type of #to_a/ary on tuples' do
+    g = cfg <<-EOF
+class RTI15
+  def foo(*args)
+    args.to_a.to_ary.to_a.to_a
+  end
+end
+EOF
+    ClassRegistry['RTI15'].instance_method(:foo).return_type_for_types(
+      ClassRegistry['RTI15'].as_type, [Types::FIXNUM, Types::PROC, Types::TRUECLASS]).should equal_type(
+        Types::TupleType.new([Types::FIXNUM, Types::PROC, Types::TRUECLASS]))
+  end
+  
+  it 'infers tuple types from array literals' do
+    g = cfg <<-EOF
+class RTI16
+  def foo
+    [1, :foo, 'string', {}]
+  end
+end
+EOF
+    ClassRegistry['RTI16'].instance_method(:foo).return_type_for_types(
+      ClassRegistry['RTI16'].as_type).should equal_type(
+        Types::TupleType.new([Types::FIXNUM, ClassRegistry['Symbol'].as_type,
+                              Types::STRING, Types::HASH]))
+  end
+
+  it 'infers tuple types from array literals with varying components' do
+    g = cfg <<-EOF
+class RTI17
+  def foo(x)
+    [x, :foo, 'string', {}]
+  end
+end
+EOF
+    ClassRegistry['RTI17'].instance_method(:foo).return_type_for_types(
+      ClassRegistry['RTI17'].as_type, [Types::FIXNUM]).should equal_type(
+        Types::TupleType.new([Types::FIXNUM, ClassRegistry['Symbol'].as_type,
+                              Types::STRING, Types::HASH]))
+  end
+  
+  it 'infers through calls to super' do
+    g = cfg <<-EOF
+class RTI18
+  def foo(x)
+    "Hello \#{x}"
+  end
+end
+class RTI19 < RTI18
+  def foo(x, y)
+    super(y).size
+  end
+end
+class RTI20 < RTI19
+  def foo(x, y)
+    z = super
+    z.to_s
+  end
+end
+EOF
+    ClassRegistry['RTI18'].instance_method(:foo).return_type_for_types(
+      ClassRegistry['RTI18'].as_type, [Types::FIXNUM]).should equal_type(Types::STRING)
+    ClassRegistry['RTI19'].instance_method(:foo).return_type_for_types(
+      ClassRegistry['RTI19'].as_type, [Types::FIXNUM, Types::STRING]).should equal_type(
+        Types::FIXNUM | Types::BIGNUM)
+    ClassRegistry['RTI20'].instance_method(:foo).return_type_for_types(
+      ClassRegistry['RTI20'].as_type, [Types::FIXNUM, Types::STRING]).should equal_type(
+        Types::STRING)
+  end
+
+  it 'infers tuple types from tuple addition' do
+g = cfg <<-EOF
+class RTI22
+  def foo(x)
+    [x, :foo] + ['foobar', x]
+  end
+end
+EOF
+    ClassRegistry['RTI22'].instance_method(:foo).return_type_for_types(
+      ClassRegistry['RTI22'].as_type, [Types::FIXNUM]).should equal_type(
+        Types::TupleType.new([Types::FIXNUM, ClassRegistry['Symbol'].as_type,
+                              Types::STRING, Types::FIXNUM]))
+  end
+
+  it 'infers tuple types from tuple multiplication' do
+g = cfg <<-EOF
+class RTI21
+  def foo(x)
+    [x, :foo] * 3
+  end
+end
+EOF
+    ClassRegistry['RTI21'].instance_method(:foo).return_type_for_types(
+      ClassRegistry['RTI21'].as_type, [Types::FIXNUM]).should equal_type(
+        Types::TupleType.new([Types::FIXNUM, ClassRegistry['Symbol'].as_type,
+                              Types::FIXNUM, ClassRegistry['Symbol'].as_type,
+                              Types::FIXNUM, ClassRegistry['Symbol'].as_type]))
+  end
+end

data/spec/analysis_specs/control_flow_specs/simulation_spec.rb

@@ -0,0 +1,158 @@
+require_relative 'spec_helper'
+
+describe ControlFlow::Simulation do
+  it 'should create classes during toplevel simulation' do
+    g = cfg <<-EOF
+class Sim1 < Hash
+end
+EOF
+    ClassRegistry['Sim1'].should_not be nil
+    ClassRegistry['Sim1'].superclass.should == ClassRegistry['Hash']
+  end
+  
+  it 'should create methods during toplevel simulation' do
+    g = cfg <<-EOF
+class Sim2
+  def foo(x, y)
+  end
+end
+EOF
+    ClassRegistry['Sim2'].instance_method(:foo).should_not be_nil
+  end
+  
+  it 'should simulate toplevel alias_method calls' do
+    g = cfg <<-EOF
+class Sim3
+  def foo(x, y)
+  end
+  alias_method :bar, :foo
+end
+EOF
+    ClassRegistry['Sim3'].instance_method(:foo).should ==
+        ClassRegistry['Sim3'].instance_method(:bar)
+  end
+
+  it 'should simulate toplevel general calls' do
+    g = cfg %q{
+class Sim4
+  class << self
+    def alias_method_chain(name, suffix)
+      alias_method "#{name}_without_#{suffix}", name
+      alias_method name, "#{name}_with_#{suffix}"
+    end
+  end
+
+  def foo(x, y)
+  end
+  def foo_with_fun(x, y)
+  end
+end
+}
+    old_foo = ClassRegistry['Sim4'].instance_method(:foo)
+    new_foo = ClassRegistry['Sim4'].instance_method(:foo_with_fun)
+    g2 = cfg %q{
+class Sim4
+  alias_method_chain :foo, :fun
+end
+}
+    ClassRegistry['Sim4'].instance_method(:foo_without_fun).should == old_foo
+    ClassRegistry['Sim4'].instance_method(:foo).should == new_foo
+  end
+  
+  it 'should simulate ruby-level attr_{reader,writer,accessor} calls' do
+    g = cfg %q{
+class Sim5
+  attr_reader :foo, :bar
+  attr_writer :baz
+  attr_accessor :qux, :pie
+end
+}
+
+    %w(foo bar qux pie).each do |name|
+      method = ClassRegistry['Sim5'].instance_method(name)
+      method.should be_a(LaserMethod)
+      method.arity.should == Arity.new(0..0)
+    end
+
+    %w(baz= qux= pie=).each do |name|
+      method = ClassRegistry['Sim5'].instance_method(name)
+      method.should be_a(LaserMethod)
+      method.arity.should == Arity.new(1..1)
+    end
+  end
+
+  it 'should simulate blocks being called by builtins' do
+    g = cfg %q{
+input = (1..10).to_a
+output = input.map do |x|
+  x ** x
+end
+}
+
+    expected = (1..10).map { |x| x ** x }
+    g.var_named('output').value.should == expected
+  end
+  
+  it 'should simulate #define_method with a block' do
+    g = cfg %q{
+class Sim6
+  [1, 2].each do |multiplicand|
+    define_method("times_#{multiplicand}") { |x| x * multiplicand }
+  end
+end
+}
+    method = ClassRegistry['Sim6'].instance_method(:times_1)
+    method.should be_a(LaserMethod)
+    method.arity.should == Arity.new(1..1)
+    method = ClassRegistry['Sim6'].instance_method(:times_1)
+    method.should be_a(LaserMethod)
+    method.arity.should == Arity.new(1..1)
+  end
+  
+  
+  it 'should give up on simulation and turn to constant propagation when unpredictability occurs' do
+    g = cfg %q{
+class Sim7
+  def foo(str)
+    bar(str[0..3]).size
+  end
+  def bar(substr)
+    substr.split(//)
+  end
+end
+SimVal8 = Sim7.new.foo(gets)
+}
+    ClassRegistry['Sim7'].instance_method(:bar).return_type_for_types(
+        ClassRegistry['Sim7'].as_type, [Types::STRING]).should equal_type Types::UnionType.new([Types::ARRAY])
+    ClassRegistry['Sim7'].instance_method(:foo).return_type_for_types(
+        ClassRegistry['Sim7'].as_type, [Types::STRING]).should equal_type Types::UnionType.new([Types::FIXNUM])
+  end
+  
+  it 'should simulate calls to super' do
+    g = cfg %q{
+class Sim8
+  def foo(x, y)
+    x * y
+  end
+end
+class Sim8B < Sim8
+  def foo(x)
+    super(x, 5)
+  end
+end
+fifty = Sim8B.new.foo(10)
+string = Sim8B.new.foo('xx')
+}
+    g.var_named('fifty').value.should == 50
+    g.var_named('string').value.should == 'xxxxxxxxxx'
+  end
+  
+  # passes, but takes fucking forever
+  # it 'should add an error when simulation fails to terminate' do
+  #   input = 'x = 1 while true'
+  #   tree = annotate_all(input)
+  #   tree.all_errors.size.should be 1
+  #   tree.all_errors.first.should be_a(TopLevelSimulationRaised)
+  #   tree.all_errors.first.error.should be_a(ControlFlow::Simulation::SimulationNonterminationError)
+  # end
+end