typeprof 0.5.1 → 0.6.1

data/lib/typeprof/type.rb

@@ -170,7 +170,7 @@ module TypeProf
         "untyped"
       end
 
-      def get_method(mid, scratch)
+      def method_dispatch_info
         nil
       end
 
@@ -430,15 +430,17 @@ module TypeProf
     end
 
     class Class < Type # or Module
-      def initialize(kind, idx, type_params, superclass, name)
+      def initialize(kind, idx, type_params, superclass, superclass_type_args, name)
         @kind = kind # :class | :module
         @idx = idx
         @type_params = type_params
         @superclass = superclass
+        raise if @kind == :class && !@superclass
+        @superclass_type_args = superclass_type_args
         @_name = name
       end
 
-      attr_reader :kind, :idx, :type_params, :superclass
+      attr_reader :kind, :idx, :type_params, :superclass, :superclass_type_args
 
       def inspect
         if @_name
@@ -449,11 +451,11 @@ module TypeProf
       end
 
       def screen_name(scratch)
-        "#{ scratch.get_class_name(self) }.class"
+        "singleton(#{ scratch.get_class_name(self) })"
       end
 
-      def get_method(mid, scratch)
-        scratch.get_method(self, true, mid)
+      def method_dispatch_info
+        [self, true]
       end
 
       def consistent?(other)
@@ -504,8 +506,8 @@ module TypeProf
         end
       end
 
-      def get_method(mid, scratch)
-        scratch.get_method(@klass, false, mid)
+      def method_dispatch_info
+        [@klass, false]
       end
 
       def consistent?(other)
@@ -558,8 +560,8 @@ module TypeProf
         end
       end
 
-      def get_method(mid, scratch)
-        @base_type.get_method(mid, scratch)
+      def method_dispatch_info
+        @base_type.method_dispatch_info
       end
 
       def substitute(subst, depth)
@@ -600,8 +602,8 @@ module TypeProf
         end
       end
 
-      def get_method(mid, scratch)
-        @base_type.get_method(mid, scratch)
+      def method_dispatch_info
+        @base_type.method_dispatch_info
       end
 
       def substitute(_subst, _depth)
@@ -630,8 +632,8 @@ module TypeProf
         @base_type
       end
 
-      def get_method(mid, scratch)
-        @base_type.get_method(mid, scratch)
+      def method_dispatch_info
+        @base_type.method_dispatch_info
       end
 
       def consistent?(_other)
@@ -785,6 +787,10 @@ module TypeProf
       end
       str = str.empty? ? "" : "(#{ str.join(", ") })"
 
+      # Dirty Hack: Stop the iteration at most once!
+      # I'll remove this hack if RBS removes the limitation of nesting blocks
+      return str if caller_locations.any? {|frame| frame.label == "show_block_signature" }
+
       optional = false
       blks = []
       @blk_ty.each_child_global do |ty|

data/lib/typeprof/version.rb

@@ -1,3 +1,3 @@
 module TypeProf
-  VERSION = "0.5.1"
+  VERSION = "0.6.1"
 end

data/smoke/array11.rb

@@ -9,5 +9,5 @@ array("foo")
 __END__
 # Classes
 class Object
-  def array : (Array[Integer] | String | {Integer=>Integer}) -> (Array[Integer | String | {Integer=>Integer}])
+  def array : (Array[Integer] | Hash[Integer, Integer] | String) -> (Array[Hash[Integer, Integer] | Integer | String])
 end

data/smoke/array6.rb

@@ -10,6 +10,6 @@ foo(1, "str")
 __END__
 # Classes
 class Object
-  ARY : []
-  def foo : (Integer, String) -> []
+  ARY : Array[bot]
+  def foo : (Integer, String) -> Array[bot]
 end

data/smoke/array8.rb

@@ -9,5 +9,5 @@ end
 __END__
 # Classes
 class Foo
-  def self.foo : ([]) -> []
+  def self.foo : (Array[bot]) -> Array[bot]
 end

data/smoke/block-args2.rb

@@ -47,11 +47,11 @@ __END__
 # Classes
 class Object
   def f1 : { -> nil } -> ^(nil, *bot, nil) -> nil
-  def log1 : (nil, [], nil) -> nil
+  def log1 : (nil, Array[bot], nil) -> nil
   def f2 : { (:a) -> nil } -> ^(:a, *bot, nil) -> nil
-  def log2 : (:a, [], nil) -> nil
+  def log2 : (:a, Array[bot], nil) -> nil
   def f3 : { (:a, :b) -> nil } -> ^(:a, *bot, :b) -> nil
