typeprof 0.1.0

data/smoke/req-keyword.rb

@@ -0,0 +1,12 @@
+def foo(a:)
+  foo(a: a + 1) if rand < 0.5
+  a
+end
+
+foo(a:1)
+
+__END__
+# Classes
+class Object
+  def foo : (a: Integer) -> Integer
+end

data/smoke/rescue1.rb

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

data/smoke/rescue2.rb

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

data/smoke/respond_to.rb

@@ -0,0 +1,22 @@
+def foo(n)
+  if n.respond_to?(:times)
+    n.times {|_| n = :sym }
+  elsif n.respond_to?(:+)
+    n + "foo"
+  else
+    n & false
+  end
+end
+
+
+foo(1)
+foo("str")
+foo(true)
+
+# no error expected
+
+__END__
+# Classes
+class Object
+  def foo : (Integer | String | true) -> (Integer | String | bool)
+end

data/smoke/rest-farg.rb

@@ -0,0 +1,10 @@
+def foo
+  a = ["", ""]
+  "".start_with?("", *a)
+end
+
+__END__
+# Classes
+class Object
+  def foo : -> bool
+end

data/smoke/rest1.rb

@@ -0,0 +1,25 @@
+def foo(a, *r, z)
+  r
+end
+
+foo(1, 2, "S", 3)
+foo(1, 2, 3)
+foo("a", "b", "c")
+foo(:a, :z)
+
+def bar(a, o=1, *r, z)
+  r
+end
+
+bar("A", "Z")
+bar("A", "B", "Z")
+bar("A", "B", "C", "Z")
+bar("A", "B", "C", "D", "Z")
+bar("A", "B", "C", "D", "E", "Z")
+
+__END__
+# Classes
+class Object
+  def foo : (:a | Integer | String, *Integer | String, :z | Integer | String) -> (Array[Integer | String])
+  def bar : (String, ?String, *String, String) -> Array[String]
+end

data/smoke/rest2.rb

@@ -0,0 +1,30 @@
+def foo(a, b, c)
+  [a, b, c]
+end
+
+a = [1, "S", :s]
+foo(*a)
+
+#def bar(a, b, c)
+#  [a, b,  d]
+#end
+#def baz(a, b, c)
+#  [a, b,  d]
+#end
+#def qux(a, b, c)
+#  [a, b,  d]
+#end
+#a = ["S", :s]
+#bar(1, *a)
+
+#a = ["S"] + [:s]
+#baz(1, *a)
+
+#a = [1, "S"]
+#qux(*a, :s)
+
+__END__
+# Classes
+class Object
+  def foo : (:s | Integer | String, :s | Integer | String, :s | Integer | String) -> ([:s | Integer | String, :s | Integer | String, :s | Integer | String])
+end

data/smoke/rest3.rb

@@ -0,0 +1,36 @@
+string_array = ["str"] + ["str"]
+
+def foo(*r)
+end
+foo(*string_array)
+
+def bar(*r)
+end
+bar(1, *string_array)
+
+def baz(x, *r)
+end
+baz(*string_array)
+
+def qux(x, *r)
+end
+qux(1, *string_array)
+
+def corge(*r, z)
+end
+corge(1, *string_array)
+
+def grault(a, o=1, *r, z)
+end
+grault(*string_array)
+
+__END__
+# Classes
+class Object
+  def foo : (*String) -> nil
+  def bar : (*Integer | String) -> nil
+  def baz : (String, *String) -> nil
+  def qux : (Integer, *String) -> nil
+  def corge : (*Integer | String, Integer | String) -> nil
+  def grault : (String, ?String, *String, String) -> nil
+end

data/smoke/rest4.rb

@@ -0,0 +1,18 @@
+def foo(*a)
+end
+
+a = ["str"] + ["str"]
+foo(1, *a, :s)
+
+def bar(x, y, z)
+end
+
+a = ["str"] + ["str"]
+bar(1, *a, :s)
+
+__END__
+# Classes
+class Object
+  def foo : (*:s | Integer | String) -> nil
+  def bar : (Integer, :s | String, :s | String) -> nil
+end

data/smoke/rest5.rb

@@ -0,0 +1,10 @@
+def foo(*args)
+  args
+end
+
+foo(42)
+__END__
+# Classes
+class Object
+  def foo : (*Integer) -> Array[Integer]
+end

data/smoke/rest6.rb

@@ -0,0 +1,11 @@
+def foo(o1=1, *r)
+  [r]
+end
+
+foo()
+foo("x", "x")
+__END__
+# Classes
+class Object
+  def foo : (?String, *String) -> [Array[String]]
+end

