typeprof 0.1.0

data/smoke/constant2.rb

@@ -0,0 +1,33 @@
+def foo(x)
+end
+
+foo(UNDEFINED_CONSTANT)
+foo(1)
+
+C = "dummy"
+class C
+  def foo
+  end
+  self.new.foo
+end
+
+BAR = 1
+BAR = "str"
+def log(x)
+end
+log(BAR)
+
+__END__
+# Errors
+smoke/constant2.rb:8: [error] the class "C" is String
+smoke/constant2.rb:15: [warning] already initialized constant Object::BAR
+
+# Classes
+class Object
+  def foo : (Integer | untyped) -> nil
+  def log : (String) -> nil
+end
+
+class C(dummy)
+  def foo : -> nil
+end

data/smoke/constant3.rb

@@ -0,0 +1,9 @@
+def foo
+  1::Foo
+end
+foo
+__END__
+# Classes
+class Object
+  def foo : -> untyped
+end

data/smoke/constant4.rb

@@ -0,0 +1,11 @@
+def foo
+  Complex::I
+end
+
+foo
+
+__END__
+# Classes
+class Object
+  def foo : -> Complex
+end

data/smoke/context-sensitive1.rb

@@ -0,0 +1,12 @@
+def foo(x)
+  x
+end
+
+x = nil
+foo(x || 1)
+
+__END__
+# Classes
+class Object
+  def foo : (Integer) -> Integer
+end

data/smoke/cvar.rb

@@ -0,0 +1,28 @@
+def log1(x)
+end
+
+def log2(x)
+end
+
+class A
+  FOO=1
+  @@var = 1
+  log1(@@var)
+  def foo
+    log2(@@var)
+  end
+end
+
+A.new.foo
+
+__END__
+# Classes
+class Object
+  def log1 : (Integer) -> nil
+  def log2 : (Integer) -> nil
+end
+
+class A
+  @@var : Integer
+  def foo : -> nil
+end

data/smoke/cvar2.rb

@@ -0,0 +1,17 @@
+class A
+  @@var = :a
+end
+
+class B < A
+  @@var = :b
+end
+
+__END__
+# Classes
+class A
+  @@var : :a
+end
+
+class B < A
+  @@var : :b
+end

data/smoke/demo.rb

@@ -0,0 +1,80 @@
+def foo(x)
+  if x
+    42
+  else
+    "str"
+  end
+end
+
+foo(true)
+foo(false)
+
+# Object#foo :: (Boolean) -> (String | Integer)
+
+
+# overrided method
+def identity(x)
+  x
+end
+
+identity(42)
+identity("str")
+identity(:sym)
+
+# Object#identity :: (Integer) -> Integer
+# Object#identity :: (String) -> String
+# Object#identity :: (Symbol) -> Symbol
+
+
+# recursive method
+def fib(x)
+  if x <= 1
+    x
+  else
+    fib(x - 1) + fib(x - 2)
+  end
+end
+
+fib(40000)
+
+# Object#fib :: (Integer) -> Integer
+
+
+# user-defined classes
+class A
+  def foo(x)
+    bar(x)
+  end
+
+  def bar(x)
+  end
+end
+
+class B < A
+  def bar(x)
+  end
+end
+A.new.foo(1)
+B.new.foo("str")
+
+# A#foo :: (Integer) -> NilClass
+# A#bar :: (Integer) -> NilClass
+# B#foo :: (String) -> NilClass
+# B#bar :: (String) -> NilClass
+
+__END__
+# Classes
+class Object
+  def foo : (bool) -> (Integer | String)
+  def identity : (:sym | Integer | String) -> (:sym | Integer | String)
+  def fib : (Integer) -> Integer
+end
+
+class A
+  def foo : (Integer | String) -> nil
+  def bar : (Integer | String) -> nil
+end
+
+class B < A
+  def bar : (Integer | String) -> nil
+end

data/smoke/demo1.rb

@@ -0,0 +1,16 @@
+def foo(x)
+  if x
+    42
+  else
+    "str"
+  end
+end
+
+foo(true)
+foo(false)
+
+__END__
+# Classes
+class Object
+  def foo : (bool) -> (Integer | String)
+end

data/smoke/demo10.rb

@@ -0,0 +1,20 @@
+def bar
+  yield
+end
+
+def foo
+  x = 42
+  bar do
+    x = "STR"
+  end
+  x
+end
+
+foo
+
+__END__
+# Classes
+class Object
+  def bar : { () -> String } -> String
+  def foo : -> (Integer | String)
+end

data/smoke/demo11.rb

