typeprof 0.3.0 → 0.4.0

data/lib/typeprof/version.rb

@@ -1,3 +1,3 @@
 module TypeProf
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

data/smoke/arguments2.rb

@@ -37,7 +37,7 @@ f9(k: :kk)
 def f10(&blk)
   blk.call(1)
 end
-f10 {}
+f10 {|n| }
 
 __END__
 # Classes

data/smoke/array-each3.rb

@@ -2,14 +2,11 @@ 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
+  def log : (untyped) -> nil
 end

data/smoke/array12.rb

@@ -19,6 +19,6 @@ __END__
 # Classes
 class Object
   def bar : ([Integer]) -> nil
-  def test_yield : { () -> nil } -> nil
+  def test_yield : { -> nil } -> nil
   def foo : -> [Integer]
 end

data/smoke/array6.rb

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

data/smoke/block-ambiguous.rb

@@ -0,0 +1,36 @@
+def f1
+  yield :a, :b, :c
+end
+def log1(x); end
+f1 {|x| log1(x) }
+
+def f2
+  yield :a, :b, :c
+end
+def log2(x); end
+f2 {|x,| log2(x) }
+
+def f3
+  yield [:a, :b, :c]
+end
+def log3(x); end
+f3 {|x| log3(x) }
+
+def f4
+  yield [:a, :b, :c]
+end
+def log4(x); end
+f4 {|x,| log4(x) }
+
+__END__
+# Classes
+class Object
+  def f1 : { (:a, :b, :c) -> nil } -> nil
+  def log1 : (:a) -> nil
+  def f2 : { (:a, :b, :c) -> nil } -> nil
+  def log2 : (:a) -> nil
+  def f3 : { ([:a, :b, :c]) -> nil } -> nil
+  def log3 : ([:a, :b, :c]) -> nil
+  def f4 : { ([:a, :b, :c]) -> nil } -> nil
+  def log4 : (:a) -> nil
+end

data/smoke/block-args1-rest.rb

@@ -0,0 +1,62 @@
+StringArray = ["str"] + ["str"]
+
+def f1(&blk)
+  yield *StringArray
+  blk
+end
+def log1(a, o, c); end
+f1 do |a, o=:opt, c|
+  log1(a, o, c)
+end
+
+def f2(&blk)
+  yield :a, *StringArray
+  blk
+end
+def log2(a, o, c); end
+f2 do |a, o=:opt, c|
+  log2(a, o, c)
+end
+
+def f3(&blk)
+  yield :a, :b, *StringArray
+  blk
+end
+def log3(a, o, c); end
+f3 do |a, o=:opt, c|
+  log3(a, o, c)
+end
+
+def f4(&blk)
+  yield :a, :b, :c, *StringArray
+  blk
+end
+def log4(a, o, c); end
+f4 do |a, o=:opt, c|
+  log4(a, o, c)
+end
+
+def f5(&blk)
+  yield :a, :b, :c, :d, *StringArray
+  blk
+end
+def log5(a, o, c); end
+f5 do |a, o=:opt, c|
+  log5(a, o, c)
+end
+
+__END__
+# Classes
+class Object
+  StringArray : Array[String]
+  def f1 : { (*String) -> nil } -> (^(String, ?:opt | String, String) -> nil)
+  def log1 : (String, :opt | String, String) -> nil
+  def f2 : { (:a, *String) -> nil } -> (^(:a, ?:opt | String, String) -> nil)
+  def log2 : (:a, :opt | String, String) -> nil
+  def f3 : { (:a, :b, *String) -> nil } -> (^(:a, ?:b | :opt, :b | String) -> nil)
+  def log3 : (:a, :b | :opt, :b | String) -> nil
+  def f4 : { (:a, :b, :c, *String) -> nil } -> (^(:a, ?:b | :opt, :b | :c) -> nil)
+  def log4 : (:a, :b | :opt, :b | :c) -> nil
+  def f5 : { (:a, :b, :c, :d, *String) -> nil } -> (^(:a, ?:b | :opt, :b | :c) -> nil)
+  def log5 : (:a, :b | :opt, :b | :c) -> nil
+end

data/smoke/block-args1.rb