-  def log3 : (:a, [], :b) -> nil
+  def log3 : (:a, Array[bot], :b) -> nil
   def f4 : { (:a, :b, :c) -> nil } -> ^(:a, *:b, :c) -> nil
   def log4 : (:a, [:b], :c) -> nil
   def f5 : { (:a, :b, :c, :d) -> nil } -> (^(:a, *:b | :c, :d) -> nil)

data/smoke/block-args3.rb

@@ -56,13 +56,13 @@ __END__
 # Classes
 class Object
   def f1 : { -> nil } -> ^(nil, ?:opt, *bot, nil) -> nil
-  def log1 : (nil, :opt, [], nil) -> nil
+  def log1 : (nil, :opt, Array[bot], nil) -> nil
   def f2 : { (:a) -> nil } -> ^(:a, ?:opt, *bot, nil) -> nil
-  def log2 : (:a, :opt, [], nil) -> nil
+  def log2 : (:a, :opt, Array[bot], nil) -> nil
   def f3 : { (:a, :b) -> nil } -> ^(:a, ?:opt, *bot, :b) -> nil
-  def log3 : (:a, :opt, [], :b) -> nil
+  def log3 : (:a, :opt, Array[bot], :b) -> nil
   def f4 : { (:a, :b, :c) -> nil } -> (^(:a, ?:b | :opt, *bot, :c) -> nil)
-  def log4 : (:a, :b | :opt, [], :c) -> nil
+  def log4 : (:a, :b | :opt, Array[bot], :c) -> nil
   def f5 : { (:a, :b, :c, :d) -> nil } -> (^(:a, ?:b | :opt, *:c, :d) -> nil)
   def log5 : (:a, :b | :opt, [:c], :d) -> nil
   def f6 : { (:a, :b, :c, :d, :e) -> nil } -> (^(:a, ?:b | :opt, *:c | :d, :e) -> nil)

data/smoke/block-blockarg.rb

@@ -23,5 +23,5 @@ class Object
   def log1 : (:a) -> nil
   def log2 : (:b) -> nil
   def log3 : (:c) -> nil
-  def f : { { (:a) -> :b } -> :c } -> :d
+  def f : { -> :c } -> :d
 end

data/smoke/block5.rb

@@ -15,5 +15,5 @@ __END__
 # Classes
 class Object
   F : ^(Integer) -> String
-  def foo : { (:sym) { (Integer) -> String } -> String } -> String
+  def foo : { (:sym) -> String } -> String
 end

data/smoke/constant2.rb

@@ -24,12 +24,11 @@ smoke/constant2.rb:15: [warning] already initialized constant Object::BAR
 
 # Classes
 class Object
-  C : String
   BAR : String
   def foo : (Integer | untyped) -> nil
   def log : (String) -> nil
 end
 
-class C(dummy)
+class C
   def foo : -> nil
 end

data/smoke/demo5.rb

@@ -9,7 +9,7 @@ B.foo(Integer)
 __END__
 # Classes
 class A
-  def self.foo : (Integer | Integer.class) -> String
+  def self.foo : (Integer | singleton(Integer)) -> String
 end
 
 class B < A

data/smoke/demo9.rb

@@ -12,5 +12,5 @@ __END__
 # Classes
 class Object
   F : ^(Integer) -> String
-  def foo : { (:sym) { (Integer) -> String } -> String } -> String
+  def foo : { (:sym) -> String } -> String
 end

data/smoke/hash1.rb

@@ -5,6 +5,7 @@ end
 foo
 
 def bar
+  # This returns {Integer=>Integer | String, String=>String} but RBS cannot express it
   { 1 => 1, 2 => "str", "s" => "s" }
 end
 
@@ -14,5 +15,5 @@ __END__
 # Classes
 class Object
   def foo : -> {int: Integer, str: String}
-  def bar : -> ({Integer=>Integer | String, String=>String})
+  def bar : -> (Hash[Integer | String, Integer | String])
 end

data/smoke/hash4.rb

@@ -6,5 +6,5 @@ foo
 __END__
 # Classes
 class Object
-  def foo : -> {}
+  def foo : -> Hash[bot, bot]
 end

data/smoke/inheritance2.rb

@@ -21,11 +21,11 @@ end
 __END__
 # Classes
 class SuperBase
-  def self.foo : -> (A.class | B.class)
+  def self.foo : -> (singleton(A) | singleton(B))
 end
 
 class Base < SuperBase
-  def self.foo : -> (A.class | B.class)
+  def self.foo : -> (singleton(A) | singleton(B))
 end
 
 class A < Base

data/smoke/ivar2.rb

@@ -25,6 +25,6 @@ __END__
 class Foo
   attr_reader array : Array[:sym | Integer | String]
   attr_reader hash : {a: Integer, b: String, c: :sym}
