typeprof 0.1.0

data/smoke/enumerator.rb

@@ -0,0 +1,15 @@
+def hoge
+  [1, 2, 3].map
+end
+def fuga
+  1.then
+end
+hoge
+fuga
+
+__END__
+# Classes
+class Object
+  def hoge : -> Enumerator[Integer]
+  def fuga : -> Enumerator[Integer]
+end

data/smoke/expandarray1.rb

@@ -0,0 +1,22 @@
+def foo
+  if rand < 0.5
+    unknown
+  else
+    [:a, [:b, :c]]
+  end
+end
+
+a, (b, c) = foo
+
+p(a)
+__END__
+# Errors
+smoke/expandarray1.rb:3: [error] undefined method: Object#unknown
+
+# Revealed types
+#  smoke/expandarray1.rb:11 #=> :a | untyped
+
+# Classes
+class Object
+  def foo : -> ([:a, [:b, :c]] | untyped)
+end

data/smoke/expandarray2.rb

@@ -0,0 +1,23 @@
+def foo
+  if rand < 0.5
+    unknown
+  else
+    [:a, [:b, :c]]
+  end
+end
+
+a, *bc = foo
+
+p(a)
+
+__END__
+# Errors
+smoke/expandarray2.rb:3: [error] undefined method: Object#unknown
+
+# Revealed types
+#  smoke/expandarray2.rb:11 #=> :a | untyped
+
+# Classes
+class Object
+  def foo : -> ([:a, [:b, :c]] | untyped)
+end

data/smoke/fib.rb

@@ -0,0 +1,28 @@
+class Fib
+  def fib_loop(x)
+    a, b = 0, 1
+    while x > 0
+      a, b = b, a+b
+      x -= 1
+    end
+    a
+  end
+
+  def fib_rec(x)
+    if x <= 1
+      x
+    else
+      fib_rec(x-1) + fib_rec(x-2)
+    end
+  end
+end
+
+Fib.new.fib_loop(42)
+Fib.new.fib_rec(42)
+
+__END__
+# Classes
+class Fib
+  def fib_loop : (Integer) -> Integer
+  def fib_rec : (Integer) -> Integer
+end

data/smoke/flow1.rb

@@ -0,0 +1,16 @@
+def foo(n)
+  if n.is_a?(Integer)
+    n + 1
+  else
+    n + "STR"
+  end
+end
+
+foo(42)
+foo("str")
+
+__END__
+# Classes
+class Object
+  def foo : (Integer | String) -> (Integer | String)
+end

data/smoke/flow2.rb

@@ -0,0 +1,14 @@
+def foo(x)
+  x.is_a?(Integer) ? x : x
+  1
+end
+foo(unknown)
+
+__END__
+# Errors
+smoke/flow2.rb:5: [error] undefined method: Object#unknown
+
+# Classes
+class Object
+  def foo : (untyped) -> Integer
+end

data/smoke/flow3.rb

@@ -0,0 +1,14 @@
+def foo(x)
+  if x
+    x + 1
+  end
+end
+
+foo(1)
+foo(nil)
+
+__END__
+# Classes
+class Object
+  def foo : (Integer?) -> Integer?
+end

data/smoke/flow4.rb

@@ -0,0 +1,5 @@
+while begin l = r = true; l or r end
+end
+
+__END__
+# Classes

data/smoke/flow5.rb

@@ -0,0 +1,19 @@
+def foo(x)
+  case x
+  when Integer
+    x
+  when String
+    x.to_i
+  else
+    raise
+  end
+end
+
+foo(1)
+foo("1")
+
+__END__
+# Classes
+class Object
+  def foo : (Integer | String) -> Integer
+end

data/smoke/flow6.rb

@@ -0,0 +1,19 @@
+def foo(x)
+  "s" + case x
+  when Integer
+    x.to_s
+  when String
+    x
+  else
+    raise
+  end
+end
+
+foo(1)
+foo("1")
+
+__END__
+# Classes
+class Object
+  def foo : (Integer | String) -> String
+end

data/smoke/flow7.rb

@@ -0,0 +1,26 @@
+def foo(n)
+  case n
+  when Integer
+    n + 1
+  when String
+    n + "STR"
+  else
+    n
+  end
+end
+
+foo(42)
+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)
+end

data/smoke/for.rb