@@ -0,0 +1,11 @@
+def swap(a)
+  [a[1], a[0]]
+end
+a = [42, "str"]
+swap(a)
+
+__END__
+# Classes
+class Object
+  def swap : ([Integer, String]) -> [String, Integer]
+end

data/smoke/demo2.rb

@@ -0,0 +1,14 @@
+# override
+def my_to_s(x)
+  x.to_s
+end
+
+my_to_s(42)
+my_to_s("str")
+my_to_s(:sym)
+
+__END__
+# Classes
+class Object
+  def my_to_s : (:sym | Integer | String) -> String
+end

data/smoke/demo3.rb

@@ -0,0 +1,16 @@
+# recursive method
+def fib(x)
+  if x <= 1
+    x
+  else
+    fib(x - 1) + fib(x - 2)
+  end
+end
+
+fib(40000)
+
+__END__
+# Classes
+class Object
+  def fib : (Integer) -> Integer
+end

data/smoke/demo4.rb

@@ -0,0 +1,27 @@
+# user-defined classes
+class A
+  def foo(x)
+    bar(x)
+  end
+
+  def bar(x)
+  end
+end
+
+class B < A
+  def bar(x)
+  end
+end
+A.new.foo(1)
+B.new.foo("str")
+
+__END__
+# Classes
+class A
+  def foo : (Integer | String) -> nil
+  def bar : (Integer | String) -> nil
+end
+
+class B < A
+  def bar : (Integer | String) -> nil
+end

data/smoke/demo5.rb

@@ -0,0 +1,13 @@
+class A
+  def self.foo(x); "str"; end
+end
+class B < A
+end
+A.foo(1)
+B.foo(Integer)
+
+__END__
+# Classes
+class A
+  def self.foo : (Integer | Integer.class) -> String
+end

data/smoke/demo6.rb

@@ -0,0 +1,21 @@
+class Foo
+  def foo=(x)
+    @foo = x
+  end
+
+  def foo
+    @foo
+  end
+end
+
+Foo.new.foo = 1
+Foo.new.foo = "str"
+Foo.new.foo
+
+__END__
+# Classes
+class Foo
+  @foo : Integer | String
+  def foo= : (Integer | String) -> (Integer | String)
+  def foo : -> (Integer | String)
+end

data/smoke/demo7.rb

@@ -0,0 +1,14 @@
+def foo(x)
+  yield 42
+end
+
+s = "str"
+foo(1) do |x|
+  s
+end
+
+__END__
+# Classes
+class Object
+  def foo : (Integer) { (Integer) -> String } -> String
+end

data/smoke/demo8.rb

@@ -0,0 +1,18 @@
+def foo
+  yield "str"
+end
+
+def bar
+  yield :sym
+end
+
+blk = -> x { x }
+foo(&blk)
+bar(&blk)
+
+__END__
+# Classes
+class Object
+  def foo : { (String) -> (:sym | String) } -> (:sym | String)
+  def bar : { (:sym) -> (:sym | String) } -> (:sym | String)
+end

data/smoke/demo9.rb

@@ -0,0 +1,18 @@
+F = -> x { "str" }
+
+def foo(&blk)
+  blk.call(:sym, &F)
+end
+
+foo do |dummy, &blk|
+  blk.call(42)
+end
+
+# truly expected:
+# Object#foo :: (&Proc[(Symbol, &Proc[(Integer) -> String]) -> String]) -> String
+
+__END__
+# Classes
+class Object
+  def foo : { (:sym) { (Integer) -> String } -> String } -> String
+end

data/smoke/dummy-execution1.rb

@@ -0,0 +1,14 @@
+def foo(n)
+  n
+end
+
+def bar
+  foo(1)
+end
+
+__END__
+# Classes
+class Object
+  def foo : (Integer | untyped) -> (Integer | untyped)
+  def bar : -> (Integer | untyped)
+end

data/smoke/dummy-execution2.rb

@@ -0,0 +1,16 @@
+class Foo
+  def foo(n)
+    n
+  end
+
+  def self.bar
+    new.foo(1)
+  end
+end
+
+__END__
+# Classes
+class Foo
+  def foo : (Integer | untyped) -> (Integer | untyped)
+  def self.bar : -> (Integer | untyped)
+end

data/smoke/ensure1.rb

@@ -0,0 +1,20 @@
+def foo(x)
+  42
+end
+
+def bar
+  x = 1
+  x = "str"
+  x = :sym
+ensure
+  foo(x)
+end
+
+bar
+
+__END__
+# Classes
+class Object
+  def foo : ((:sym | Integer | String)?) -> Integer
+  def bar : -> :sym
+end