typeprof 0.20.0 → 0.20.1

data/smoke/block-args1.rb

@@ -1,60 +0,0 @@
-def f1(&blk)
-  yield
-  blk
-end
-def log1(a, o, c); end
-f1 do |a, o=:opt, c|
-  log1(a, o, c)
-end
-
-def f2(&blk)
-  yield :a
-  blk
-end
-def log2(a, o, c); end
-f2 do |a, o=:opt, c|
-  log2(a, o, c)
-end
-
-def f3(&blk)
-  yield :a, :b
-  blk
-end
-def log3(a, o, c); end
-f3 do |a, o=:opt, c|
-  log3(a, o, c)
-end
-
-def f4(&blk)
-  yield :a, :b, :c
-  blk
-end
-def log4(a, o, c); end
-f4 do |a, o=:opt, c|
-  log4(a, o, c)
-end
-
-def f5(&blk)
-  yield :a, :b, :c, :d
-  blk
-end
-def log5(a, o, c); end
-f5 do |a, o=:opt, c|
-  log5(a, o, c)
-end
-
-__END__
-# Classes
-class Object
-  private
-  def f1: { -> nil } -> ^(nil, ?:opt, nil) -> nil
-  def log1: (nil a, :opt o, nil c) -> nil
-  def f2: { (:a) -> nil } -> ^(:a, ?:opt, nil) -> nil
-  def log2: (:a a, :opt o, nil c) -> nil
-  def f3: { (:a, :b) -> nil } -> ^(:a, ?:opt, :b) -> nil
-  def log3: (:a a, :opt o, :b c) -> nil
-  def f4: { (:a, :b, :c) -> nil } -> (^(:a, ?:b | :opt, :c) -> nil)
-  def log4: (:a a, :b | :opt o, :c c) -> nil
-  def f5: { (:a, :b, :c, :d) -> nil } -> (^(:a, ?:b | :opt, :c) -> nil)
-  def log5: (:a a, :b | :opt o, :c c) -> nil
-end

data/smoke/block-args2-rest.rb

@@ -1,64 +0,0 @@
-StringArray = ["str"] + ["str"]
-
-def f1(&blk)
-  yield *StringArray
-  blk
-end
-def log1(a, r, c); end
-f1 do |a, *r, c|
-  log1(a, r, c)
-end
-
-def f2(&blk)
-  yield :a, *StringArray
-  blk
-end
-def log2(a, r, c); end
-f2 do |a, *r, c|
-  log2(a, r, c)
-end
-
-def f3(&blk)
-  yield :a, :b, *StringArray
-  blk
-end
-def log3(a, r, c); end
-f3 do |a, *r, c|
-  log3(a, r, c)
-end
-
-def f4(&blk)
-  yield :a, :b, :c, *StringArray
-  blk
-end
-def log4(a, r, c); end
-f4 do |a, *r, c|
-  log4(a, r, c)
-end
-
-def f5(&blk)
-  yield :a, :b, :c, :d, *StringArray
-  blk
-end
-def log5(a, r, c); end
-f5 do |a, *r, c|
-  log5(a, r, c)
-end
-
-__END__
-# Classes
-class Object
-  StringArray: Array[String]
-
-  private
-  def f1: { (*String) -> nil } -> ^(String, *String, String) -> nil
-  def log1: (String a, Array[String] r, String c) -> nil
-  def f2: { (:a, *String) -> nil } -> ^(:a, *String, String) -> nil
-  def log2: (:a a, Array[String] r, String c) -> nil
-  def f3: { (:a, :b, *String) -> nil } -> (^(:a, *:b | String, :b | String) -> nil)
-  def log3: (:a a, Array[:b | String] r, :b | String c) -> nil
-  def f4: { (:a, :b, :c, *String) -> nil } -> (^(:a, *:b | :c | String, :c | String) -> nil)
-  def log4: (:a a, Array[:b | :c | String] r, :c | String c) -> nil
-  def f5: { (:a, :b, :c, :d, *String) -> nil } -> (^(:a, *:b | :c | :d | String, :d | String) -> nil)
-  def log5: (:a a, Array[:b | :c | :d | String] r, :d | String c) -> nil
-end

data/smoke/block-args2.rb

