typeprof 0.2.0 → 0.5.0

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

data/smoke/block-blockarg.rb

@@ -0,0 +1,27 @@
+def log1(x); end
+def log2(x); end
+def log3(x); end
+
+def f(&blk)
+  log3(
+    blk.call do |x|
+      log1(x)
+      :b
+    end
+  )
+  :d
+end
+
+f do |&blk|
+  log2(blk.call(:a))
+  :c
+end
+
+__END__
+# Classes
+class Object
+  def log1 : (:a) -> nil
+  def log2 : (:b) -> nil
+  def log3 : (:c) -> nil
+  def f : { { (:a) -> :b } -> :c } -> :d
+end

data/smoke/block-kwarg.rb

@@ -0,0 +1,52 @@
+def f1
+  yield k: 1
+end
+def log1(n); end
+f1 {|k:| log1(k) }
+
+def f2
+  yield k: 1
+end
+def log2(n); end
+f2 {|k: :opt| log2(k) }
+
+def f3
+  yield k: 1
+end
+def log3(n); end
+f3 {|k: "str"| log3(k) }
+
+def f4
+  yield k: 1
+end
+def log4(kwrest); end
+f4 {|**kwrest| log4(kwrest) }
+
+def f5
+  yield k: 1
+end
+f5 {|| }
+
+def f6
+  yield
+end
+f6 {|k:| }
+
+__END__
+# Errors
+smoke/block-kwarg.rb:26: [error] unknown keyword: k
+smoke/block-kwarg.rb:31: [error] no argument for required keywords
+
+# Classes
+class Object
+  def f1 : { -> nil } -> nil
+  def log1 : (Integer) -> nil
+  def f2 : { -> nil } -> nil
+  def log2 : (:opt | Integer) -> nil
+  def f3 : { -> nil } -> nil
+  def log3 : (Integer | String) -> nil
+  def f4 : { -> nil } -> nil
+  def log4 : ({k: Integer}) -> nil
+  def f5 : { -> nil } -> untyped
+  def f6 : { -> nil } -> untyped
+end

data/smoke/block10.rb

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

data/smoke/block11.rb

@@ -34,6 +34,6 @@ class Object
   def log1 : (Integer?) -> nil
   def log2 : (Integer?) -> nil
   def foo : -> Integer?
-  def test_yield : { () -> nil } -> nil
+  def test_yield : { -> nil } -> nil
   def bar : -> Integer?
 end

data/smoke/block14.rb

@@ -0,0 +1,17 @@
+def foo(&blk)
+  $blk = blk
+  nil
+end
+
+foo {|n| }
+
+$blk.call(42)
+
+__END__
+# Global variables
+$blk : ^(Integer) -> nil
+
+# Classes
+class Object
+  def foo : { (Integer) -> nil } -> nil
+end

data/smoke/block4.rb

@@ -13,6 +13,6 @@ bar(&blk)
 __END__
 # Classes
 class Object
-  def foo : { (String) -> (:sym | String) } -> (:sym | String)
-  def bar : { (:sym) -> (:sym | String) } -> (:sym | String)
+  def foo : { (:sym | String) -> (:sym | String) } -> (:sym | String)
+  def bar : { (:sym | String) -> (:sym | String) } -> (:sym | String)
 end

data/smoke/block5.rb

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

data/smoke/block6.rb

@@ -15,6 +15,6 @@ foo
 __END__
 # Classes
 class Object
-  def bar : { () -> String } -> String
+  def bar : { -> String } -> String
   def foo : -> (Integer | String)
 end

data/smoke/block7.rb

@@ -11,8 +11,6 @@ __END__
 # Errors
 smoke/block7.rb:5: [error] undefined method: Object#undefined_method
 smoke/block7.rb:8: [error] wrong argument type Integer<1> (expected Proc)
-smoke/block7.rb:2: [warning] non-iseq-proc is passed as a block
-smoke/block7.rb:2: [warning] non-iseq-proc is passed as a block
 
 # Classes
 class Object

data/smoke/block8.rb

@@ -21,7 +21,7 @@ foo
 __END__
 # Classes
 class Object
-  def bar : -> String
-  def baz : { () -> String } -> String
+  def bar : { -> String } -> String
+  def baz : { -> String } -> String
   def foo : -> (Integer | String)
 end

data/smoke/block9.rb

@@ -8,5 +8,5 @@ foo { }
 __END__
 # Classes
 class Object
-  def foo : -> Integer
+  def foo : { -> nil } -> Integer
 end

data/smoke/blown.rb

@@ -8,5 +8,5 @@ foo { }
 __END__
 # Classes
 class Object
-  def foo : -> ([Proc[] | Proc[]])
+  def foo : { -> nil } -> [^-> nil]
 end

data/smoke/class-hierarchy.rb

