RubyToC 1.0.0.4

data/support.rb

@@ -0,0 +1,317 @@
+
+class Environment
+
+  attr_accessor :env
+
+  def initialize
+    @env = [{}]
+  end
+
+  def depth
+    @env.length
+  end
+
+  def add(id, val)
+    raise "Adding illegal identifier #{id.inspect}" unless String === id or Symbol === id
+    current[id] = val
+  end
+
+  def extend
+    @env.unshift({})
+  end
+
+  def unextend
+    @env.shift
+  end
+
+  def lookup(id)
+
+    # HACK: if id is :self, cheat for now until we have full defn remapping
+    if id == :self then
+      return Type.fucked
+    end
+
+    @env.each do |closure|
+      return closure[id] if closure.has_key? id
+    end
+
+    raise NameError, "Unbound var: #{id.inspect} in #{@env.inspect}"
+  end
+
+  def current
+    @env.first
+  end
+
+  def scope
+    self.extend
+    yield
+    self.unextend
+  end
+
+end
+
+class FunctionTable
+
+  def initialize
+    @functions = Hash.new do |h,k|
+      h[k] = []
+    end
+  end
+
+  def cheat(name) # HACK: just here for debugging
+    puts "\n# WARNING: FunctionTable.cheat called from #{caller[0]}" if $DEBUG
+    @functions[name]
+  end
+
+  def [](name) # HACK: just here for transition
+    puts "\n# WARNING: FunctionTable.[] called from #{caller[0]}" if $DEBUG
+    @functions[name].first
+  end
+
+  def has_key?(name) # HACK: just here for transition
+    puts "\n# WARNING: FunctionTable.has_key? called from #{caller[0]}" if $DEBUG
+    @functions.has_key?(name)
+  end
+
+  def add_function(name, type)
+    @functions[name] << type
+    type
+  end
+
+  def unify(name, type)
+    success = false
+    @functions[name].each do |o| # unify(type)
+      begin
+        o.unify type
+        success = true
+      rescue
+        # ignore
+      end
+    end
+    unless success then
+      yield(name, type) if block_given?
+    end
+    type
+  end
+
+end
+
+class FunctionType
+
+  attr_accessor :receiver_type
+  attr_accessor :formal_types
+  attr_accessor :return_type
+
+  def initialize(receiver_type, formal_types, return_type)
+    raise "nil not allowed" if formal_types.nil? or return_type.nil?
+    @receiver_type = receiver_type
+    @formal_types = formal_types
+    @return_type = return_type
+  end
+
+  def ==(other)
+    return nil unless other.class == self.class
+
+    return false unless other.receiver_type == self.receiver_type
+    return false unless other.return_type == self.return_type
+    return false unless other.formal_types == self.formal_types
+    return true
+  end
+
+  def unify_components(other)
+    raise TypeError, "Unable to unify: different number of args #{self.inspect} vs #{other.inspect}" unless
+      @formal_types.length == other.formal_types.length
+
+    @formal_types.each_with_index do |t, i|
+      t.unify other.formal_types[i]
+    end
+
+    @receiver_type.unify other.receiver_type
+    @return_type.unify other.return_type
+#  rescue RuntimeError # print more complete warning message
+#    raise "Unable to unify\n#{self}\nwith\n#{other}"
+  end
+
+  def to_s
+    formals = formal_types.map do |t|
+      t.inspect
+    end
+
+    "function(#{receiver_type.inspect}, [#{formals.join ', '}], #{return_type.inspect})"
+  end
+
+end
+
+class Handle
+
+  attr_accessor :contents
+
+  def initialize(contents)
+    @contents = contents
+  end
+
+  def ==(other)
+    return nil unless other.class == self.class
+    return other.contents == self.contents
+  end
+
+end
+
+class Type
+
+  # REFACTOR: nuke this
+  KNOWN_TYPES = {
+    :unknown => "Unknown",
+    :unknown_list => "Unknown list",
+    :long => "Integer",
+    :long_list => "Integer list",
+    :str => "String",
+    :str_list => "String list",
+    :void => "Void",
+    :bool => "Bool",
+    :bool_list => "Bool list",
+    :value => "Value",
+    :value_list => "Value list",
+    :function => "Function",
+    :file => "File",
+    :float => "Float",
+    :float_list => "Float list",
+    :symbol => "Symbol",
+    :zclass => "Class",
+    :homo => "Homogenous",
+    :hetero => "Heterogenous",
+    :fucked => "Untranslatable type",
+  }
+
+  TYPES = {}
+
+  def self.method_missing(type, *args)
+    raise "Unknown type Type.#{type}" unless KNOWN_TYPES.has_key?(type)
+    case type 
+    when :unknown then
+      return self.new(type)
+    when :function then
+      if args.size == 2 then
+        $stderr.puts "\nWARNING: adding Type.unknown for #{caller[0]}" if $DEBUG
+        args.unshift Type.unknown
+      end
+      return self.new(FunctionType.new(*args))
+    else
+      if type.to_s =~ /(.*)_list$/ then
+        TYPES[type] = self.new($1.intern, true) unless TYPES.has_key?(type)
+        return TYPES[type]
+      else
+        TYPES[type] = self.new(type) unless TYPES.has_key?(type)
+        return TYPES[type]
+      end
+    end
+  end
+
+  def self.unknown_list
+    self.new(:unknown, true)
+  end
+
+  attr_accessor :type
+  attr_accessor :list
+
+  def initialize(type, list=false)
+    # HACK
+    unless KNOWN_TYPES.has_key? type or type.class.name =~ /Type$/ then
+      raise "Unknown type Type.new(#{type.inspect})"
+    end
+    @type = Handle.new type
+    @list = list
+  end
+
+  def function?
+    not KNOWN_TYPES.has_key? self.type.contents
+  end
+
+  def unknown?
+    self.type.contents == :unknown
+  end
+
+  def list?
+    @list
+  end
+
+  # REFACTOR: this should be named type, but that'll break code at the moment
+  def list_type
+    @type.contents
+  end
+
+  def eql?(other)
+    return nil unless other.class == self.class
+
+    other.type == self.type && other.list? == self.list?
+  end
+
+  alias :== :eql?
+
+  def hash
+    type.contents.hash ^ @list.hash
+  end
+
+  def unify(other)
+    return other.unify(self) if Array === other
+    return self if other == self and (not self.unknown?)
+    return self if other.nil?
+    if self.unknown? and other.unknown? then
+      # link types between unknowns
+      self.type = other.type
+      self.list = other.list? or self.list? # HACK may need to be tri-state
+    elsif self.unknown? then
+      # other's type is now my type
+      self.type.contents = other.type.contents
+      self.list = other.list?
+    elsif other.unknown? then
+      # my type is now other's type
+      other.type.contents = self.type.contents
+      other.list = self.list?
+    elsif self.function? and other.function? then
+      self_fun = self.type.contents
+      other_fun = other.type.contents
+
+      self_fun.unify_components other_fun
+    else
+      raise TypeError, "Unable to unify #{self.inspect} with #{other.inspect}"
+    end
+    return self
+  end
+
+  def to_s
+    str = "Type.#{self.type.contents}"
+    str << "_list" if self.list?
+    str
+  end
+
+  def inspect
+    to_s
+  end unless $DEBUG
+
+end
+
+##
+# Unique creates unique variable names.
+
+class Unique
+
+  ##
+  # Variable names will be prefixed by +prefix+
+
+  def initialize(prefix)
+    @prefix = prefix
+    @curr = 'a'
+  end
+
+  ##
+  # Generate a new unique variable name
+
+  def next
+    var = "#{@prefix}_#{@curr}"
+    @curr.succ!
+    return var
+  end
+
+end
+