@@ -1,60 +0,0 @@
-def f1(&blk)
-  yield
-  blk
-end
-def log1(a, r, c); end
-f1 do |a, *r, c|
-  log1(a, r, c)
-end
-
-def f2(&blk)
-  yield :a
-  blk
-end
-def log2(a, r, c); end
-f2 do |a, *r, c|
-  log2(a, r, c)
-end
-
-def f3(&blk)
-  yield :a, :b
-  blk
-end
-def log3(a, r, c); end
-f3 do |a, *r, c|
-  log3(a, r, c)
-end
-
-def f4(&blk)
-  yield :a, :b, :c
-  blk
-end
-def log4(a, r, c); end
-f4 do |a, *r, c|
-  log4(a, r, c)
-end
-
-def f5(&blk)
-  yield :a, :b, :c, :d
-  blk
-end
-def log5(a, r, c); end
-f5 do |a, *r, c|
-  log5(a, r, c)
-end
-
-__END__
-# Classes
-class Object
-  private
-  def f1: { -> nil } -> ^(nil, *bot, nil) -> nil
-  def log1: (nil a, Array[untyped] r, nil c) -> nil
-  def f2: { (:a) -> nil } -> ^(:a, *bot, nil) -> nil
-  def log2: (:a a, Array[untyped] r, nil c) -> nil
-  def f3: { (:a, :b) -> nil } -> ^(:a, *bot, :b) -> nil
-  def log3: (:a a, Array[untyped] r, :b c) -> nil
-  def f4: { (:a, :b, :c) -> nil } -> ^(:a, *:b, :c) -> nil
-  def log4: (:a a, [:b] r, :c c) -> nil
-  def f5: { (:a, :b, :c, :d) -> nil } -> (^(:a, *:b | :c, :d) -> nil)
-  def log5: (:a a, [:b, :c] r, :d c) -> nil
-end

data/smoke/block-args3-rest.rb

@@ -1,75 +0,0 @@
-StringArray = ["str"] + ["str"]
-
-def f1(&blk)
-  yield *StringArray
-  blk
-end
-def log1(a, o, r, c); end
-f1 do |a, o=:opt, *r, c|
-  log1(a, o, r, c)
-end
-
-def f2(&blk)
-  yield :a, *StringArray
-  blk
-end
-def log2(a, o, r, c); end
-f2 do |a, o=:opt, *r, c|
-  log2(a, o, r, c)
-end
-
-def f3(&blk)
-  yield :a, :b, *StringArray
-  blk
-end
-def log3(a, o, r, c); end
-f3 do |a, o=:opt, *r, c|
-  log3(a, o, r, c)
-end
-
-def f4(&blk)
-  yield :a, :b, :c, *StringArray
-  blk
-end
-def log4(a, o, r, c); end
-f4 do |a, o=:opt, *r, c|
-  log4(a, o, r, c)
-end
-
-def f5(&blk)
-  yield :a, :b, :c, :d, *StringArray
-  blk
-end
-def log5(a, o, r, c); end
-f5 do |a, o=:opt, *r, c|
-  log5(a, o, r, c)
-end
-
-def f6(&blk)
-  yield :a, :b, :c, :d, :e, *StringArray
-  blk
-end
-def log6(a, o, r, c); end
-f6 do |a, o=:opt, *r, c|
-  log6(a, o, r, c)
-end
-
-__END__
-# Classes
-class Object
-  StringArray: Array[String]
-
-  private
-  def f1: { (*String) -> nil } -> (^(String, ?:opt | String, *String, String) -> nil)
-  def log1: (String a, :opt | String o, Array[String] r, String c) -> nil
-  def f2: { (:a, *String) -> nil } -> (^(:a, ?:opt | String, *String, String) -> nil)
-  def log2: (:a a, :opt | String o, Array[String] r, String c) -> nil
-  def f3: { (:a, :b, *String) -> nil } -> (^(:a, ?:b | :opt, *String, :b | String) -> nil)
-  def log3: (:a a, :b | :opt o, Array[String] r, :b | String c) -> nil
-  def f4: { (:a, :b, :c, *String) -> nil } -> (^(:a, ?:b | :opt, *:c | String, :c | String) -> nil)
-  def log4: (:a a, :b | :opt o, Array[:c | String] r, :c | String c) -> nil
-  def f5: { (:a, :b, :c, :d, *String) -> nil } -> (^(:a, ?:b | :opt, *:c | :d | String, :d | String) -> nil)
-  def log5: (:a a, :b | :opt o, Array[:c | :d | String] r, :d | String c) -> nil
-  def f6: { (:a, :b, :c, :d, :e, *String) -> nil } -> (^(:a, ?:b | :opt, *:c | :d | :e | String, :e | String) -> nil)
-  def log6: (:a a, :b | :opt o, Array[:c | :d | :e | String] r, :e | String c) -> nil
-end

