typeprof 0.1.0

data/smoke/initialize.rb

@@ -0,0 +1,26 @@
+class A
+  def initialize(x)
+    @int = 1
+    @str = "str"
+    @val = x
+  end
+end
+
+def log(x)
+end
+log A.new(1)
+A.new("str")
+A.new(nil)
+
+__END__
+# Classes
+class Object
+  def log : (A) -> nil
+end
+
+class A
+  @int : Integer
+  @str : String
+  @val : (Integer | String)?
+  def initialize : ((Integer | String)?) -> ((Integer | String)?)
+end

data/smoke/instance_eval.rb

@@ -0,0 +1,18 @@
+class C
+  def self.foo(&blk)
+    new.instance_eval(&blk)
+  end
+  def log(n)
+  end
+end
+
+C.foo do
+  log(42)
+end
+
+__END__
+# Classes
+class C
+  def self.foo : -> C
+  def log : (Integer) -> nil
+end

data/smoke/int_times.rb

@@ -0,0 +1,14 @@
+def foo(n)
+  z = "str"
+  n.times {|i| z = i }
+  # TODO: n.times { z = 42 }
+  z
+end
+
+foo(42)
+
+__END__
+# Classes
+class Object
+  def foo : (Integer) -> (Integer | String)
+end

data/smoke/integer.rb

@@ -0,0 +1,10 @@
+def foo(x); end
+
+foo(Integer(1))
+foo(Integer("str"))
+
+__END__
+# Classes
+class Object
+  def foo : (Integer) -> nil
+end

data/smoke/ivar.rb

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

data/smoke/ivar2.rb

@@ -0,0 +1,30 @@
+class Foo
+  def initialize
+    @array = []
+    @hash = {}
+  end
+
+  def set
+    @array << 1
+    @array << "str"
+    @array << :sym
+    @hash[:a] = 1
+    @hash[:b] = "str"
+    @hash[:c] = :sym
+  end
+
+  attr_reader :array, :hash
+end
+
+Foo.new.array
+Foo.new.hash
+Foo.new.set
+
+__END__
+# Classes
+class Foo
+  attr_reader array : Array[:sym | Integer | String]
+  attr_reader hash : {:a=>Integer, :b=>String, :c=>:sym}
+  def initialize : -> {}
+  def set : -> :sym
+end

data/smoke/kernel-class.rb

@@ -0,0 +1,12 @@
+def foo(n)
+  n.class
+end
+
+foo(1)
+foo("")
+
+__END__
+# Classes
+class Object
+  def foo : (Integer | String) -> (Integer.class | String.class)
+end

data/smoke/keyword1.rb

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

data/smoke/keyword2.rb

@@ -0,0 +1,11 @@
+def foo(n: 42, s: 42)
+  [n, s]
+end
+
+foo(n: 42, s: "str")
+
+__END__
+# Classes
+class Object
+  def foo : (?n: Integer, ?s: Integer | String) -> ([Integer, Integer | String])
+end

data/smoke/keyword3.rb

@@ -0,0 +1,12 @@
+# TODO: foo should accept "s: String | [Integer]"?
+def foo(n: 42, s: [n])
+  [n, s]
+end
+
+foo(n: 42, s: "str")
+
+__END__
+# Classes
+class Object
+  def foo : (?n: Integer, ?s: String) -> ([Integer, String | [Integer]])
+end

data/smoke/keyword4.rb

@@ -0,0 +1,11 @@
+def foo(**kw)
+  kw
+end
+
+foo(n: 42, s: "str")
+
+__END__
+# Classes
+class Object
+  def foo : (**{:n=>Integer, :s=>String}) -> nil
+end

data/smoke/keyword5.rb

@@ -0,0 +1,15 @@
+def foo(req:)
+  req
+end
+
+foo()
+foo(req: 1)
+
+__END__
+# Errors
+smoke/keyword5.rb:5: [error] no argument for required keywords
+
+# Classes
+class Object
+  def foo : (req: Integer) -> Integer
+end

data/smoke/kwsplat1.rb

