typeprof 0.1.0

data/lib/typeprof/utils.rb

@@ -0,0 +1,209 @@
+module TypeProf
+  module Utils
+    def self.array_update(ary, idx, elem)
+      idx %= ary.size
+      ary[0...idx] + [elem] + ary[idx+1..-1]
+    end
+
+    module StructuralEquality
+      def hash
+        @_hash ||=
+          begin
+            h = 0
+            instance_variables.each do |v|
+              h ^= instance_variable_get(v).hash if v != :@_hash
+            end
+            h
+          end
+      end
+
+      TABLE = {}
+
+      def self.included(klass)
+        def klass.new(*args)
+          (TABLE[self] ||= {})[args] ||= super
+        end
+        class << klass
+          ruby2_keywords :new
+        end
+      end
+    end
+
+    class Set
+      include StructuralEquality
+
+      attr_reader :tbl
+
+      def self.[](*values)
+        tbl = {}
+        values.each do |v|
+          tbl[v] = true
+        end
+        new(tbl)
+      end
+
+      def initialize(tbl)
+        @tbl = tbl
+        @tbl.freeze
+      end
+
+      def each(&blk)
+        @tbl.each_key(&blk)
+      end
+
+      include Enumerable
+
+      def sum(other)
+        if @tbl.size == 0
+          other
+        elsif other.tbl.size == 0
+          self
+        else
+          Set.new(@tbl.merge(other.tbl))
+        end
+      end
+
+      def add(new_val)
+        tbl = @tbl.dup
+        tbl[new_val] = true
+        Set.new(tbl)
+      end
+
+      def size
+        @tbl.size
+      end
+
+      def map(&blk)
+        tbl = {}
+        each do |elem|
+          v = yield(elem)
+          tbl[v] = true
+        end
+        Set.new(tbl)
+      end
+
+      def inspect
+        s = []
+        each {|v| s << v.inspect }
+        "{#{ s.join(", ") }}"
+      end
+
+      def include?(elem)
+        @tbl[elem]
+      end
+
+      def intersection(other)
+        tbl = {}
+        h = 0
+        each do |elem|
+          if other.include?(elem)
+            tbl << elem
+            h ^= elem.hash
+          end
+        end
+        Set.new(tbl, h)
+      end
+    end
+
+    class MutableSet
+      def initialize(*values)
+        @hash = {}
+        values.each {|v| @hash[v] = v }
+      end
+
+      def each(&blk)
+        @hash.each_key(&blk)
+      end
+
+      include Enumerable
+
+      def <<(v)
+        @hash[v] = true
+      end
+
+      def [](v)
+        @hash[v]
+      end
+
+      def delete(v)
+        @hash.delete(v)
+      end
+
+      def inspect
+        s = []
+        each {|v| s << v.inspect }
+        "{#{ s.join(", ") }}"
+      end
+
+      def size
+        @hash.size
+      end
+
+      def to_set
+        Set[*@hash.keys]
+      end
+    end
+
+    class HashWrapper
+      include StructuralEquality
+
+      def initialize(hash)
+        @internal_hash = hash.freeze
+      end
+
+      attr_reader :internal_hash
+    end
+
+    class WorkList
+      def initialize
+        @heap = []
+        @set = MutableSet.new
+      end
+
+      def insert(key, val)
+        i = @heap.size
+        @heap << [key, val]
+        while i > 0 && (@heap[i][0] <=> @heap[i / 2][0]) < 0
+          @heap[i], @heap[i / 2] = @heap[i / 2], @heap[i]
+          i /= 2
+        end
+        @set << val
+      end
+
+      def member?(val)
+        @set[val]
+      end
+
+      def deletemin
+        return nil if @heap.empty?
+        val = @heap[0][1]
+        @set.delete(val)
+        if @heap.size == 1
+          @heap.pop
+          return val
+        end
+        @heap[0] = @heap.pop
+        i = 0
+        while (j = i * 2 + 1) < @heap.size
+          j += 1 if j + 1 < @heap.size && (@heap[j][0] <=> @heap[j + 1][0]) >= 0
+          break if (@heap[i][0] <=> @heap[j][0]) < 0
+          @heap[i], @heap[j] = @heap[j], @heap[i]
+          i = j
+        end
+        return val
+      end
+
+      def size
+        @heap.size
+      end
+
+      def empty?
+        @heap.empty?
+      end
+
+      def inspect
+        "#<#{ self.class }:#{ @heap.map {|_key, val| val }.inspect }>"
+      end
+    end
+  end
+end

data/run.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+
+bundle exe ruby exe/type-profiler $@

data/smoke/alias.rb

@@ -0,0 +1,30 @@
+def foo(x)
+  x
+end
+
+alias bar foo
+
+class Test
+  def baz(x)
+    x
+  end
+
+  alias qux baz
+end
+
+foo(1)
+bar("str")
+Test.new.baz(1)
+Test.new.qux("str")
+
+__END__
+# Classes
+class Object
+  def foo : (Integer) -> Integer
+  def bar : (String) -> String
+end
+
+class Test
+  def baz : (Integer) -> Integer
+  def qux : (String) -> String
+end