data/smoke/block-args3.rb

@@ -1,71 +0,0 @@
-def f1(&blk)
-  yield
-  blk
-end
-def log1(a, o, r, c); end
-f1 do |a, o=:opt, *r, c|
-  log1(a, o, r, c)
-end
-
-def f2(&blk)
-  yield :a
-  blk
-end
-def log2(a, o, r, c); end
-f2 do |a, o=:opt, *r, c|
-  log2(a, o, r, c)
-end
-
-def f3(&blk)
-  yield :a, :b
-  blk
-end
-def log3(a, o, r, c); end
-f3 do |a, o=:opt, *r, c|
-  log3(a, o, r, c)
-end
-
-def f4(&blk)
-  yield :a, :b, :c
-  blk
-end
-def log4(a, o, r, c); end
-f4 do |a, o=:opt, *r, c|
-  log4(a, o, r, c)
-end
-
-def f5(&blk)
-  yield :a, :b, :c, :d
-  blk
-end
-def log5(a, o, r, c); end
-f5 do |a, o=:opt, *r, c|
-  log5(a, o, r, c)
-end
-
-def f6(&blk)
-  yield :a, :b, :c, :d, :e
-  blk
-end
-def log6(a, o, r, c); end
-f6 do |a, o=:opt, *r, c|
-  log6(a, o, r, c)
-end
-
-__END__
-# Classes
-class Object
-  private
-  def f1: { -> nil } -> ^(nil, ?:opt, *bot, nil) -> nil
-  def log1: (nil a, :opt o, Array[untyped] r, nil c) -> nil
-  def f2: { (:a) -> nil } -> ^(:a, ?:opt, *bot, nil) -> nil
-  def log2: (:a a, :opt o, Array[untyped] r, nil c) -> nil
-  def f3: { (:a, :b) -> nil } -> ^(:a, ?:opt, *bot, :b) -> nil
-  def log3: (:a a, :opt o, Array[untyped] r, :b c) -> nil
-  def f4: { (:a, :b, :c) -> nil } -> (^(:a, ?:b | :opt, *bot, :c) -> nil)
-  def log4: (:a a, :b | :opt o, Array[untyped] r, :c c) -> nil
-  def f5: { (:a, :b, :c, :d) -> nil } -> (^(:a, ?:b | :opt, *:c, :d) -> nil)
-  def log5: (:a a, :b | :opt o, [:c] r, :d c) -> nil
-  def f6: { (:a, :b, :c, :d, :e) -> nil } -> (^(:a, ?:b | :opt, *:c | :d, :e) -> nil)
-  def log6: (:a a, :b | :opt o, [:c, :d] r, :e c) -> nil
-end

data/smoke/block-blockarg.rb

@@ -1,28 +0,0 @@
-def log1(x); end
-def log2(x); end
-def log3(x); end
-
-def f(&blk)
-  log3(
-    blk.call do |x|
-      log1(x)
-      :b
-    end
-  )
-  :d
-end
-
-f do |&blk|
-  log2(blk.call(:a))
-  :c
-end
-
-__END__
-# Classes
-class Object
-  private
-  def log1: (:a x) -> nil
-  def log2: (:b x) -> nil
-  def log3: (:c x) -> nil
-  def f: { -> :c } -> :d
-end

data/smoke/block-kwarg.rb

@@ -1,53 +0,0 @@
-def f1
-  yield k: 1
-end
-def log1(n); end
-f1 {|k:| log1(k) }
-
-def f2
-  yield k: 1
-end
-def log2(n); end
-f2 {|k: :opt| log2(k) }
-
-def f3
-  yield k: 1
-end
-def log3(n); end
-f3 {|k: "str"| log3(k) }
-
-def f4
-  yield k: 1
-end
-def log4(kwrest); end
-f4 {|**kwrest| log4(kwrest) }
-
-def f5
-  yield k: 1
-end
-f5 {|| }
-
-def f6
-  yield
-end
-f6 {|k:| }
-
-__END__
-# Errors
-smoke/block-kwarg.rb:26: [error] unknown keyword: k
-smoke/block-kwarg.rb:31: [error] no argument for required keywords
-
-# Classes
-class Object
-  private
-  def f1: { -> nil } -> nil
-  def log1: (Integer n) -> nil
-  def f2: { -> nil } -> nil
-  def log2: (:opt | Integer n) -> nil
-  def f3: { -> nil } -> nil
-  def log3: (Integer | String n) -> nil
-  def f4: { -> nil } -> nil
-  def log4: ({k: Integer} kwrest) -> nil
-  def f5: { -> nil } -> untyped
-  def f6: { -> nil } -> untyped
-end

