typeprof 0.20.0 → 0.20.1

data/smoke/define_method5.rb

@@ -1,12 +0,0 @@
-class Foo
-  foo = 42
-  f = proc { foo }
-
-  define_method(:foo, &f)
-end
-
-__END__
-# Classes
-class Foo
-  def foo: -> Integer
-end

data/smoke/define_method6.rb

@@ -1,19 +0,0 @@
-class A
-  %i[a b].each.with_index { |sym, i| define_method(sym) { i } }
-end
-
-def foo
-  A.new.a + A.new.b
-end
-
-__END__
-# Classes
-class Object
-  private
-  def foo: -> Integer
-end
-
-class A
-  def a: -> Integer
-  def b: -> Integer
-end

data/smoke/define_method7.rb

@@ -1,18 +0,0 @@
-class Human
-  define_method(:fo) { }
-  
-  [:a, :b].each { |m|
-    define_method(m) { }
-  }
-end
-
-Human.new.a
-Human.new.b
-
-__END__
-# Classes
-class Human
-  def fo: -> nil
-  def a: -> nil
-  def b: -> nil
-end

data/smoke/demo.rb

@@ -1,81 +0,0 @@
-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
-  private
-  def foo: (bool x) -> (Integer | String)
-  def identity: (:sym | Integer | String x) -> (:sym | Integer | String)
-  def fib: (Integer x) -> Integer
-end
-
-class A
-  def foo: (Integer | String x) -> nil
-  def bar: (Integer | String x) -> nil
-end
-
-class B < A
-  def bar: (Integer | String x) -> nil
-end

data/smoke/demo1.rb

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

data/smoke/demo10.rb

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

data/smoke/demo11.rb

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

data/smoke/demo2.rb

@@ -1,15 +0,0 @@
-# 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
-  private
-  def my_to_s: (:sym | Integer | String x) -> String
-end

data/smoke/demo3.rb

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

data/smoke/demo4.rb

@@ -1,27 +0,0 @@
-# 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 x) -> nil
-  def bar: (Integer | String x) -> nil
-end
-
-class B < A
-  def bar: (Integer | String x) -> nil
-end

data/smoke/demo5.rb

@@ -1,16 +0,0 @@
-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 | singleton(Integer) x) -> String
-end
-
-class B < A
-end

data/smoke/demo6.rb

@@ -1,22 +0,0 @@
-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 x) -> (Integer | String)
-  def foo: -> (Integer | String)
-end

data/smoke/demo7.rb

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

data/smoke/demo8.rb

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

data/smoke/demo9.rb

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

data/smoke/dummy-execution1.rb

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

data/smoke/dummy-execution2.rb

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

data/smoke/dummy_element.rb

@@ -1,14 +0,0 @@
-# I'm unsure how, but this code calls ContainerType::Elements.dummy_elements
-# I should investigate the mechanism, but anyway I record this code
-
-class Foo
-  define_method(:f) {|**h| }
-end
-
-Foo.new.f
-
-__END__
-# Classes
-class Foo
-  def f: (**untyped) -> nil
-end

data/smoke/ensure1.rb

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

data/smoke/enum_for.rb

@@ -1,15 +0,0 @@
-def log
-  nn = nil
-  ary = [1, "str"].to_enum.map do |n|
-    nn = n
-    n.to_s
-  end
-  return nn, ary
-end
-
-__END__
-# Classes
-class Object
-  private
-  def log: -> ([(Integer | String)?, Array[String]])
-end

data/smoke/enum_for2.rb

@@ -1,17 +0,0 @@
-class Foo
-  def int_and_str_enum
-    return enum_for(__method__) unless block_given?
-
-    yield 1
-    yield 2
-    yield 3
-
-    1.0
-  end
-end
-
-__END__
-# Classes
-class Foo
-  def int_and_str_enum: ?{ (Integer) -> untyped } -> (Enumerator[Integer, untyped] | Float)
-end

data/smoke/enumerator.rb

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

data/smoke/expandarray1.rb

@@ -1,23 +0,0 @@
-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
-  private
-  def foo: -> ([:a, [:b, :c]] | untyped)
-end

data/smoke/expandarray2.rb

@@ -1,24 +0,0 @@
-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
-  private
-  def foo: -> ([:a, [:b, :c]] | untyped)
-end

data/smoke/extended.rb

@@ -1,38 +0,0 @@
-module Foo
-  @extended = []
-  def self.extended(klass)
-    @extended << klass
-  end
-end
-
-class C
-  extend Foo
-end
-
-class D
-  extend Foo
-end
-
-class E
-  extend Foo
-end
-
-__END__
-# Classes
-module Foo
-  self.@extended: Array[singleton(C) | singleton(D) | singleton(E)]
-
-  def self.extended: (singleton(C) | singleton(D) | singleton(E) klass) -> (Array[singleton(C) | singleton(D) | singleton(E)])
-end
-
-class C
-  extend Foo
-end
-
-class D
-  extend Foo
-end
-
-class E
-  extend Foo
-end

data/smoke/fib.rb

@@ -1,28 +0,0 @@
-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 x) -> Integer
-  def fib_rec: (Integer x) -> Integer
-end

data/smoke/flip-flop.rb

@@ -1,28 +0,0 @@
-def cond1?
-  rand < 0.5
-end
-
-def cond2?
-  rand < 0.5
-end
-
-def foo
-  while true
-    if cond1? .. cond2?
-      return 42
-    end
-    if cond1? .. cond2?
-      return "str"
-    end
-  end
-  return
-end
-
-__END__
-# Classes
-class Object
-  private
-  def cond1?: -> bool
-  def cond2?: -> bool
-  def foo: -> (Integer | String)
-end

data/smoke/flow1.rb

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

data/smoke/flow10.rb

@@ -1,17 +0,0 @@
-def foo
-  if block_given?
-    yield 42
-  else
-    1.0
-  end
-end
-
-foo
-foo {|n| n.to_s }
-
-__END__
-# Classes
-class Object
-  private
-  def foo: ?{ (Integer) -> String } -> (Float | String)
-end

data/smoke/flow11.rb

@@ -1,17 +0,0 @@
-def foo(arg)
-  if Integer === arg
-    arg
-  else
-    42
-  end
-end
-
-foo("str")
-foo(1)
-
-__END__
-# Classes
-class Object
-  private
-  def foo: (Integer | String arg) -> Integer
-end

data/smoke/flow2.rb

@@ -1,15 +0,0 @@
-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
-  private
-  def foo: (untyped x) -> Integer
-end