data/smoke/alias2.rb

@@ -0,0 +1,19 @@
+class Foo
+  class << self
+    alias [] new
+  end
+
+  def initialize(a, b, c)
+    @a, @b, @c = a, b, c
+  end
+end
+
+Foo[:x, :y, :z]
+__END__
+# Classes
+class Foo
+  @a : :x
+  @b : :y
+  @c : :z
+  def initialize : (:x, :y, :z) -> [:x, :y, :z]
+end

data/smoke/any-cbase.rb

@@ -0,0 +1,5 @@
+class Unknown::Foo
+end
+
+__END__
+# Classes

data/smoke/any1.rb

@@ -0,0 +1,15 @@
+def foo
+  x = 1.undefined_method
+  x.undefined_method2
+end
+
+foo
+
+__END__
+# Errors
+smoke/any1.rb:2: [error] undefined method: Integer#undefined_method
+
+# Classes
+class Object
+  def foo : -> untyped
+end

data/smoke/any2.rb

@@ -0,0 +1,17 @@
+def foo
+  yield
+end
+def bar
+  yield
+  1
+end
+
+foo
+bar
+
+__END__
+# Classes
+class Object
+  def foo : -> untyped
+  def bar : -> Integer
+end

data/smoke/arguments.rb

@@ -0,0 +1,16 @@
+def foo(x)
+end
+def bar(x)
+end
+
+bar(foo(1, 2))
+
+__END__
+# Errors
+smoke/arguments.rb:6: [error] wrong number of arguments (given 2, expected 1)
+
+# Classes
+class Object
+  def foo : (untyped) -> nil
+  def bar : (untyped) -> nil
+end

data/smoke/array-each.rb

@@ -0,0 +1,14 @@
+def log(x)
+end
+
+[1, "str", :sym].each do |x|
+  log(x)
+end
+
+log(nil)
+
+__END__
+# Classes
+class Object
+  def log : ((:sym | Integer | String)?) -> nil
+end

data/smoke/array-each2.rb

@@ -0,0 +1,15 @@
+def foo
+  x = nil
+  [1, "str"].each do |y|
+    x = y
+  end
+  x
+end
+
+foo
+
+__END__
+# Classes
+class Object
+  def foo : -> ((Integer | String)?)
+end

data/smoke/array-each3.rb

@@ -0,0 +1,15 @@
+def log(x)
+end
+
+[].each do |x|
+  # Currently, x is bot. But, [].each is rarely useful.
+  # It would be a good guess to assume a empty receiver of Array#each means a wrong guess.
+  # So, it would be good to assume x as any
+  log(x)
+end
+
+__END__
+# Classes
+class Object
+  def log : (bot) -> nil
+end

data/smoke/array-ltlt.rb

@@ -0,0 +1,13 @@
+def foo
+  a = []
+  a << 1
+  a << "str"
+  a
+end
+
+foo
+__END__
+# Classes
+class Object
+  def foo : -> (Array[Integer | String])
+end

data/smoke/array-ltlt2.rb

@@ -0,0 +1,16 @@
+def foo
+  a = []
+  while true
+    a << 1
+    a << "str"
+    break if rand < 0.5
+  end
+  a
+end
+
+foo
+__END__
+# Classes
+class Object
+  def foo : -> (Array[Integer | String])
+end

data/smoke/array-map.rb

@@ -0,0 +1,11 @@
+def foo(a)
+  a.map {|n| n.to_s }
+end
+
+foo([1, 2, 3])
+
+__END__
+# Classes
+class Object
+  def foo : ([Integer, Integer, Integer]) -> Array[String]
+end

data/smoke/array-map2.rb

@@ -0,0 +1,10 @@
+def foo(a)
+  a.map {|n| rand < 0.5 ? n.to_s : n }
+end
+
+foo([1, 2, 3])
+__END__
+# Classes
+class Object
+  def foo : ([Integer, Integer, Integer]) -> (Array[Integer | String])
+end

data/smoke/array-map3.rb

@@ -0,0 +1,22 @@
+def map_test(a)
+  a.map {|n| n.to_s }
+end
+def map_bang_test(a)
+  a.map! {|n| n.to_s }
+  a
+end
+def map_bang_test_known_bug(a)
+  a.map! {|n| n.to_s }
+end
+
+map_test([1, 2, 3])
+map_bang_test([1, 2, 3])
+map_bang_test_known_bug([1, 2, 3])
+
+__END__
+# Classes
+class Object
+  def map_test : ([Integer, Integer, Integer]) -> Array[String]
+  def map_bang_test : ([Integer, Integer, Integer]) -> (Array[Integer | String])
+  def map_bang_test_known_bug : ([Integer, Integer, Integer]) -> [Integer, Integer, Integer]
+end