data/smoke/block1.rb

@@ -1,23 +0,0 @@
-def foo(x)
-  yield x
-  yield 1
-end
-
-foo("str") do |x|
-  x
-end
-
-foo(:sym) do |x|
-  if 1+1
-    x
-  else
-    1
-  end
-end
-
-__END__
-# Classes
-class Object
-  private
-  def foo: (:sym | String x) { (:sym | Integer | String) -> (:sym | Integer | String) } -> (:sym | Integer | String)
-end

data/smoke/block10.rb

@@ -1,15 +0,0 @@
-def foo(ary1, ary2)
-  ary1.each do |x|
-    ary2[0] = x
-  end
-  ary2
-end
-
-foo([1], ["str"])
-
-__END__
-# Classes
-class Object
-  private
-  def foo: ([Integer] ary1, [String] ary2) -> ([Integer | String])
-end

data/smoke/block11.rb

@@ -1,40 +0,0 @@
-def log1(x)
-end
-def log2(x)
-end
-
-def foo
-  x = nil
-  1.times do |_|
-    x = 1
-    log1(x)
-  end
-  x
-end
-
-def test_yield
-  yield
-end
-
-def bar
-  x = nil
-  test_yield do
-    x = 1
-    log2(x)
-  end
-  x
-end
-
-foo
-bar
-
-__END__
-# Classes
-class Object
-  private
-  def log1: (Integer? x) -> nil
-  def log2: (Integer? x) -> nil
-  def foo: -> Integer?
-  def test_yield: { -> nil } -> nil
-  def bar: -> Integer?
-end

data/smoke/block12.rb

@@ -1,23 +0,0 @@
-def foo
-  1.times do |_|
-    return [:foo]
-  end
-end
-
-def bar
-  a = [:bar]
-  1.times do |_|
-    return a
-  end
-end
-
-foo
-bar
-
-__END__
-# Classes
-class Object
-  private
-  def foo: -> [:foo]
-  def bar: -> [:bar]
-end

data/smoke/block13.rb

@@ -1,9 +0,0 @@
-foo do |n|
-  p n
-end
-
-__END__
-# Revealed types
-#  smoke/block13.rb:2 #=> Integer?
-
-# Classes

data/smoke/block13.rbs

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

data/smoke/block14.rb

@@ -1,18 +0,0 @@
-def foo(&blk)
-  $blk = blk
-  nil
-end
-
-foo {|n| }
-
-$blk.call(42)
-
-__END__
-# Global variables
-$blk: ^(Integer) -> nil
-
-# Classes
-class Object
-  private
-  def foo: { (Integer) -> nil } -> nil
-end

data/smoke/block2.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/block3.rb

@@ -1,38 +0,0 @@
-class Common
-  def func(x)
-    yield 1
-  end
-end
-
-class Foo
-  def foo
-    Common.new.func("str") do |x|
-      1
-    end
-  end
-end
-
-class Bar
-  def bar
-    Common.new.func(:sym) do |x|
-      :sym2
-    end
-  end
-end
-
-Foo.new.foo
-Bar.new.bar
-
-__END__
-# Classes
-class Common
-  def func: (:sym | String x) { (Integer) -> (:sym2 | Integer) } -> (:sym2 | Integer)
-end
-
-class Foo
-  def foo: -> (:sym2 | Integer)
-end
-
-class Bar
-  def bar: -> (:sym2 | Integer)
-end

data/smoke/block4.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/block5.rb

@@ -1,21 +0,0 @@
-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
-  F: ^(Integer) -> String
-
-  private
-  def foo: { (:sym) -> String } -> String
-end

data/smoke/block6.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/block7.rb

@@ -1,19 +0,0 @@
-def foo
-  yield
-end
-
-any = undefined_method
-foo(&any)
-
-foo(&1)
-
-__END__
-# Errors
-smoke/block7.rb:5: [error] undefined method: Object#undefined_method
-smoke/block7.rb:8: [error] wrong argument type Integer<1> (expected Proc)
-
-# Classes
-class Object
-  private
-  def foo: -> untyped
-end