@@ -0,0 +1,9 @@
+for x in [[1, 2]]
+  p x
+end
+
+__END__
+# Revealed types
+#  smoke/for.rb:2 #=> [Integer, Integer]?
+
+# Classes

data/smoke/freeze.rb

@@ -0,0 +1,11 @@
+def foo
+  [1].freeze
+end
+
+foo
+
+__END__
+# Classes
+class Object
+  def foo : -> [Integer]
+end

data/smoke/function.rb

@@ -0,0 +1,16 @@
+def no_argument
+  "str"
+end
+
+def one_argument(x)
+end
+
+no_argument
+one_argument(1)
+
+__END__
+# Classes
+class Object
+  def no_argument : -> String
+  def one_argument : (Integer) -> nil
+end

data/smoke/gvar.rb

@@ -0,0 +1,13 @@
+$foo = 1
+$foo = "str"
+def log(x); end
+log($foo)
+
+__END__
+# Global variables
+#  $foo : Integer | String
+
+# Classes
+class Object
+  def log : (Integer | String) -> nil
+end

data/smoke/hash-fetch.rb

@@ -0,0 +1,27 @@
+h = { a: :A, b: :B }
+
+def foo(h)
+  h.fetch(:a)     #=> :A | :B
+end
+def bar(h)
+  h.fetch(:a, :C) #=> :A | :B | :C
+end
+def baz(h)
+  n = nil
+  [h.fetch(:a) do |k| #=> :A | :B | :C
+    n = k #=> :A | :B
+    :C
+  end, n]
+end
+
+foo(h)
+bar(h)
+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)?])
+end

data/smoke/hash1.rb

@@ -0,0 +1,18 @@
+def foo
+  { int: 1, str: "str" }
+end
+
+foo
+
+def bar
+  { 1 => 1, 2 => "str", "s" => "s" }
+end
+
+bar
+
+__END__
+# Classes
+class Object
+  def foo : -> {:int=>Integer, :str=>String}
+  def bar : -> ({Integer=>Integer | String, String=>String})
+end

data/smoke/hash2.rb

@@ -0,0 +1,12 @@
+def foo
+  h = { int: 1, str: "str" }
+  h[:int]
+end
+
+foo
+
+__END__
+# Classes
+class Object
+  def foo : -> Integer
+end

data/smoke/hash3.rb

@@ -0,0 +1,13 @@
+def foo
+  h = {}
+  h[:int] = 1
+  h[:str] = "str"
+  h
+end
+
+foo
+__END__
+# Classes
+class Object
+  def foo : -> {:int=>Integer, :str=>String}
+end

data/smoke/hash4.rb

@@ -0,0 +1,10 @@
+def foo
+  Hash.new { |h, k| h[k] = [] }
+end
+
+foo
+__END__
+# Classes
+class Object
+  def foo : -> Hash
+end

data/smoke/hash5.rb

@@ -0,0 +1,14 @@
+class Foo
+  def foo
+    h = {}
+    key = ["str"]
+    h[key] = 1
+    h[key]
+  end
+end
+Foo.new.foo
+__END__
+# Classes
+class Foo
+  def foo : -> Integer
+end

data/smoke/inheritance.rb

@@ -0,0 +1,34 @@
+class A
+  def foo(x)
+    bar(x)
+  end
+
+  def bar(x)
+  end
+
+  def self.test(x)
+  end
+end
+
+class B < A
+  def bar(x)
+  end
+end
+
+A.new.foo(1)
+B.new.foo("str")
+B.new.bar(nil)
+A.test(1)
+B.test("str")
+
+__END__
+# Classes
+class A
+  def foo : (Integer | String) -> nil
+  def bar : (Integer | String) -> nil
+  def self.test : (Integer | String) -> nil
+end
+
+class B < A
+  def bar : ((Integer | String)?) -> nil
+end

data/smoke/inheritance2.rb

@@ -0,0 +1,29 @@
+class SuperBase
+  def self.foo
+    self
+  end
+end
+
+class Base < SuperBase
+  def self.foo
+    super
+  end
+end
+
+class A < Base
+  foo
+end
+
+class B < Base
+  foo
+end
+
+__END__
+# Classes
+class SuperBase
+  def self.foo : -> (A.class | B.class)
+end
+
+class Base < SuperBase
+  def self.foo : -> (A.class | B.class)
+end