data/test_all.rb

@@ -0,0 +1,9 @@
+#!/usr/local/bin/ruby -w
+
+$TESTING = true
+
+Dir.glob("test_*.rb").each do |f|
+  require f
+end
+
+require 'test/unit'

data/test_extras.rb

@@ -0,0 +1,143 @@
+#!/usr/local/bin/ruby -w
+
+$TESTING = true
+
+require 'type_checker'
+require 'test/unit'
+
+class RandomCode # ZenTest SKIP
+  def specific_method(x)
+    x = 0 # make x and y to be longs
+    return c.to_i > 0
+  end
+
+  def generic_method(x)
+    specific_method(x)
+  end
+
+  def meth_b(x)
+    # nothing to do so we don't hint what x is
+  end
+
+  def meth_a(x)
+    meth_b(x)
+  end
+
+end
+
+class TestExtraTypeChecker < Test::Unit::TestCase # ZenTest SKIP
+
+  def setup
+    @parser = ParseTree.new
+    @rewriter = Rewriter.new
+    @type_checker = TypeChecker.new
+  end
+
+  # HACK: this shouldn't be in test code. use augment or something
+  def util_process(klass, meth)
+    sexp = @parser.parse_tree_for_method klass, meth
+    sexp = [sexp] unless meth.nil?
+    result = []
+    sexp.each do | sub_exp|
+      result << @type_checker.process(@rewriter.process(sub_exp))
+    end
+    return result
+  end
+
+  def util_unify_function
+    a = Type.function(Type.unknown, [ Type.unknown ], Type.unknown)
+    b = Type.function(Type.long, [ Type.str ], Type.void)
+    a.unify b
+    act = a.list_type
+    bct = b.list_type
+    return act, bct
+  end
+
+  def test_unify_function_whole
+    act, bct = util_unify_function
+    assert_equal act, bct
+  end
+
+  def test_unify_function_receiver
+    act, bct = util_unify_function
+    assert_equal act.receiver_type.list_type, bct.receiver_type.list_type
+    assert_equal act.receiver_type.list_type.object_id, bct.receiver_type.list_type.object_id
+    assert_equal act, bct
+  end
+
+  def test_unify_function_args
+    act, bct = util_unify_function.map { |x| x.formal_types }
+    assert_equal act.first.list_type, bct.first.list_type
+    assert_equal act.first.list_type.object_id, bct.first.list_type.object_id
+  end
+
+  def test_unify_function_return
+    act, bct = util_unify_function
+    assert_equal act.return_type.list_type, bct.return_type.list_type
+    assert_equal act.return_type.list_type.object_id, bct.return_type.list_type.object_id
+  end
+
+  def test_type_inference_across_args_known
+    generic  = util_process(RandomCode, :generic_method).first
+# puts
+# pp @type_checker.functions
+    specific = util_process(RandomCode, :specific_method).first
+# puts
+# pp @type_checker.functions
+
+# pp generic
+# pp specific
+
+    args_g = generic[2]  # FIX FUCK this is horrid
+    args_s = specific[2] # FIX FUCK this is horrid
+
+    #assert_equal(args_s[1].sexp_type.list_type.object_id, # FIX demeter
+    #             args_s[2].sexp_type.list_type.object_id,
+    #             "#specific_method's arguments are unified")
+
+    assert_equal(Type.long, args_s[1].sexp_type,
+                 "#specific_method's x is a Long")
+    assert_equal(Type.long, args_g[1].sexp_type, # FAILS
+                 "#generic_method's x is a Long")
+
+    assert_equal(args_g[1].sexp_type.list_type.object_id,
+                 args_s[1].sexp_type.list_type.object_id,
+                 "#specific_method's x and #generic_method's x are unified")
+
+#     assert_equal(args_g[2].sexp_type.list_type.object_id,
+#                  args_s[2].sexp_type.list_type.object_id,
+#                 "#specific_method's y and #generic_method's y are unified")
+
+#     assert_equal(Type.long, args_s[2].sexp_type,
+#                  "#specific_method's y is a Long")
+#     assert_equal(Type.long, args_g[2].sexp_type,
+#                  "#generic_method's y is a Long")
+end
+
+  def test_type_inference_across_args_unknown
+    meth_a = util_process(RandomCode, :meth_a).first
+    meth_b = util_process(RandomCode, :meth_b).first
+
+    args_a = meth_a[2][1] # FIX FUCK this is horrid
+    args_b = meth_b[2][1] # FIX FUCK this is horrid
+
+    assert_equal(args_a.sexp_type.list_type,
+                 args_b.sexp_type.list_type,
+                 "#meth_a and meth_b arguments are the same after unification")
+
+    assert_equal(args_a.sexp_type.list_type.object_id,
+                 args_b.sexp_type.list_type.object_id,
+                 "#meth_a and meth_b arguments are unified by object_id")
+  end
+
+  def test_process_defn_return_val
+    ignore = util_process(RandomCode, :meth_a)
+    result = util_process(RandomCode, :meth_b).first
+
+    assert_equal(:meth_b, result[1])
+    # FIX: this is the worst API in my codebase - demeter
+    assert_equal(Type.void, result.sexp_type.list_type.return_type)
+  end
+
+end
+