@@ -0,0 +1,59 @@
+def f1(&blk)
+  yield
+  blk
+end
+def log1(a, o, c); end
+f1 do |a, o=:opt, c|
+  log1(a, o, c)
+end
+
+def f2(&blk)
+  yield :a
+  blk
+end
+def log2(a, o, c); end
+f2 do |a, o=:opt, c|
+  log2(a, o, c)
+end
+
+def f3(&blk)
+  yield :a, :b
+  blk
+end
+def log3(a, o, c); end
+f3 do |a, o=:opt, c|
+  log3(a, o, c)
+end
+
+def f4(&blk)
+  yield :a, :b, :c
+  blk
+end
+def log4(a, o, c); end
+f4 do |a, o=:opt, c|
+  log4(a, o, c)
+end
+
+def f5(&blk)
+  yield :a, :b, :c, :d
+  blk
+end
+def log5(a, o, c); end
+f5 do |a, o=:opt, c|
+  log5(a, o, c)
+end
+
+__END__
+# Classes
+class Object
+  def f1 : { -> nil } -> ^(nil, ?:opt, nil) -> nil
+  def log1 : (nil, :opt, nil) -> nil
+  def f2 : { (:a) -> nil } -> ^(:a, ?:opt, nil) -> nil
+  def log2 : (:a, :opt, nil) -> nil
+  def f3 : { (:a, :b) -> nil } -> ^(:a, ?:opt, :b) -> nil
+  def log3 : (:a, :opt, :b) -> nil
+  def f4 : { (:a, :b, :c) -> nil } -> (^(:a, ?:b | :opt, :c) -> nil)
+  def log4 : (:a, :b | :opt, :c) -> nil
+  def f5 : { (:a, :b, :c, :d) -> nil } -> (^(:a, ?:b | :opt, :c) -> nil)
+  def log5 : (:a, :b | :opt, :c) -> nil
+end

data/smoke/block-args2-rest.rb

@@ -0,0 +1,62 @@
+StringArray = ["str"] + ["str"]
+
+def f1(&blk)
+  yield *StringArray
+  blk
+end
+def log1(a, r, c); end
+f1 do |a, *r, c|
+  log1(a, r, c)
+end
+
+def f2(&blk)
+  yield :a, *StringArray
+  blk
+end
+def log2(a, r, c); end
+f2 do |a, *r, c|
+  log2(a, r, c)
+end
+
+def f3(&blk)
+  yield :a, :b, *StringArray
+  blk
+end
+def log3(a, r, c); end
+f3 do |a, *r, c|
+  log3(a, r, c)
+end
+
+def f4(&blk)
+  yield :a, :b, :c, *StringArray
+  blk
+end
+def log4(a, r, c); end
+f4 do |a, *r, c|
+  log4(a, r, c)
+end
+
+def f5(&blk)
+  yield :a, :b, :c, :d, *StringArray
+  blk
+end
+def log5(a, r, c); end
+f5 do |a, *r, c|
+  log5(a, r, c)
+end
+
+__END__
+# Classes
+class Object
+  StringArray : Array[String]
+  def f1 : { (*String) -> nil } -> ^(String, *String, String) -> nil
+  def log1 : (String, Array[String], String) -> nil
+  def f2 : { (:a, *String) -> nil } -> ^(:a, *String, String) -> nil
+  def log2 : (:a, Array[String], String) -> nil
+  def f3 : { (:a, :b, *String) -> nil } -> (^(:a, *:b | String, :b | String) -> nil)
+  def log3 : (:a, Array[:b | String], :b | String) -> nil
+  def f4 : { (:a, :b, :c, *String) -> nil } -> (^(:a, *:b | :c | String, :c | String) -> nil)
+  def log4 : (:a, Array[:b | :c | String], :c | String) -> nil
+  def f5 : { (:a, :b, :c, :d, *String) -> nil } -> (^(:a, *:b | :c | :d | String, :d | String) -> nil)
+  def log5 : (:a, Array[:b | :c | :d | String], :d | String) -> nil
+end

data/smoke/block-args2.rb

@@ -0,0 +1,59 @@
+def f1(&blk)
+  yield
+  blk
+end
+def log1(a, r, c); end
+f1 do |a, *r, c|
+  log1(a, r, c)
+end
+
+def f2(&blk)
+  yield :a
+  blk
+end
+def log2(a, r, c); end
+f2 do |a, *r, c|
+  log2(a, r, c)
+end
+
+def f3(&blk)
+  yield :a, :b
+  blk
+end
+def log3(a, r, c); end
+f3 do |a, *r, c|
+  log3(a, r, c)
+end
+
+def f4(&blk)
+  yield :a, :b, :c
+  blk
+end
+def log4(a, r, c); end
+f4 do |a, *r, c|
+  log4(a, r, c)
+end
+
+def f5(&blk)
+  yield :a, :b, :c, :d
+  blk
+end
+def log5(a, r, c); end
+f5 do |a, *r, c|
+  log5(a, r, c)
+end
+
+__END__
+# Classes
+class Object
+  def f1 : { -> nil } -> ^(nil, *bot, nil) -> nil
+  def log1 : (nil, [], nil) -> nil
+  def f2 : { (:a) -> nil } -> ^(:a, *bot, nil) -> nil
+  def log2 : (:a, [], nil) -> nil
+  def f3 : { (:a, :b) -> nil } -> ^(:a, *bot, :b) -> nil
+  def log3 : (:a, [], :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)
+  def log5 : (:a, [:b, :c], :d) -> nil
+end

data/smoke/block-args3-rest.rb

