furnace 0.4.0.beta.1 → 0.4.0.beta.2

data/lib/furnace/type/value.rb

@@ -0,0 +1,13 @@
+module Furnace
+  class Type::Value < Type::Top
+    attr_reader :value
+
+    def initialize(value)
+      @value = value
+    end
+
+    def to_s
+      %{'#{@value.inspect}}
+    end
+  end
+end

data/lib/furnace/type/variable.rb

@@ -0,0 +1,61 @@
+module Furnace
+  class Type::Variable
+    def initialize
+      freeze
+    end
+
+    def to_type
+      self
+    end
+
+    def subtype_of?(other)
+      other.instance_of?(Type::Top) ||
+          self == other
+    end
+
+    def supertype_of?(other)
+      other.subtype_of?(self)
+    end
+
+    def variable?
+      true
+    end
+
+    def replace_type_with(type, replacement)
+      if self == type
+        replacement.to_type
+      else
+        self
+      end
+    end
+
+    def specialize(other)
+      { self => other }
+    end
+
+    def awesome_print(p=AwesomePrinter.new)
+      p.type_variable self
+    end
+  end
+
+  class Type::Variable::Annotator
+    def initialize
+      @last_annotation = "a"
+
+      @annotations = Hash.new do |hash, var|
+        unless var.is_a? Type::Variable
+          raise ArgumentError, "#{self.class} cannot annotate #{var.class}"
+        end
+
+        annotation       = @last_annotation
+        @last_annotation = @last_annotation.succ
+
+        hash[var] = annotation
+      end
+    end
+
+    def annotate(var)
+      @annotations[var]
+    end
+  end
+end

data/lib/furnace/version.rb

@@ -1,3 +1,3 @@
 module Furnace
-  VERSION = "0.4.0.beta.1"
+  VERSION = "0.4.0.beta.2"
 end

data/test/{test_helper.rb → helper.rb}

@@ -19,7 +19,32 @@ end
 require 'simplecov'
 SimpleCov.start
 
-$LOAD_PATH << File.expand_path('../../lib', __FILE__)
-
 require 'furnace'
-include Furnace
+include Furnace
+
+class RubyType < Type::Top
+  attr_reader :ruby_type
+
+  def initialize(ruby_type)
+    @ruby_type = ruby_type
+  end
+
+  def ==(other)
+    other.instance_of?(RubyType) &&
+        @ruby_type == other.ruby_type
+  end
+
+  def hash
+    [self.class, @ruby_type].hash
+  end
+
+  def to_s
+    "^#{@ruby_type}"
+  end
+end
+
+class Class
+  def to_type
+    RubyType.new(self)
+  end
+end

data/test/{ast_test.rb → test_ast.rb}

@@ -1,4 +1,4 @@
-require_relative 'test_helper'
+require_relative 'helper'
 
 describe AST::Node do
   extend Furnace::AST::Sexp
@@ -107,6 +107,18 @@ describe AST::Node do
     var_name.should.equal :$foo
     value.should.equal s(:integer, 1)
   end
+
+  it 'should concatenate with arrays' do
+    node = s(:gasgn, :$foo)
+    (node + [s(:integer, 1)]).
+        should.equal s(:gasgn, :$foo, s(:integer, 1))
+  end
+
+  it 'should append elements' do
+    node = s(:array)
+    (node << s(:integer, 1) << s(:string, "foo")).
+        should.equal s(:array, s(:integer, 1), s(:string, "foo"))
+  end
 end
 
 describe AST::Processor do

data/test/test_awesome_printer.rb

@@ -0,0 +1,148 @@
+require_relative 'helper'
+
+describe AwesomePrinter do
+  AwesomePrinter.colorize = false
+
+  it 'outputs chunks' do
+    AwesomePrinter.new do |p|
+      p.text 'foo'
+    end.should == 'foo'
+
+    AwesomePrinter.new do |p|
+      Integer.to_type.awesome_print(p)
+    end.should == '^Integer'
+
+    AwesomePrinter.new do |p|
+      p.keyword 'bar'
+    end.should == 'bar'
+  end
+
+  it 'supports matching by =~' do
+    AwesomePrinter.new do |p|
+      p.text 'foo'
+    end.should =~ /foo/
+  end
+
+  it 'ensures space between chunks' do
+    AwesomePrinter.new do |p|
+      p.text 'foo'
+      p.keyword 'doh'
+      p.text 'bar'
+    end.should == 'foo doh bar'
+  end
+
+  it 'adds no space before and after #append' do
+    AwesomePrinter.new do |p|
+      p.text 'foo'
+      p.append 'bar'
+      p.text 'baz'
+    end.should == 'foobarbaz'
+  end
+
+  it 'adds no space after #newline' do
+    AwesomePrinter.new do |p|
+      p.text 'foo'
+      p.newline
+      p.text 'bar'
+    end.should == "foo\nbar"
+  end
+
+  it 'converts objects to chunks with to_s' do
+    AwesomePrinter.new do |p|
+      p.text :foo
+      p.text 1
+      p.keyword :bar
+    end.should == 'foo 1 bar'
+  end
+
+  it 'when nesting, delegates to #awesome_print and then #to_s' do
+    with_awesome_print = Object.new.tap do |o|
+      def o.awesome_print(p)
+        p.text "awesome print"
+      end
+    end
+
+    with_inspect = Object.new.tap do |o|
+      def o.to_s
+        "awesome to_s"
+      end
+    end
+
+    AwesomePrinter.new do |p|
+      p.nest with_awesome_print
+      p.nest with_inspect
+    end.should == 'awesome print awesome to_s'
+  end
+
+  it 'prints %names' do
+    AwesomePrinter.new do |p|
+      p.name 'foo'
+    end.should == '%foo'
+  end
+
+  it 'prints type variables' do
+    a, b = 2.times.map { Type::Variable.new }
+
+    AwesomePrinter.new do |p|
+      p.type_variable a
+      p.type_variable b
+      p.type_variable a
+    end.should == '~a ~b ~a'
+  end
+
+  it 'prints type variables with passed Annotator' do
+    a, b = 2.times.map { Type::Variable.new }
+
+    ann = Type::Variable::Annotator.new
+    ann.annotate a
+
+    AwesomePrinter.new(false, ann) do |p|
+      p.type_variable b
+    end.should == '~b'
+  end
+
+  it 'prints collections' do
+    AwesomePrinter.new do |p|
+      p.collection(%w(a b c))
+    end.should == 'abc'
+
+    AwesomePrinter.new do |p|
+      p.collection('<', '; ', '>', %w(a b c))
+    end.should == '<a; b; c>'
+  end
+
+  it 'ensures space before collections' do
+    AwesomePrinter.new do |p|
+      p.text 'foo'
+      p.collection(%w(a b c))
+    end.should == 'foo abc'
+  end
+
+  it 'prints collections with custom iterator' do
+    AwesomePrinter.new do |p|
+      p.collection(%w(abc def)) do |e|
+        p.text e.reverse
+      end
+    end.should == 'cbafed'
+  end
+
+  it 'chains' do
+    AwesomePrinter.new do |p|
+      p.append("foo").should == p
+      p.text("foo").should == p
+      p.newline.should == p
+      p.nest("foo").should == p
+      p.name("foo").should == p
+      p.type("foo").should == p
+      p.type_variable(Type::Variable.new).should == p
+      p.keyword("foo").should == p
+      p.collection(%w(a b)).should == p
+    end
+  end
+
+  it 'adds colors if requested' do
+    AwesomePrinter.new(true) do |p|
+      p.keyword :bar
+    end.should == "\e[1;37mbar\e[0m"
+  end
+end

data/test/{ssa_test.rb → test_ssa.rb}

@@ -1,27 +1,7 @@
-require_relative 'test_helper'
+require_relative 'helper'
 
 describe SSA do
-  SSA::PrettyPrinter.colorize = false
-
-  class SSARubyType < SSA::GenericType
-    def initialize(ruby_type)
-      @ruby_type = ruby_type
-    end
-
-    def parameters
-      [@ruby_type]
-    end
-
-    def inspect
-      "^#{@ruby_type}"
-    end
-  end
-
-  class Class
-    def to_type
-      SSARubyType.new(self)
-    end
-  end
+  AwesomePrinter.colorize = false
 
   class BindingInsn < SSA::Instruction
     def type
@@ -31,7 +11,11 @@ describe SSA do
 
   class DupInsn < SSA::Instruction
     def type
-      operands.first.type
+      if operands
+        operands.first.type
+      else
+        Type::Top.new
+      end
     end
   end
 
@@ -47,8 +31,8 @@ describe SSA do
   class CondBranchInsn < SSA::TerminatorInstruction
     syntax do |s|
       s.operand :condition
-      s.operand :if_true,  SSA::BasicBlock
-      s.operand :if_false, SSA::BasicBlock
+      s.operand :if_true
+      s.operand :if_false
     end
 
     def exits?
@@ -56,6 +40,9 @@ describe SSA do
     end
   end
 
+  class IsBInsn < SSA::Instruction
+  end
+
   module TestScope
     include SSA
 
@@ -74,129 +61,35 @@ describe SSA do
 
   before do
     @function    = SSA::Function.new('foo')
-    @basic_block = SSA::BasicBlock.new(@function)
+    @basic_block = SSA::BasicBlock.new
     @function.add @basic_block
     @function.entry = @basic_block
   end
 
-  def insn_noary(basic_block)
-    BindingInsn.new(basic_block)
+  def insn_noary
+    BindingInsn.new
   end
 
-  def insn_unary(basic_block, what)
-    DupInsn.new(basic_block, [what])
+  def insn_unary(what)
+    DupInsn.new([what])
   end
 
-  def insn_binary(basic_block, left, right)
-    TupleConcatInsn.new(basic_block, [left, right])
+  def insn_binary(left, right)
+    TupleConcatInsn.new([left, right])
   end
 
   it 'converts class names to opcodes' do
     SSA.class_name_to_opcode(DupInsn).should == 'dup'
     SSA.class_name_to_opcode(TupleConcatInsn).should == 'tuple_concat'
     SSA.class_name_to_opcode(TestScope::NestedInsn).should == 'nested'
+    SSA.class_name_to_opcode(IsBInsn).should == 'is_b'
   end
 
   it 'converts opcodes to class names' do
     SSA.opcode_to_class_name('foo').should == 'FooInsn'
     SSA.opcode_to_class_name('foo_bar').should == 'FooBarInsn'
     SSA.opcode_to_class_name(:foo_bar).should == 'FooBarInsn'
-  end
-
-  describe SSA::PrettyPrinter do
-    it 'outputs chunks' do
-      SSA::PrettyPrinter.new do |p|
-        p.text 'foo'
-      end.to_s.should == 'foo'
-
-      SSA::PrettyPrinter.new do |p|
-        p.type Integer.to_type
-      end.to_s.should == '^Integer'
-
-      SSA::PrettyPrinter.new do |p|
-        p.keyword 'bar'
-      end.to_s.should == 'bar'
-    end
-
-    it 'ensures space between chunks' do
-      SSA::PrettyPrinter.new do |p|
-        p.text 'foo'
-        p.keyword 'doh'
-        p.text 'bar'
-      end.to_s.should == 'foo doh bar'
-    end
-
-    it 'adds no space inside #text chunk' do
-      SSA::PrettyPrinter.new do |p|
-        p.text 'foo', 'bar'
-        p.keyword 'squick'
-      end.to_s.should == 'foobar squick'
-    end
-
-    it 'adds no space after newline' do
-      SSA::PrettyPrinter.new do |p|
-        p.text 'foo'
-        p.newline
-        p.text 'bar'
-      end.to_s.should == "foo\nbar"
-    end
-
-    it 'converts objects to chunks with to_s' do
-      SSA::PrettyPrinter.new do |p|
-        p.text :foo
-        p.text 1
-        p.keyword :bar
-      end.to_s.should == 'foo 1 bar'
-    end
-
-    it 'adds colors if requested' do
-      SSA::PrettyPrinter.new(true) do |p|
-        p.keyword :bar
-      end.to_s.should == "\e[1;37mbar\e[0m"
-    end
-  end
-
-  describe SSA::Type do
-    before do
-      @type = SSA::Type.new
-    end
-
-    it 'converts to type' do
-      @type.to_type.should.be.equal @type
-    end
-
-    it 'is a monotype' do
-      @type.should.be.monotype
-    end
-
-    it 'should be ==, eql?, subtype_of? and have the same hash as another instance' do
-      other = SSA::Type.new
-      @type.should == other
-      @type.should.be.eql other
-      @type.should.be.subtype_of other
-      @type.hash.should == other.hash
-    end
-
-    describe SSA::GenericType do
-      before do
-        @type = Integer.to_type
-      end
-
-      it 'should compare its parameters' do
-        otheri = Integer.to_type
-        otherf = Float.to_type
-
-        @type.should == otheri
-        @type.should.be.eql otheri
-        @type.should.be.subtype_of otheri
-        @type.hash.should == otheri.hash
-
-        @type.should.not == otherf
-        @type.should.not.be.eql otherf
-        @type.should.not.be.subtype_of otherf
-        @type.hash.should.not == otherf.hash
-      end
-    end
+    SSA.opcode_to_class_name(:is_b).should == 'IsBInsn'
   end
 
   describe SSA::Value do
@@ -204,8 +97,8 @@ describe SSA do
       @val = SSA::Value.new
     end
 
-    it 'has void type' do
-      @val.type.should == SSA.void
+    it 'has bottom type' do
+      @val.type.should == Type::Bottom.new
     end
 
     it 'is not constant' do
@@ -221,7 +114,7 @@ describe SSA do
     end
 
     it 'pretty prints' do
-      @val.pretty_print.should =~ %r{#<Furnace::SSA::Value}
+      @val.awesome_print.should =~ %r{#<Furnace::SSA::Value}
     end
 
     it 'has an use list' do
@@ -244,7 +137,7 @@ describe SSA do
     it 'can have all of its uses replaced' do
       val1, val2 = 2.times.map { SSA::Value.new }
 
-      user = SSA::User.new(@function, [val1])
+      user = SSA::User.new([val1], 'foo')
 
       val1.replace_all_uses_with(val2)
 
@@ -259,7 +152,7 @@ describe SSA do
     end
 
     it 'pretty prints' do
-      @imm.pretty_print.should == '^Integer 1'
+      @imm.awesome_print.should == '^Integer 1'
     end
 
     it 'converts to value' do
@@ -279,49 +172,32 @@ describe SSA do
     end
   end
 
-  describe SSA::VoidType do
-    it 'allows to retrieve a constant' do
-      const = SSA.void_value
-      const.should.be.constant
-      const.type.should.be.instance_of SSA::VoidType
-    end
-
-    it 'inspects as void' do
-      SSA.void.inspect.should == 'void'
-    end
-
-    it 'inspects as void in constants' do
-      SSA.void_value.inspect.should == 'void'
-    end
-  end
-
   describe SSA::NamedValue do
     it 'receives unique names' do
-      values = 5.times.map { SSA::NamedValue.new(@function, nil) }
-      values.map(&:name).uniq.count.should == values.size
+      values = 5.times.map do
+        v = SSA::NamedValue.new(nil)
+        v.function = @function
+        v
+      end
+
+      values.map(&:name).uniq.size.should == 5
     end
 
     it 'receives unique names even if explicitly specified name conflicts' do
-      i1 = SSA::NamedValue.new(@function, "foo")
-      i2 = SSA::NamedValue.new(@function, "foo")
-      i2.name.should.not == i1.name
+      i1 = SSA::NamedValue.new("foo")
+      i1.function = @function
 
-      i2.name = 'foo'
+      i2 = SSA::NamedValue.new("foo")
+      i2.name.should == i1.name
+
+      i2.function = @function
       i2.name.should.not == i1.name
     end
   end
 
   describe SSA::Argument do
     before do
-      @val = SSA::Argument.new(@function, nil, 'foo')
-    end
-
-    it 'pretty prints' do
-      SSA::Argument.new(@function, nil, 'baz').pretty_print.
-          should == '<?> %baz'
-
-      SSA::Argument.new(@function, Integer, 'bar').pretty_print.
-          should == '^Integer %bar'
+      @val = SSA::Argument.new(Integer, 'foo')
     end
 
     it 'converts to value' do
@@ -334,15 +210,24 @@ describe SSA do
     end
 
     it 'compares by identity' do
-      @val.should.not == SSA::Argument.new(@function, nil, 'foo')
+      @val.should.not == SSA::Argument.new(Integer, 'foo')
     end
 
     it 'is not constant' do
       @val.should.not.be.constant
     end
 
-    it 'has side effects' do
-      @val.has_side_effects?.should == true
+    it 'replaces its type' do
+      ty = Type::Variable.new
+
+      val = SSA::Argument.new(ty, 'foo')
+      val.replace_type_with(ty, Integer.to_type)
+      val.type.should == Integer.to_type
+    end
+
+    it 'pretty prints' do
+      @val.awesome_print.
+          should == '^Integer %foo'
     end
   end
 
@@ -350,14 +235,14 @@ describe SSA do
     it 'enumerates operands' do
       val1, val2 = 2.times.map { SSA::Value.new }
 
-      user = SSA::User.new(@function, [val1, val2])
+      user = SSA::User.new([val1, val2])
       user.should.enumerate :each_operand, [val1, val2]
     end
 
     it 'populates use lists' do
       val  = SSA::Value.new
 
-      user = SSA::User.new(@function)
+      user = SSA::User.new
       val.should.enumerate :each_use, []
 
       user.operands = [val]
@@ -367,7 +252,7 @@ describe SSA do
     it 'updates use lists' do
       val1, val2 = 2.times.map { SSA::Value.new }
 
-      user = SSA::User.new(@function)
+      user = SSA::User.new
       val1.should.enumerate :each_use, []
       val2.should.enumerate :each_use, []
 
@@ -382,17 +267,17 @@ describe SSA do
 
     it 'detaches from values' do
       val  = SSA::Value.new
-      user = SSA::User.new(@function, [val])
+      user = SSA::User.new([val])
 
       val.should.enumerate :each_use, [user]
-      user.detach
+      user.drop_references
       val.should.enumerate :each_use, []
     end
 
     it 'can replace uses of values' do
       val1, val2 = 2.times.map { SSA::Value.new }
 
-      user = SSA::User.new(@function, [val1])
+      user = SSA::User.new([val1])
       user.replace_uses_of(val1, val2)
 
       val1.should.enumerate :each_use, []
@@ -402,7 +287,7 @@ describe SSA do
     it 'barfs on #replace_uses_of if the value is not used' do
       val1, val2 = 2.times.map { SSA::Value.new }
 
-      user = SSA::User.new(@function, [val1])
+      user = SSA::User.new([val1])
 
       -> { user.replace_uses_of(val2, val1) }.should.raise ArgumentError
     end
@@ -410,106 +295,132 @@ describe SSA do
 
   describe SSA::Instruction do
     it 'is not terminator' do
-      i = insn_noary(@basic_block)
+      i = insn_noary
       i.should.not.be.terminator
     end
 
     it 'does not have side effects' do
-      i = insn_noary(@basic_block)
+      i = insn_noary
       i.has_side_effects?.should == false
     end
 
     it 'removes itself from basic block' do
-      i = insn_noary(@basic_block)
+      i = insn_noary
       @basic_block.append i
 
       i.remove
       @basic_block.to_a.should.be.empty
+      i.operands.should == []
+    end
+
+    it 'erases itself from basic block' do
+      i = insn_noary
+      @basic_block.append i
+
+      i.erase
+      @basic_block.to_a.should.be.empty
+      i.operands.should == nil
     end
 
     it 'replaces uses of itself with instructions' do
-      i1 = insn_noary(@basic_block)
+      i1 = insn_noary
       @basic_block.append i1
 
-      i2 = insn_unary(@basic_block, i1)
+      i2 = insn_unary(i1)
       @basic_block.append i2
 
-      i1a = insn_noary(@basic_block)
+      i1a = insn_noary
       i1.replace_with i1a
+      i1.operands.should == nil
 
       @basic_block.to_a.should == [i1a, i2]
       i2.operands.should == [i1a]
     end
 
     it 'replaces uses of itself with constants' do
-      i1 = insn_noary(@basic_block)
+      i1 = insn_noary
       @basic_block.append i1
 
-      i2 = insn_unary(@basic_block, i1)
+      i2 = insn_unary(i1)
       @basic_block.append i2
 
       c1 = SSA::Constant.new(Integer, 1)
       i1.replace_with c1
+      i1.operands.should == nil
 
       @basic_block.to_a.should == [i2]
       i2.operands.should == [c1]
     end
 
     it 'pretty prints' do
-      dup = DupInsn.new(@basic_block, [SSA::Constant.new(Integer, 1)])
-      dup.pretty_print.should == '^Integer %2 = dup ^Integer 1'
-      dup.inspect_as_value.should == '%2'
+      dup = DupInsn.new([SSA::Constant.new(Integer, 1)])
+      dup.basic_block = @basic_block
+      dup.awesome_print.should =~ /\^Integer %\d+ = dup \^Integer 1/
+      dup.awesome_print_as_value.should =~ /^%\d+/
 
-      concat = TupleConcatInsn.new(@basic_block,
+      concat = TupleConcatInsn.new(
           [SSA::Constant.new(Array, [1]), SSA::Constant.new(Array, [2,3])])
-      concat.pretty_print.should == '^Array %3 = tuple_concat ^Array [1], ^Array [2, 3]'
-      concat.inspect_as_value.should == '%3'
+      concat.basic_block = @basic_block
+      concat.awesome_print.should =~ /\^Array %\d+ = tuple_concat \^Array \[1\], \^Array \[2, 3\]/
+      concat.awesome_print_as_value.should =~ /^%\d+/
 
-      zero_arity = BindingInsn.new(@basic_block)
-      zero_arity.pretty_print.should == '^Binding %4 = binding'
-      zero_arity.inspect_as_value.should == '%4'
+      zero_arity = BindingInsn.new
+      zero_arity.basic_block = @basic_block
+      zero_arity.awesome_print.should =~ /\^Binding %\d+ = binding/
+      zero_arity.awesome_print_as_value.should =~ /^%\d+/
 
-      zero_all = TestScope::NestedInsn.new(@basic_block)
-      zero_all.pretty_print.should == 'nested'
-      zero_all.inspect_as_value.should == 'void'
+      zero_all = TestScope::NestedInsn.new
+      zero_all.basic_block = @basic_block
+      zero_all.awesome_print.should == 'nested'
+      zero_all.awesome_print_as_value.should == 'bottom'
     end
 
     describe SSA::GenericInstruction do
       it 'has settable type' do
-        i = GenericInsn.new(@basic_block, Integer, [])
-        i.pretty_print.should =~ /\^Integer %\d+ = generic/
+        i = GenericInsn.new(Integer, [])
+        i.basic_block = @basic_block
+        i.awesome_print.should =~ /\^Integer %\d+ = generic/
         i.type = Binding
-        i.pretty_print.should =~ /\^Binding %\d+ = generic/
+        i.awesome_print.should =~ /\^Binding %\d+ = generic/
+      end
+
+      it 'replaces its type' do
+        ty = Type::Variable.new
+
+        i = GenericInsn.new(ty, [])
+        i.replace_type_with(ty, Integer.to_type)
+        i.type.should == Integer.to_type
       end
 
       describe SSA::PhiInsn do
         it 'accepts operand hash' do
           -> {
-            phi = SSA::PhiInsn.new(@basic_block, nil,
+            phi = SSA::PhiInsn.new(Integer,
                 { @basic_block => SSA::Constant.new(Integer, 1) })
           }.should.not.raise
         end
 
         it 'enumerates operands' do
           val1, val2 = 2.times.map { SSA::Value.new }
-          bb1,  bb2  = 2.times.map { SSA::BasicBlock.new(@function) }
+          bb1,  bb2  = 2.times.map { SSA::BasicBlock.new }
 
-          phi = SSA::PhiInsn.new(@basic_block, nil,
+          phi = SSA::PhiInsn.new(Integer,
               { bb1 => val1, bb2 => val2 })
           phi.should.enumerate :each_operand, [val1, val2, bb1, bb2]
         end
 
         it 'pretty prints' do
-          phi = SSA::PhiInsn.new(@basic_block, nil,
+          phi = SSA::PhiInsn.new(Integer,
               { @basic_block => SSA::Constant.new(Integer, 1) })
-          phi.pretty_print.should =~
-            /<?> %\d = phi %\d => \^Integer 1/
+          phi.basic_block = @basic_block
+          phi.awesome_print.should =~
+            /\^Integer %\d = phi %\d => \^Integer 1/
         end
 
         it 'maintains use chains' do
           val = SSA::Value.new
-          phi = SSA::PhiInsn.new(@basic_block, nil,
-              { @basic_block => val })
+          phi = SSA::PhiInsn.new(Integer,
+                    { @basic_block => val })
           val.should.enumerate :each_use, [phi]
           @basic_block.should.enumerate :each_use, [phi]
         end
@@ -517,8 +428,8 @@ describe SSA do
         it 'can replace uses of values' do
           val1, val2 = 2.times.map { SSA::Value.new }
 
-          phi = SSA::PhiInsn.new(@basic_block, nil,
-              { @basic_block => val1 })
+          phi = SSA::PhiInsn.new(Integer,
+                    { @basic_block => val1 })
           phi.replace_uses_of(val1, val2)
 
           val1.should.enumerate :each_use, []
@@ -527,9 +438,9 @@ describe SSA do
 
         it 'can replace uses of basic blocks' do
           val = SSA::Value.new
-          bb2 = SSA::BasicBlock.new(@function)
+          bb2 = SSA::BasicBlock.new
 
-          phi = SSA::PhiInsn.new(@basic_block, nil,
+          phi = SSA::PhiInsn.new(Integer,
               { @basic_block => val })
           phi.replace_uses_of(@basic_block, bb2)
 
@@ -541,7 +452,7 @@ describe SSA do
         it 'barfs on #replace_uses_of if the value is not used' do
           val1, val2 = 2.times.map { SSA::Value.new }
 
-          phi = SSA::PhiInsn.new(@basic_block, nil,
+          phi = SSA::PhiInsn.new(Integer,
               { @basic_block => val1 })
 
           -> { phi.replace_uses_of(val2, val1) }.should.raise ArgumentError
@@ -551,31 +462,54 @@ describe SSA do
 
     describe SSA::TerminatorInstruction do
       it 'is a terminator' do
-        i = SSA::TerminatorInstruction.new(@basic_block, [])
+        i = SSA::TerminatorInstruction.new([])
         i.should.be.terminator
       end
 
-      it 'has side effects' do
-        i = SSA::TerminatorInstruction.new(@basic_block, [])
+      it 'has side effects if exits?' do
+        i = SSA::TerminatorInstruction.new([])
+
+        def i.exits?; true; end
         i.has_side_effects?.should == true
       end
 
       it 'requires to implement #exits?' do
-        i = SSA::TerminatorInstruction.new(@basic_block, [])
+        i = SSA::TerminatorInstruction.new([])
         -> { i.exits? }.should.raise NotImplementedError
       end
 
       describe SSA::BranchInsn do
         it 'does not exit the method' do
-          i = SSA::BranchInsn.new(@basic_block, [@basic_block])
+          i = SSA::BranchInsn.new([@basic_block])
           i.exits?.should == false
         end
       end
 
       describe SSA::ReturnInsn do
+        before do
+          @i = SSA::ReturnInsn.new
+        end
+
+        it 'exits the method' do
+          @i.exits?.should == true
+        end
+
+        it 'returns bottom in #value_type' do
+          @i.value_type.should == Type::Bottom.new
+        end
+      end
+
+      describe SSA::ReturnValueInsn do
+        before do
+          @i = SSA::ReturnValueInsn.new([SSA::Constant.new(Integer, 1)])
+        end
+
         it 'exits the method' do
-          i = SSA::ReturnInsn.new(@basic_block, [SSA.void_value])
-          i.exits?.should == true
+          @i.exits?.should == true
+        end
+
+        it 'returns value type in #value_type' do
+          @i.value_type.should == Integer.to_type
         end
       end
     end
@@ -587,18 +521,18 @@ describe SSA do
     end
 
     it 'has the type of BasicBlock' do
-      @basic_block.type.should == SSA::BasicBlock.to_type
+      @basic_block.type.should == SSA::BasicBlockType.new
     end
 
     it 'pretty prints' do
-      @basic_block.append insn_noary(@basic_block)
-      @basic_block.append insn_noary(@basic_block)
-      @basic_block.pretty_print.should ==
-          "1:\n   ^Binding %2 = binding\n   ^Binding %3 = binding\n"
+      @basic_block.append insn_noary
+      @basic_block.append insn_noary
+      @basic_block.awesome_print.should ==
+          "1:\n   ^Binding %2 = binding\n   ^Binding %3 = binding\n\n"
     end
 
     it 'inspects as value' do
-      @basic_block.inspect_as_value.should == 'label %1'
+      @basic_block.awesome_print_as_value.should == 'label %1'
     end
 
     it 'is constant' do
@@ -606,14 +540,21 @@ describe SSA do
     end
 
     it 'can append instructions' do
-      i1, i2 = 2.times.map { insn_noary(@basic_block) }
+      i1, i2 = 2.times.map { insn_noary }
       @basic_block.append i1
       @basic_block.append i2
       @basic_block.to_a.should == [i1, i2]
     end
 
+    it 'can prepend instructions' do
+      i1, i2 = 2.times.map { insn_noary }
+      @basic_block.prepend i1
+      @basic_block.prepend i2
+      @basic_block.to_a.should == [i2, i1]
+    end
+
     it 'can insert instructions' do
-      i1, i2, i3 = 3.times.map { insn_noary(@basic_block) }
+      i1, i2, i3 = 3.times.map { insn_noary }
       @basic_block.append i1
       -> { @basic_block.insert i3, i2 }.should.raise ArgumentError, %r|is not found|
       @basic_block.append i3
@@ -621,38 +562,49 @@ describe SSA do
       @basic_block.to_a.should == [i1, i2, i3]
     end
 
+    it 'can splice instructions' do
+      i1, i2, i3 = 3.times.map { insn_noary }
+      @basic_block.append i1
+      @basic_block.append i2
+      @basic_block.append i3
+      @basic_block.splice(i2).should == [i3]
+      @basic_block.to_a.should == [i1, i2]
+
+      -> { @basic_block.splice(i3) }.should.raise(ArgumentError, %r|is not found|)
+    end
+
     it 'is not affected by changes to #to_a value' do
-      i1 = insn_noary(@basic_block)
+      i1 = insn_noary
       @basic_block.append i1
       @basic_block.to_a.clear
       @basic_block.to_a.size.should == 1
     end
 
     it 'enumerates instructions' do
-      i1 = insn_noary(@basic_block)
+      i1 = insn_noary
       @basic_block.append i1
       @basic_block.should.enumerate :each, [i1]
     end
 
     it 'enumerates instructions by type' do
-      i1 = BindingInsn.new(@basic_block)
+      i1 = BindingInsn.new
       @basic_block.append i1
 
-      i2 = GenericInsn.new(@basic_block)
+      i2 = GenericInsn.new(Integer)
       @basic_block.append i2
 
       @basic_block.each(BindingInsn).should.enumerate :each, [i1]
     end
 
     it 'can check for presence of instructions' do
-      i1, i2 = 2.times.map { insn_noary(@basic_block) }
+      i1, i2 = 2.times.map { insn_noary }
       @basic_block.append i1
       @basic_block.should.include i1
       @basic_block.should.not.include i2
     end
 
     it 'can remove instructions' do
-      i1, i2 = 2.times.map { insn_noary(@basic_block) }
+      i1, i2 = 2.times.map { insn_noary }
       @basic_block.append i1
       @basic_block.append i2
       @basic_block.remove i1
@@ -660,7 +612,7 @@ describe SSA do
     end
 
     it 'can replace instructions' do
-      i1, i2, i3, i4 = 4.times.map { insn_noary(@basic_block) }
+      i1, i2, i3, i4 = 4.times.map { insn_noary }
       @basic_block.append i1
       @basic_block.append i2
       @basic_block.append i3
@@ -673,28 +625,26 @@ describe SSA do
         @branch_bb = @basic_block
         @branch_bb.name = 'branch'
 
-        @body_bb = SSA::BasicBlock.new(@function, 'body')
+        @body_bb = SSA::BasicBlock.new([], 'body')
         @function.add @body_bb
 
-        @ret_bb  = SSA::BasicBlock.new(@function, 'ret')
+        @ret_bb  = SSA::BasicBlock.new([], 'ret')
         @function.add @ret_bb
 
-        @cond = DupInsn.new(@branch_bb,
-              [ SSA::Constant.new(TrueClass, true) ])
+        @cond = DupInsn.new([ SSA::Constant.new(TrueClass, true) ])
         @branch_bb.append @cond
 
-        @cond_br = CondBranchInsn.new(@branch_bb,
+        @cond_br = CondBranchInsn.new(
               [ @cond,
                 @body_bb,
                 @ret_bb ])
         @branch_bb.append @cond_br
 
-        @uncond_br = SSA::BranchInsn.new(@body_bb,
+        @uncond_br = SSA::BranchInsn.new(
               [ @ret_bb ])
         @body_bb.append @uncond_br
 
-        @ret = SSA::ReturnInsn.new(@ret_bb,
-              [ SSA.void_value ])
+        @ret = SSA::ReturnInsn.new
         @ret_bb.append @ret
       end
 
@@ -734,12 +684,12 @@ describe SSA do
           SSA::Constant.new(SSA::Function, @function.name)
 
       @function.name = 'foo'
-      @function.to_value.inspect_as_value.should ==
+      @function.to_value.awesome_print_as_value.should ==
           'function "foo"'
     end
 
     it 'converts to type' do
-      SSA::Function.to_type.should == SSA::FunctionType.instance
+      SSA::Function.to_type.should == SSA::FunctionType.new
     end
 
     it 'generates numeric names in #make_name(nil)' do
@@ -762,39 +712,47 @@ describe SSA do
       @function.should.not.include 'foobar'
     end
 
+    it 'reports #size' do
+      @function.size.should == 1
+    end
+
     it 'removes blocks' do
       @function.remove @basic_block
       @function.should.not.include '1'
     end
 
     it 'iterates each instruction in each block' do
-      bb2 = SSA::BasicBlock.new(@function)
+      bb2 = SSA::BasicBlock.new
       @function.add bb2
 
-      i1 = insn_noary(@basic_block)
+      i1 = insn_noary
       @basic_block.append i1
 
-      i2 = insn_unary(@basic_block, i1)
+      i2 = insn_unary(i1)
       bb2.append i2
 
       @function.should.enumerate :each_instruction, [i1, i2]
     end
 
+    it 'sanitizes arguments' do
+      -> { @function.arguments = [1] }.should.raise(ArgumentError)
+    end
+
     it 'pretty prints' do
       @function.name = 'foo'
       @function.arguments = [
-          SSA::Argument.new(@function, Integer, 'count'),
-          SSA::Argument.new(@function, Binding, 'outer')
+          SSA::Argument.new(Integer, 'count'),
+          SSA::Argument.new(Binding, 'outer')
       ]
 
-      @basic_block.append insn_binary(@basic_block, *@function.arguments)
+      @basic_block.append insn_binary(*@function.arguments)
 
-      bb2 = SSA::BasicBlock.new(@function, 'foo')
+      bb2 = SSA::BasicBlock.new([], 'foo')
       @function.add bb2
-      bb2.append insn_unary(@basic_block, SSA::Constant.new(Integer, 1))
+      bb2.append insn_unary(SSA::Constant.new(Integer, 1))
 
-      @function.pretty_print.should == <<-END
-function void foo( ^Integer %count, ^Binding %outer ) {
+      @function.awesome_print.should == <<-END
+function bottom foo (^Integer %count, ^Binding %outer) {
 1:
    ^Array %2 = tuple_concat %count, %outer
 
@@ -808,7 +766,7 @@ foo:
     it 'duplicates all its content' do
       @function.name = 'foo;1'
       @function.arguments = [
-          SSA::Argument.new(@function, Integer, 'count'),
+          SSA::Argument.new(Integer, 'count'),
       ]
 
       f1a1 = @function.arguments.first
@@ -816,20 +774,20 @@ foo:
       f1bb1 = @function.entry
       f1bb1.name = 'bb1'
 
-      f1bb2 = SSA::BasicBlock.new(@function, 'bb2')
+      f1bb2 = SSA::BasicBlock.new([], 'bb2')
       @function.add f1bb2
 
-      f1i1 = insn_unary(@basic_block, f1a1)
+      f1i1 = insn_unary(f1a1)
       @basic_block.append f1i1
 
       f1c1 = SSA::Constant.new(Array, [1])
-      f1i2 = insn_binary(@basic_block, f1i1, f1c1)
+      f1i2 = insn_binary(f1i1, f1c1)
       f1bb2.append f1i2
 
-      f1bb3 = SSA::BasicBlock.new(@function, 'bb3')
+      f1bb3 = SSA::BasicBlock.new([], 'bb3')
       @function.add f1bb3
 
-      f1phi = SSA::PhiInsn.new(f1bb3, nil,
+      f1phi = SSA::PhiInsn.new(Integer,
           { f1bb1 => f1i1, f1bb2 => f1i2 })
       f1bb3.append f1phi
 
@@ -872,7 +830,7 @@ foo:
       end
 
       f2.name = f1.name
-      f2.pretty_print.to_s.should == f1.pretty_print.to_s
+      f2.awesome_print.to_s.should == f1.awesome_print.to_s
     end
   end
 
@@ -896,7 +854,7 @@ foo:
       bar, = @f.arguments
       bar.type.should == Integer.to_type
       bar.name.should == 'bar'
-      @f.return_type.should == Float
+      @f.return_type.should == Float.to_type
 
       bb = @f.find('1')
       @f.entry.should == bb
@@ -917,10 +875,19 @@ foo:
     end
 
     it 'builds ReturnInsn' do
-      @b.return SSA.void_value
+      @b.return
       i, = @b.block.to_a
       i.should.be.instance_of SSA::ReturnInsn
-      i.operands.should == [SSA.void_value]
+      i.operands.should == []
+    end
+
+    it 'builds ReturnValueInsn' do
+      v1 = SSA::Constant.new(Integer, 1)
+
+      @b.return_value v1
+      i, = @b.block.to_a
+      i.should.be.instance_of SSA::ReturnValueInsn
+      i.operands.should == [v1]
     end
   end
 
@@ -932,12 +899,6 @@ foo:
       end
     end
 
-    class SyntaxTypedInsn < SSA::Instruction
-      syntax do |s|
-        s.operand :foo, Integer
-      end
-    end
-
     class SyntaxSplatInsn < SSA::Instruction
       syntax do |s|
         s.operand :foo
@@ -948,45 +909,36 @@ foo:
     before do
       @iconst = SSA::Constant.new(Integer, 1)
       @fconst = SSA::Constant.new(Float, 1.0)
-      @iinsn  = DupInsn.new(@basic_block, [ @iconst ])
+      @iinsn  = DupInsn.new([ @iconst ])
     end
 
     it 'accepts operands and decomposes them' do
-      i = SyntaxUntypedInsn.new(@basic_block, [ @iconst, @fconst ])
+      i = SyntaxUntypedInsn.new([ @iconst, @fconst ])
       i.foo.should == @iconst
       i.bar.should == @fconst
     end
 
     it 'allows to change operands through accessors' do
-      i = SyntaxUntypedInsn.new(@basic_block, [ @iconst, @fconst ])
+      i = SyntaxUntypedInsn.new([ @iconst, @fconst ])
       i.foo = @iinsn
       i.operands.should == [@iinsn, @fconst]
     end
 
     it 'does not accept wrong amount of operands' do
-      -> { SyntaxUntypedInsn.new(@basic_block, [ @iconst ]) }.
+      -> { SyntaxUntypedInsn.new([ @iconst ]) }.
         should.raise ArgumentError
-      -> { SyntaxUntypedInsn.new(@basic_block, [ @iconst, @iconst, @iconst ]) }.
+      -> { SyntaxUntypedInsn.new([ @iconst, @iconst, @iconst ]) }.
         should.raise ArgumentError
     end
 
-    it 'accepts only correct typed operands' do
-      -> { SyntaxTypedInsn.new(@basic_block, [ @fconst ]) }.
-        should.raise TypeError
-      -> { SyntaxTypedInsn.new(@basic_block, [ @iconst ]) }.
-        should.not.raise
-      -> { SyntaxTypedInsn.new(@basic_block, [ @iinsn ]) }.
-        should.not.raise
-    end
-
     it 'accepts splat' do
-      i = SyntaxSplatInsn.new(@basic_block, [ @iconst, @fconst, @iinsn ])
+      i = SyntaxSplatInsn.new([ @iconst, @fconst, @iinsn ])
       i.foo.should == @iconst
       i.bars.should == [@fconst, @iinsn]
     end
 
     it 'does not accept wrong amount of operands with splat' do
-      -> { SyntaxSplatInsn.new(@basic_block, []) }.
+      -> { SyntaxSplatInsn.new([]) }.
           should.raise ArgumentError
     end
 
@@ -1011,41 +963,14 @@ foo:
     end
 
     it 'allows to update splat' do
-      i = SyntaxSplatInsn.new(@basic_block, [ @iconst, @fconst, @iinsn ])
+      i = SyntaxSplatInsn.new([ @iconst, @fconst, @iinsn ])
       i.bars = [@iinsn, @fconst]
       i.bars.should == [@iinsn, @fconst]
       i.operands.should == [@iconst, @iinsn, @fconst]
     end
 
-    it 'allows to inquire status' do
-      i = SyntaxTypedInsn.new(@basic_block, [ @iconst ])
-      i.should.be.valid
-      i.foo = @fconst
-      i.should.not.be.valid
-    end
-
-    it 'highlights invalid insns when pretty printing' do
-      i = SyntaxTypedInsn.new(@basic_block, [ @iconst ])
-      i.foo = @fconst
-      i.pretty_print.should =~ /!syntax_typed/
-    end
-
-    it 'allows to treat nil type as error' do
-      phi = SSA::PhiInsn.new(@basic_block, nil)
-
-      i   = SyntaxTypedInsn.new(@basic_block, [ @iconst ])
-      i.should.be.valid(true)
-      i.should.be.valid(false)
-      -> { i.verify!(false) }.should.not.raise
-
-      i.foo = phi
-      i.should.be.valid(true)
-      i.should.not.be.valid(false)
-      -> { i.verify!(false) }.should.raise TypeError, %r|<?>|
-    end
-
     it 'does not interfere with def-use tracking' do
-      i = SyntaxUntypedInsn.new(@basic_block, [ @iconst, @fconst ])
+      i = SyntaxUntypedInsn.new([ @iconst, @fconst ])
       @fconst.should.enumerate :each_use, [ i ]
 
       i.bar = @iinsn
@@ -1054,12 +979,48 @@ foo:
     end
 
     it 'does not break on replace_uses_of' do
-      i = SyntaxUntypedInsn.new(@basic_block, [ @iconst, @fconst ])
+      i = SyntaxUntypedInsn.new([ @iconst, @fconst ])
       i.replace_uses_of @iconst, @fconst
       i.foo.should == @fconst
     end
   end
 
+  describe SSA::EventStream do
+    before do
+      @b   = TestBuilder.new('foo',
+              [ [Integer, 'bar'], [Binding, 'baz'] ],
+              Float)
+      @fun = @b.function
+
+      SSA.start_instrumentation
+
+      @mod  = SSA::Module.new
+      @mod.add @fun
+    end
+
+    it 'instruments functions' do
+      iconst  = SSA::Constant.new(Integer, 1)
+      iconst2 = @b.append :dup, [ iconst ]
+
+      iconst2.name = 'dupped'
+
+      @b.add_block do
+        @b.return_value iconst2
+      end
+
+      SSA.instrumentation.mark_transform(@fun, "footrans")
+      @fun.remove @b.block
+
+      # It's not possible to verify the instrumentation data,
+      # as it includes object_ids, so we just check that no exception
+      # is raised and it's not nil.
+      SSA.instrumentation.data.should.is_a? Array
+
+      # Disable instrumentation
+      SSA.instrumentation = nil
+    end
+  end
+
   describe SSA::Module do
     before do
       @module = SSA::Module.new
@@ -1126,4 +1087,4 @@ foo:
       @module.should.not.include 'foo'
     end
   end
-end
+end