typeprof 0.20.0 → 0.20.1

data/smoke/array-pop.rb

@@ -1,12 +0,0 @@
-def foo
-  [1, "str", :sym].pop()
-end
-
-foo
-
-__END__
-# Classes
-class Object
-  private
-  def foo: -> (:sym | Integer | String)
-end

data/smoke/array-range-aref.rb

@@ -1,71 +0,0 @@
-def f1(*ary)
-  ary[1..3]
-end
-
-def f2(*ary)
-  ary[1...3]
-end
-
-def f3(*ary)
-  ary[1..-3]
-end
-
-def f4(*ary)
-  ary[1...-3]
-end
-
-def f5(*ary)
-  ary[-4..3]
-end
-
-def f6(*ary)
-  ary[-4...3]
-end
-
-def f7(*ary)
-  ary[-4..-3]
-end
-
-def f8(*ary)
-  ary[-4...-3]
-end
-
-def f9(*ary)
-  ary[...3]
-end
-
-def f10(*ary)
-  ary[3..]
-end
-
-def dispatch(*ary)
-  f1(*ary)
-  f2(*ary)
-  f3(*ary)
-  f4(*ary)
-  f5(*ary)
-  f6(*ary)
-  f7(*ary)
-  f8(*ary)
-  f9(*ary)
-  f10(*ary)
-end
-
-dispatch(:a, :b, :c, :d, :e)
-
-__END__
-# Classes
-class Object
-  private
-  def f1: (*:a | :b | :c | :d | :e ary) -> (Array[:a | :b | :c | :d | :e])
-  def f2: (*:a | :b | :c | :d | :e ary) -> (Array[:a | :b | :c | :d | :e])
-  def f3: (*:a | :b | :c | :d | :e ary) -> (Array[:a | :b | :c | :d | :e])
-  def f4: (*:a | :b | :c | :d | :e ary) -> (Array[:a | :b | :c | :d | :e])
-  def f5: (*:a | :b | :c | :d | :e ary) -> (Array[:a | :b | :c | :d | :e])
-  def f6: (*:a | :b | :c | :d | :e ary) -> (Array[:a | :b | :c | :d | :e])
-  def f7: (*:a | :b | :c | :d | :e ary) -> (Array[:a | :b | :c | :d | :e])
-  def f8: (*:a | :b | :c | :d | :e ary) -> (Array[:a | :b | :c | :d | :e])
-  def f9: (*:a | :b | :c | :d | :e ary) -> (Array[:a | :b | :c | :d | :e])
-  def f10: (*:a | :b | :c | :d | :e ary) -> (Array[:a | :b | :c | :d | :e])
-  def dispatch: (*:a | :b | :c | :d | :e ary) -> (Array[:a | :b | :c | :d | :e])
-end

data/smoke/array-replace.rb

@@ -1,13 +0,0 @@
-def foo(a)
-  a.replace(["str"])
-  a
-end
-
-foo([1, 2, 3])
-
-__END__
-# Classes
-class Object
-  private
-  def foo: ([Integer, Integer, Integer] a) -> (Array[Integer | String])
-end

data/smoke/array-s-aref.rb

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

data/smoke/array1.rb

@@ -1,27 +0,0 @@
-def foo(a)
-  a[0]
-end
-def bar(n); end
-def baz(n); end
-def qux(n); end
-def quux(n); end
-
-a = [42, "str"]
-foo(a)
-bar(a[0])
-n = 1
-baz(a[n])
-qux(a[2])
-n = 0+0
-quux(a[n])
-
-__END__
-# Classes
-class Object
-  private
-  def foo: ([Integer, String] a) -> Integer
-  def bar: (Integer n) -> nil
-  def baz: (String n) -> nil
-  def qux: (nil n) -> nil
-  def quux: (Integer | String n) -> nil
-end

data/smoke/array10.rb

@@ -1,15 +0,0 @@
-def foo(a)
-  1.times do
-    x, y = a
-    return x
-  end
-end
-
-foo([:a, :b, :c])
-
-__END__
-# Classes
-class Object
-  private
-  def foo: ([:a, :b, :c] a) -> :a
-end

data/smoke/array11.rb

@@ -1,14 +0,0 @@
-def array(obj)
-    Array(obj)
-end
-
-array({1=>1})
-array([1]+[2])
-array("foo")
-
-__END__
-# Classes
-class Object
-  private
-  def array: (Array[Integer] | Hash[Integer, Integer] | String obj) -> (Array[Hash[Integer, Integer] | Integer | String])
-end

data/smoke/array12.rb