-  def initialize : -> {}
+  def initialize : -> Hash[bot, bot]
   def set : -> :sym
 end

data/smoke/kernel-class.rb

@@ -8,5 +8,5 @@ foo("")
 __END__
 # Classes
 class Object
-  def foo : (Integer | String) -> (Integer.class | String.class)
+  def foo : (Integer | String) -> (singleton(Integer) | singleton(String))
 end

data/smoke/kwsplat1.rb

@@ -38,5 +38,5 @@ class Object
   def foo : (k: Integer) -> nil
   def bar : (int: Integer, str: String) -> nil
   def baz : (**{int: Integer, str: String}) -> nil
-  def qux : (**{untyped=>untyped}) -> nil
+  def qux : (**Hash[untyped, untyped]) -> nil
 end

data/smoke/multiple-superclass.rb

@@ -15,7 +15,7 @@ smoke/multiple-superclass.rb:9: [warning] superclass is not a class; Object is u
 
 # Classes
 class Object
-  Base : A.class | B.class
+  Base : singleton(A) | singleton(B)
 end
 
 class A

data/smoke/parameterizedd-self.rb

@@ -13,6 +13,6 @@ bar([])
 __END__
 # Classes
 class Object
-  def foo : -> []
-  def bar : ([]) -> []
+  def foo : -> Array[bot]
+  def bar : (Array[bot]) -> Array[bot]
 end

data/smoke/parameterizedd-self2.rb

@@ -0,0 +1,15 @@
+class Object
+  def foo
+    # The receiver is considered as an empty array
+    self[0]
+  end
+end
+
+# The elements are dropped when it is passed as a receiver (to avoid state explosion)
+[0].foo
+
+__END__
+# Classes
+class Object
+  def foo : -> nil
+end

data/smoke/rbs-tyvar6.rb

@@ -0,0 +1,17 @@
+def log1(obj) end
+def log2(obj) end
+def log3(obj) end
+
+obj = Bar.new("str")
+
+log1(obj)
+log2(obj.test_superclass)
+log3(obj.test_module)
+
+__END__
+# Classes
+class Object
+  def log1 : (Bar[String]) -> nil
+  def log2 : (Array[String]) -> nil
+  def log3 : (Integer) -> nil
+end

data/smoke/rbs-tyvar6.rbs

@@ -0,0 +1,12 @@
+class Foo[X]
+  def test_superclass: -> X
+end
+
+module M[X]
+  def test_module: -> X
+end
+
+class Bar[X] < Foo[Array[X]]
+  def initialize: (X) -> void
+  include M[Integer]
+end

data/smoke/struct.rb

@@ -5,9 +5,9 @@ end
 Foo.new.a = 1
 __END__
 # Classes
-class (Anonymous Struct) < Struct
+class AnonymousStruct_generated_1 < Struct
   attr_accessor a() : untyped
 end
 
-class Foo < (Anonymous Struct)
+class Foo < AnonymousStruct_generated_1
 end

data/smoke/super4.rb

@@ -0,0 +1,43 @@
+module M1
+  def f(m); super :M1; end
+end
+module M2
+  def f(m); super :M2; end
+end
+class C
+  def f(m); end
+end
+class D < C
+  def f(m); super :D; end
+  include M1
+end
+class E < D
+  def f(m); super :E; end
+  include M2
+end
+
+E.new.f(:top)
+
+__END__
+# Classes
+module M1
+  def f : (:D) -> nil
+end
+
+module M2
+  def f : (:E) -> nil
+end
+
+class C
+  def f : (:M1) -> nil
+end
+
+class D < C
+  include M1
+  def f : (:M2) -> nil
+end
+
+class E < D
+  include M2
+  def f : (:top) -> nil
+end

data/smoke/super5.rb

@@ -0,0 +1,36 @@
+module M
+  def f(m); super :M; end
+end
+class C
+  def f(m); end
+end
+class D < C
+  def f(m); super :D; end
+  include M
+end
+class E < D
+  def f(m); super :E; end
+  include M
+end
+
+E.new.f(:top)
+
+__END__
+# Classes
+module M
+  def f : (:D | :E) -> nil
+end
+
+class C
+  def f : (:M) -> nil
+end
+
+class D < C
+  include M
+  def f : (:M) -> nil
+end
+
+class E < D
+  include M
+  def f : (:top) -> nil
+end

data/smoke/union-recv.rb

@@ -21,11 +21,11 @@ end
 __END__
 # Classes
 class SuperBase
-  def self.foo : -> (A.class | B.class)
+  def self.foo : -> (singleton(A) | singleton(B))
 end
 
 class Base < SuperBase
-  def self.foo : -> (A.class | B.class)
+  def self.foo : -> (singleton(A) | singleton(B))
 end
 
 class A < Base