typeprof 0.3.0 → 0.4.0

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/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/instance_eval.rb

@@ -13,6 +13,6 @@ end
 __END__
 # Classes
 class C
-  def self.foo : -> C
+  def self.foo : { (C) -> nil } -> C
   def log : (Integer) -> nil
 end

data/smoke/int_times.rb

@@ -1,7 +1,7 @@
 def foo(n)
   z = "str"
   n.times {|i| z = i }
-  # TODO: n.times { z = 42 }
+  n.times { z = 42 }
   z
 end
 

data/smoke/multiple-superclass.rb

@@ -14,6 +14,10 @@ __END__
 smoke/multiple-superclass.rb:9: [warning] superclass is not a class; Object is used instead
 
 # Classes
+class Object
+  Base : A.class | B.class
+end
+
 class A
 end
 

data/smoke/next2.rb

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

data/smoke/optional3.rb

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

data/smoke/proc4.rb

@@ -7,5 +7,5 @@ foo(-> x { "str" })
 __END__
 # Classes
 class Object
-  def foo : (Proc[(Integer) -> String]) -> String
+  def foo : (^(Integer) -> String) -> String
 end

data/smoke/rbs-proc1.rb

@@ -0,0 +1,9 @@
+def log
+  Foo.new.foo.call(42)
+end
+
+__END__
+# Classes
+class Object
+  def log : -> Integer
+end

data/smoke/rbs-proc1.rbs

@@ -0,0 +1,3 @@
+class Foo
+  def foo: -> ^(Integer) -> Integer
+end

data/smoke/rbs-proc2.rb

@@ -0,0 +1,20 @@
+# two issues:
+# (1) TypedProc should call `-> n { log1(n) }` with an Integer, but not implemented yet
+# (2) log1 returns a String, which is inconsistent and should be reported
+
+def log1(n)
+  n.to_s # XXX: should be reported as "inconsistent with RBS"
+end
+
+def log2
+  Foo.new.foo(-> n { log1(n) })
+end
+
+log2
+
+__END__
+# Classes
+class Object
+  def log1 : (untyped) -> untyped
+  def log2 : -> String
+end