@@ -1,25 +0,0 @@
-def bar(x)
-end
-
-def test_yield
-  yield
-end
-
-def foo
-  a = [1]
-  test_yield do
-    bar(a)
-  end
-  a
-end
-
-foo
-
-__END__
-# Classes
-class Object
-  private
-  def bar: ([Integer] x) -> nil
-  def test_yield: { -> nil } -> nil
-  def foo: -> [Integer]
-end

data/smoke/array13.rb

@@ -1,31 +0,0 @@
-def tuple_set
-  ary = [:a, :b, :c]
-  ary[-1] = :z
-  ary
-end
-
-def tuple_get
-  ary = [:a, :b, :c]
-  ary[-1]
-end
-
-def seq_set
-  ary = [:a, :b, :c] + []
-  ary[-1] = :z
-  ary
-end
-
-def seq_get
-  ary = [:a, :b, :c] + []
-  ary[-1]
-end
-
-__END__
-# Classes
-class Object
-  private
-  def tuple_set: -> [:a, :b, :z]
-  def tuple_get: -> :c
-  def seq_set: -> (Array[:a | :b | :c | :z])
-  def seq_get: -> (:a | :b | :c)
-end

data/smoke/array14.rb

@@ -1,14 +0,0 @@
-def f(a, b, c)
-  ary = [nil]
-  foo, bar, ary[0] = a, b, c
-  ary[0]
-end
-
-f(:a, :b, :c)
-
-__END__
-# Classes
-class Object
-  private
-  def f: (:a a, :b b, :c c) -> :c
-end

data/smoke/array15.rb

@@ -1,16 +0,0 @@
-class Foo
-  def []=(*args)
-    ary = []
-    val = args[-1]
-    ary[*args[0..-2]] = val # TODO: there is room to improve array_aset
-    ary                     # This should be Array[String]
-  end
-end
-
-Foo.new[1] = "str"
-
-__END__
-# Classes
-class Foo
-  def []=: (*Integer | String args) -> Array[untyped]
-end

data/smoke/array2.rb

@@ -1,28 +0,0 @@
-def foo
-  a = [[42]]
-  a[0][0] = "str"
-  a
-end
-
-def bar(a)
-  a[0][0] = "str"
-  a
-end
-
-def log(a)
-end
-
-foo
-a = [[42]]
-bar(a)
-# limitation: a is kept as [[Integer]]
-log(a)
-
-__END__
-# Classes
-class Object
-  private
-  def foo: -> [[String]]
-  def bar: ([[Integer]] a) -> [[String]]
-  def log: ([[Integer]] a) -> nil
-end

data/smoke/array3.rb

@@ -1,26 +0,0 @@
-class Foo
-  def initialize
-    @ary = [1, "str", :sym]
-  end
-
-  def foo
-    @ary[1]
-  end
-
-  def bar
-    @ary[1] = nil
-  end
-end
-
-Foo.new.foo
-Foo.new.bar
-
-__END__
-# Classes
-class Foo
-  @ary: [Integer, String?, :sym]
-
-  def initialize: -> void
-  def foo: -> String?
-  def bar: -> nil
-end

data/smoke/array4.rb

@@ -1,15 +0,0 @@
-def foo
-  while 1+1
-    a = [1]
-  end
-  a
-end
-
-foo
-
-__END__
-# Classes
-class Object
-  private
-  def foo: -> [Integer]?
-end

data/smoke/array5.rb

@@ -1,14 +0,0 @@
-def foo
-  a = [[nil]]
-  a[0] = a
-  a
-end
-
-foo
-
-__END__
-# Classes
-class Object
-  private
-  def foo: -> [untyped]
-end

data/smoke/array6.rb

@@ -1,17 +0,0 @@
-ARY = []
-
-def foo(i, v)
-  ARY[i] = v
-  ARY
-end
-
-foo(1, "str")
-
-__END__
-# Classes
-class Object
-  ARY: Array[untyped]
-
-  private
-  def foo: (Integer i, String v) -> Array[untyped]
-end

data/smoke/array7.rb

@@ -1,14 +0,0 @@
-def foo
-  a = [1]
-  a[1] = "str"
-  a
-end
-
-foo
-
-__END__
-# Classes
-class Object
-  private
-  def foo: -> (Array[Integer | String])
-end

data/smoke/array8.rb

@@ -1,13 +0,0 @@
-class Foo
-  def self.foo(a)
-    a
-  end
-
-  foo([])
-end
-
-__END__
-# Classes
-class Foo
-  def self.foo: (Array[untyped] a) -> Array[untyped]
-end

data/smoke/array9.rb