data/smoke/retry1.rb

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

data/smoke/return.rb

@@ -0,0 +1,13 @@
+def foo
+  loop do |_|
+    return 42
+  end
+  nil
+end
+
+foo
+__END__
+# Classes
+class Object
+  def foo : -> Integer
+end

data/smoke/reveal.rb

@@ -0,0 +1,13 @@
+p(1)
+p("str")
+p(:sym)
+p([1, "str", :sym])
+
+__END__
+# Revealed types
+#  smoke/reveal.rb:1 #=> Integer
+#  smoke/reveal.rb:2 #=> String
+#  smoke/reveal.rb:3 #=> :sym
+#  smoke/reveal.rb:4 #=> [Integer, String, :sym]
+
+# Classes

data/smoke/singleton_class.rb

@@ -0,0 +1,8 @@
+class << Object.new
+end
+
+__END__
+# Errors
+smoke/singleton_class.rb:1: [warning] A singleton class is open for Object; handled as any
+
+# Classes

data/smoke/singleton_method.rb

@@ -0,0 +1,9 @@
+V = Object.new
+def V.foo
+  # Currently, this call is ignored because the recv of the call is any
+  # We may allow a call whose recv is any to invoke Kernel's methods
+  p(1)
+end
+
+__END__
+# Classes

data/smoke/step.rb

@@ -0,0 +1,17 @@
+def log1(x)
+end
+def log2(x)
+end
+def log3(x)
+end
+
+log2(1.step(5) {|n| log1(n) })
+log3(1.step(5))
+
+__END__
+# Classes
+class Object
+  def log1 : (Integer | Numeric) -> nil
+  def log2 : (untyped) -> nil
+  def log3 : (Enumerator[Integer | Numeric]) -> nil
+end

data/smoke/string-split.rb

@@ -0,0 +1,11 @@
+def foo
+  "".split("").map {|n| n.to_i }
+end
+
+foo
+
+__END__
+# Classes
+class Object
+  def foo : -> Array[Integer]
+end

data/smoke/struct.rb

@@ -0,0 +1,9 @@
+# tentative
+class Foo < Struct.new(:a)
+end
+Foo.new.a = 1
+__END__
+# Classes
+class (Struct) < Struct
+  attr_accessor a() : untyped
+end

data/smoke/struct2.rb

@@ -0,0 +1,24 @@
+FooBar = Struct.new(:foo, :bar)
+class FooBar
+  def my_foo
+    foo
+  end
+end
+def gen_foobar
+  FooBar.new(1)
+end
+foobar = gen_foobar
+foobar.foo = "str"
+foobar.bar = :sym
+
+__END__
+# Classes
+class Object
+  def gen_foobar : -> FooBar
+end
+
+class FooBar < Struct
+  attr_accessor foo() : Integer | String
+  attr_accessor bar() : :sym?
+  def my_foo : -> (Integer | String)
+end

data/smoke/super1.rb

@@ -0,0 +1,50 @@
+def log(x)
+end
+
+class A; end
+class B; end
+class C; end
+class X; end
+class Y; end
+class Z; end
+
+class Foo
+  def f(x)
+    log(self)
+    X.new
+  end
+end
+
+class Bar < Foo
+  def f(x)
+    super(C.new)
+    Y.new
+  end
+end
+
+class Baz < Bar
+  def f(x)
+    super(B.new)
+    Z.new
+  end
+end
+
+Baz.new.f(A.new)
+
+__END__
+# Classes
+class Object
+  def log : (Baz) -> nil
+end
+
+class Foo
+  def f : (C) -> X
+end
+
+class Bar < Foo
+  def f : (B) -> Y
+end
+
+class Baz < Bar
+  def f : (A) -> Z
+end

data/smoke/super2.rb

@@ -0,0 +1,16 @@
+class Foo
+  def f
+    super
+  end
+end
+
+Foo.new.f
+
+__END__
+# Errors
+smoke/super2.rb:3: [error] no superclass method: Foo#f
+
+# Classes
+class Foo
+  def f : -> untyped
+end

data/smoke/super3.rb

@@ -0,0 +1,19 @@
+class Foo
+  def self.new(a)
+    super(a)
+  end
+
+  def initialize(a)
+    @a = a
+  end
+end
+
+Foo.new(1)
+
+__END__
+# Classes
+class Foo
+  @a : Integer
+  def self.new : (Integer) -> Foo
+  def initialize : (Integer) -> Integer
+end