@@ -0,0 +1,42 @@
+def foo(k:)
+end
+
+h = { k: 42 }
+foo(**h)
+
+def bar(int:, str:)
+end
+
+if rand < 0.5
+  h = { int: 42 }
+else
+  h = { str: "str" }
+end
+bar(**h)
+
+def baz(**kw)
+end
+
+if rand < 0.5
+  h = { int: 42 }
+else
+  h = { str: "str" }
+end
+baz(**h)
+
+def qux(**kw)
+end
+
+qux(**any)
+
+__END__
+# Errors
+smoke/kwsplat1.rb:30: [error] undefined method: Object#any
+
+# Classes
+class Object
+  def foo : (k: Integer) -> nil
+  def bar : (int: Integer, str: String) -> nil
+  def baz : (**{:int=>Integer, :str=>String}) -> nil
+  def qux : (**{untyped=>untyped}) -> nil
+end

data/smoke/kwsplat2.rb

@@ -0,0 +1,12 @@
+def foo(*r, k:)
+end
+
+a = [1, 2, 3]
+h = { k: 42 }
+foo(*a, **h)
+
+__END__
+# Classes
+class Object
+  def foo : (*Integer | {:k=>Integer}, k: Integer) -> nil
+end

data/smoke/manual-rbs.rb

@@ -0,0 +1,27 @@
+def foo(n)
+  case n
+  when Integer
+    n + 1
+  when String
+    n + "STR"
+  else
+    raise
+  end
+end
+
+def ret_int
+  foo(42)
+end
+
+def ret_str
+  foo("str")
+end
+
+__END__
+# Classes
+class Object
+# def foo : (Integer) -> Integer
+#         | (String) -> String
+  def ret_int : -> Integer
+  def ret_str : -> String
+end

data/smoke/manual-rbs.rbs

@@ -0,0 +1,3 @@
+class Object
+  def foo: (Integer) -> Integer | (String) -> String
+end

data/smoke/manual-rbs2.rb

@@ -0,0 +1,20 @@
+class A
+  class B
+    def foo
+      unknown
+    end
+  end
+end
+
+def bar
+  A::B.new.foo + 1
+end
+
+__END__
+# Errors
+smoke/manual-rbs2.rb:4: [error] undefined method: A::B.class#unknown
+
+# Classes
+class Object
+  def bar : -> untyped
+end

data/smoke/manual-rbs2.rbs

@@ -0,0 +1,8 @@
+class A
+end
+
+type A::int_or_float = Integer | Float
+
+class A::B
+  def foo: -> int_or_float
+end

data/smoke/masgn1.rb

@@ -0,0 +1,13 @@
+def foo
+  ary = [1, "str", :sym, nil]
+  a, *rest, z = *ary
+  [a, rest, z]
+end
+
+foo
+
+__END__
+# Classes
+class Object
+  def foo : -> [Integer, [String, :sym], nil]
+end

data/smoke/masgn2.rb

@@ -0,0 +1,17 @@
+def ary
+  [1, "str", :sym, 1.0]
+end
+
+def foo
+  a, *rest, z = *ary
+  [a, rest, z]
+end
+
+foo
+
+__END__
+# Classes
+class Object
+  def ary : -> [Integer, String, :sym, Float]
+  def foo : -> [Integer, [String, :sym], Float]
+end

data/smoke/masgn3.rb

@@ -0,0 +1,12 @@
+def foo
+  a, b, c = 42
+  [a, b, c]
+end
+
+foo
+
+__END__
+# Classes
+class Object
+  def foo : -> [Integer, nil, nil]
+end

data/smoke/method_in_branch.rb

@@ -0,0 +1,22 @@
+if 1+1
+  def foo
+  end
+  def bar
+    foo
+    42
+  end
+else
+  def bar
+    "str"
+  end
+end
+
+bar
+
+__END__
+# Classes
+class Object
+  def foo : -> nil
+  def bar : -> Integer
+          | -> String
+end

data/smoke/module1.rb

@@ -0,0 +1,29 @@
+module M
+  def foo
+    :foo
+  end
+end
+
+class C
+  include M
+end
+
+module M
+  def bar
+    :bar
+  end
+end
+
+C.new.foo
+C.new.bar
+
+__END__
+# Classes
+module M
+  def foo : -> :foo
+  def bar : -> :bar
+end
+
+class C
+  include M
+end

data/smoke/module2.rb

@@ -0,0 +1,28 @@
+module M1
+  def foo
+    :foo
+  end
+end
+
+module M2
+  include M1
+end
+
+class C
+  include M2
+end
+
+C.new.foo
+__END__
+# Classes
+module M1
+  def foo : -> :foo
+end
+
+module M2
+  include M1
+end
+
+class C
+  include M2
+end