@@ -1,13 +0,0 @@
-def foo(a)
-end
-
-foo([:a, :b, :c])
-foo([:a, :b])
-foo([:a])
-
-__END__
-# Classes
-class Object
-  private
-  def foo: (Array[:a | :b | :c] a) -> nil
-end

data/smoke/attr-module.rb

@@ -1,24 +0,0 @@
-module Foo
-  attr_accessor :foo
-  module_function :foo=, :foo
-end
-
-class Bar
-  include Foo
-end
-
-Foo.foo = 42
-Bar.new.foo = "str"
-
-__END__
-# Classes
-module Foo
-  self.@foo: Integer
-
-  attr_accessor foo: String
-  attr_accessor self.foo: Integer
-end
-
-class Bar
-  include Foo
-end

data/smoke/attr-vis.rb

@@ -1,43 +0,0 @@
-class Foo
-  def initialize
-    @foo = 42
-  end
-
-  private
-  attr_accessor :foo
-
-  public
-  def get_foo
-    foo
-  end
-  def set_foo(arg)
-    self.foo = arg
-  end
-  def get_bar
-    bar
-  end
-  def set_bar(arg)
-    self.bar = arg
-  end
-end
-
-Foo.new.set_foo("str")
-Foo.new.set_bar("str")
-
-__END__
-# Errors
-smoke/attr-vis.rb:20: [warning] inconsistent assignment to RBS-declared variable
-
-# Classes
-class Foo
-  def initialize: -> void
-
-  private
-  attr_accessor foo: Integer | String
-
-  public
-  def get_foo: -> (Integer | String)
-  def set_foo: (String arg) -> String
-  def get_bar: -> Integer
-  def set_bar: (String arg) -> String
-end

data/smoke/attr-vis.rbs

@@ -1,4 +0,0 @@
-class Foo
-  private
-  attr_accessor bar: Integer
-end

data/smoke/attr.rb

@@ -1,28 +0,0 @@
-class Foo
-  def initialize(a)
-    @a = a
-  end
-  attr_reader :a
-
-  attr_writer :b
-  def get_b
-    @b
-  end
-
-  attr_accessor :c
-end
-
-foo = Foo.new(:aaa)
-foo.b = :bbb
-foo.get_b
-foo.c = :ccc
-
-__END__
-# Classes
-class Foo
-  def initialize: (:aaa a) -> void
-  attr_reader a: :aaa
-  attr_writer b: :bbb
-  def get_b: -> :bbb
-  attr_accessor c: :ccc
-end

data/smoke/autoload.rb

@@ -1,14 +0,0 @@
-autoload(:Pathname, "pathname")
-
-def foo
-  Pathname.new("foo")
-end
-
-foo
-
-__END__
-# Classes
-class Object
-  private
-  def foo: -> Pathname
-end

data/smoke/backtrace.rb

@@ -1,33 +0,0 @@
-def foo
-  unknown_method
-end
-
-def bar
-  foo
-end
-
-def baz
-  bar
-end
-
-baz
-
-# smoke/backtrace.rb:2: [error] undefined method: Object#unknown_method
-#         from smoke/backtrace.rb:6
-#         from smoke/backtrace.rb:10
-#         from smoke/backtrace.rb:13
-# Object#baz :: () -> any
-# Object#bar :: () -> any
-# Object#foo :: () -> any
-
-__END__
-# Errors
-smoke/backtrace.rb:2: [error] undefined method: Object#unknown_method
-
-# Classes
-class Object
-  private
-  def foo: -> untyped
-  def bar: -> untyped
-  def baz: -> untyped
-end

data/smoke/block-ambiguous.rb

@@ -1,37 +0,0 @@
-def f1
-  yield :a, :b, :c
-end
-def log1(x); end
-f1 {|x| log1(x) }
-
-def f2
-  yield :a, :b, :c
-end
-def log2(x); end
-f2 {|x,| log2(x) }
-
-def f3
-  yield [:a, :b, :c]
-end
-def log3(x); end
-f3 {|x| log3(x) }
-
-def f4
-  yield [:a, :b, :c]
-end
-def log4(x); end
-f4 {|x,| log4(x) }
-
-__END__
-# Classes
-class Object
-  private
-  def f1: { (:a, :b, :c) -> nil } -> nil
-  def log1: (:a x) -> nil
-  def f2: { (:a, :b, :c) -> nil } -> nil
-  def log2: (:a x) -> nil
-  def f3: { ([:a, :b, :c]) -> nil } -> nil
-  def log3: ([:a, :b, :c] x) -> nil
-  def f4: { ([:a, :b, :c]) -> nil } -> nil
-  def log4: (:a x) -> nil
-end

data/smoke/block-args1-rest.rb

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