@@ -0,0 +1,54 @@
+A = 1
+
+module Lib
+  module Mod
+  end
+  class Base
+  end
+end
+
+module App
+  class Foo < Lib::Base
+    include Lib::Mod
+    CONST1 = Foo.new
+    class Bar
+      CONST2 = Bar.new
+    end
+  end
+
+  CONST3 = Foo::Bar.new
+  class Baz < App::Foo
+    CONST4 = Foo::Bar.new
+  end
+end
+
+__END__
+# Classes
+class Object
+  A : Integer
+end
+
+module Lib
+  module Mod
+  end
+
+  class Base
+  end
+end
+
+module App
+  CONST3 : Foo::Bar
+
+  class Foo < Lib::Base
+    CONST1 : Foo
+    include Lib::Mod
+
+    class Bar
+      CONST2 : Bar
+    end
+  end
+
+  class Baz < Foo
+    CONST4 : Foo::Bar
+  end
+end

data/smoke/class-hierarchy2.rb

@@ -0,0 +1,27 @@
+class A
+  class B
+    class C
+      def get_a
+        A.new
+      end
+      def get_b
+        B.new
+      end
+      def get_c
+        C.new
+      end
+    end
+  end
+end
+
+__END__
+# Classes
+class A
+  class B
+    class C
+      def get_a : -> A
+      def get_b : -> B
+      def get_c : -> C
+    end
+  end
+end

data/smoke/constant1.rb

@@ -30,12 +30,17 @@ Foo::Bar.new.get4 # Integer
 
 __END__
 # Classes
-class Foo
+class Object
+  CONST : Integer
 end
 
-class Foo::Bar
-  def get1 : -> String
-  def get2 : -> Integer
-  def get3 : -> Integer
-  def get4 : -> Integer
+class Foo
+  CONST : String
+
+  class Bar
+    def get1 : -> String
+    def get2 : -> Integer
+    def get3 : -> Integer
+    def get4 : -> Integer
+  end
 end

data/smoke/constant2.rb

@@ -24,6 +24,8 @@ 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

data/smoke/cvar.rb

@@ -23,6 +23,7 @@ class Object
 end
 
 class A
+  FOO : Integer
   @@var : Integer
   def foo : -> nil
 end

data/smoke/demo10.rb

@@ -15,6 +15,6 @@ foo
 __END__
 # Classes
 class Object
-  def bar : { () -> String } -> String
+  def bar : { -> String } -> String
   def foo : -> (Integer | String)
 end

data/smoke/demo8.rb

@@ -13,6 +13,6 @@ bar(&blk)
 __END__
 # Classes
 class Object
-  def foo : { (String) -> (:sym | String) } -> (:sym | String)
-  def bar : { (:sym) -> (:sym | String) } -> (:sym | String)
+  def foo : { (:sym | String) -> (:sym | String) } -> (:sym | String)
+  def bar : { (:sym | String) -> (:sym | String) } -> (:sym | String)
 end

data/smoke/demo9.rb

@@ -8,11 +8,9 @@ foo do |dummy, &blk|
   blk.call(42)
 end
 
-# truly expected:
-# Object#foo :: (&Proc[(Symbol, &Proc[(Integer) -> String]) -> String]) -> String
-
 __END__
 # Classes
 class Object
+  F : ^(Integer) -> String
   def foo : { (:sym) { (Integer) -> String } -> String } -> String
 end

data/smoke/flow7.rb

@@ -14,13 +14,7 @@ foo("str")
 foo(:sym)
 
 __END__
-# Errors
-smoke/flow7.rb:4: [error] failed to resolve overload: String#+
-smoke/flow7.rb:4: [error] undefined method: :sym#+
-smoke/flow7.rb:6: [error] failed to resolve overload: Integer#+
-smoke/flow7.rb:6: [error] undefined method: :sym#+
-
 # Classes
 class Object
-  def foo : (:sym | Integer | String) -> (:sym | Integer | String | untyped)
+  def foo : (:sym | Integer | String) -> (:sym | Integer | String)
 end

data/smoke/flow8.rb

@@ -0,0 +1,13 @@
+def foo(n)
+  n = n || 42
+  n
+end
+
+foo(1)
+foo(nil)
+
+__END__
+# Classes
+class Object
+  def foo : (Integer?) -> Integer
+end

data/smoke/hash-fetch.rb

@@ -21,7 +21,7 @@ baz(h)
 __END__
 # Classes
 class Object
-  def foo : ({:a=>:A, :b=>:B}) -> (:A | :B)
-  def bar : ({:a=>:A, :b=>:B}) -> (:A | :B | :C)
-  def baz : ({:a=>:A, :b=>:B}) -> ([:A | :B | :C, (:a | :b)?])
+  def foo : ({a: :A, b: :B}) -> (:A | :B)
+  def bar : ({a: :A, b: :B}) -> (:A | :B | :C)
+  def baz : ({a: :A, b: :B}) -> ([:A | :B | :C, (:a | :b)?])
 end