@@ -0,0 +1,73 @@
+StringArray = ["str"] + ["str"]
+
+def f1(&blk)
+  yield *StringArray
+  blk
+end
+def log1(a, o, r, c); end
+f1 do |a, o=:opt, *r, c|
+  log1(a, o, r, c)
+end
+
+def f2(&blk)
+  yield :a, *StringArray
+  blk
+end
+def log2(a, o, r, c); end
+f2 do |a, o=:opt, *r, c|
+  log2(a, o, r, c)
+end
+
+def f3(&blk)
+  yield :a, :b, *StringArray
+  blk
+end
+def log3(a, o, r, c); end
+f3 do |a, o=:opt, *r, c|
+  log3(a, o, r, c)
+end
+
+def f4(&blk)
+  yield :a, :b, :c, *StringArray
+  blk
+end
+def log4(a, o, r, c); end
+f4 do |a, o=:opt, *r, c|
+  log4(a, o, r, c)
+end
+
+def f5(&blk)
+  yield :a, :b, :c, :d, *StringArray
+  blk
+end
+def log5(a, o, r, c); end
+f5 do |a, o=:opt, *r, c|
+  log5(a, o, r, c)
+end
+
+def f6(&blk)
+  yield :a, :b, :c, :d, :e, *StringArray
+  blk
+end
+def log6(a, o, r, c); end
+f6 do |a, o=:opt, *r, c|
+  log6(a, o, r, c)
+end
+
+__END__
+# Classes
+class Object
+  StringArray : Array[String]
+  def f1 : { (*String) -> nil } -> (^(String, ?:opt | String, *String, String) -> nil)
+  def log1 : (String, :opt | String, Array[String], String) -> nil
+  def f2 : { (:a, *String) -> nil } -> (^(:a, ?:opt | String, *String, String) -> nil)
+  def log2 : (:a, :opt | String, Array[String], String) -> nil
+  def f3 : { (:a, :b, *String) -> nil } -> (^(:a, ?:b | :opt, *String, :b | String) -> nil)
+  def log3 : (:a, :b | :opt, Array[String], :b | String) -> nil
+  def f4 : { (:a, :b, :c, *String) -> nil } -> (^(:a, ?:b | :opt, *:c | String, :c | String) -> nil)
+  def log4 : (:a, :b | :opt, Array[:c | String], :c | String) -> nil
+  def f5 : { (:a, :b, :c, :d, *String) -> nil } -> (^(:a, ?:b | :opt, *:c | :d | String, :d | String) -> nil)
+  def log5 : (:a, :b | :opt, Array[:c | :d | String], :d | String) -> nil
+  def f6 : { (:a, :b, :c, :d, :e, *String) -> nil } -> (^(:a, ?:b | :opt, *:c | :d | :e | String, :e | String) -> nil)
+  def log6 : (:a, :b | :opt, Array[:c | :d | :e | String], :e | String) -> nil
+end

data/smoke/block-args3.rb

@@ -0,0 +1,70 @@
+def f1(&blk)
+  yield
+  blk
+end
+def log1(a, o, r, c); end
+f1 do |a, o=:opt, *r, c|
+  log1(a, o, r, c)
+end
+
+def f2(&blk)
+  yield :a
+  blk
+end
+def log2(a, o, r, c); end
+f2 do |a, o=:opt, *r, c|
+  log2(a, o, r, c)
+end
+
+def f3(&blk)
+  yield :a, :b
+  blk
+end
+def log3(a, o, r, c); end
+f3 do |a, o=:opt, *r, c|
+  log3(a, o, r, c)
+end
+
+def f4(&blk)
+  yield :a, :b, :c
+  blk
+end
+def log4(a, o, r, c); end
+f4 do |a, o=:opt, *r, c|
+  log4(a, o, r, c)
+end
+
+def f5(&blk)
+  yield :a, :b, :c, :d
+  blk
+end
+def log5(a, o, r, c); end
+f5 do |a, o=:opt, *r, c|
+  log5(a, o, r, c)
+end
+
+def f6(&blk)
+  yield :a, :b, :c, :d, :e
+  blk
+end
+def log6(a, o, r, c); end
+f6 do |a, o=:opt, *r, c|
+  log6(a, o, r, c)
+end
+
+__END__
+# Classes
+class Object
+  def f1 : { -> nil } -> ^(nil, ?:opt, *bot, nil) -> nil
+  def log1 : (nil, :opt, [], nil) -> nil
+  def f2 : { (:a) -> nil } -> ^(:a, ?:opt, *bot, nil) -> nil
+  def log2 : (:a, :opt, [], nil) -> nil
+  def f3 : { (:a, :b) -> nil } -> ^(:a, ?:opt, *bot, :b) -> nil
+  def log3 : (:a, :opt, [], :b) -> nil
+  def f4 : { (:a, :b, :c) -> nil } -> (^(:a, ?:b | :opt, *bot, :c) -> nil)
+  def log4 : (:a, :b | :opt, [], :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)
+  def log6 : (:a, :b | :opt, [:c, :d], :e) -> nil
+end