typeprof 0.4.2 → 0.5.4

data/lib/typeprof/version.rb

@@ -1,3 +1,3 @@
 module TypeProf
-  VERSION = "0.4.2"
+  VERSION = "0.5.4"
 end

data/smoke/arguments2.rb

@@ -50,6 +50,6 @@ class Object
   def f6 : (k: :kk) -> nil
   def f7 : (?k: Integer) -> nil
   def f8 : (?k: String) -> nil
-  def f9 : (**{:k=>:kk}) -> nil
+  def f9 : (**{k: :kk}) -> nil
   def f10 : { (Integer) -> nil } -> nil
 end

data/smoke/array11.rb

@@ -9,5 +9,5 @@ array("foo")
 __END__
 # Classes
 class Object
-  def array : (Array[Integer] | String | {Integer=>Integer}) -> (Array[Integer | String | {Integer=>Integer}])
+  def array : (Array[Integer] | Hash[Integer, Integer] | String) -> (Array[Hash[Integer, Integer] | Integer | String])
 end

data/smoke/array6.rb

@@ -10,6 +10,6 @@ foo(1, "str")
 __END__
 # Classes
 class Object
-  ARY : []
-  def foo : (Integer, String) -> []
+  ARY : Array[bot]
+  def foo : (Integer, String) -> Array[bot]
 end

data/smoke/array8.rb

@@ -9,5 +9,5 @@ end
 __END__
 # Classes
 class Foo
-  def self.foo : ([]) -> []
+  def self.foo : (Array[bot]) -> Array[bot]
 end

data/smoke/block-args2.rb

@@ -47,11 +47,11 @@ __END__
 # Classes
 class Object
   def f1 : { -> nil } -> ^(nil, *bot, nil) -> nil
-  def log1 : (nil, [], nil) -> nil
+  def log1 : (nil, Array[bot], nil) -> nil
   def f2 : { (:a) -> nil } -> ^(:a, *bot, nil) -> nil
-  def log2 : (:a, [], nil) -> nil
+  def log2 : (:a, Array[bot], nil) -> nil
   def f3 : { (:a, :b) -> nil } -> ^(:a, *bot, :b) -> nil
-  def log3 : (:a, [], :b) -> nil
+  def log3 : (:a, Array[bot], :b) -> nil
   def f4 : { (:a, :b, :c) -> nil } -> ^(:a, *:b, :c) -> nil
   def log4 : (:a, [:b], :c) -> nil
   def f5 : { (:a, :b, :c, :d) -> nil } -> (^(:a, *:b | :c, :d) -> nil)

data/smoke/block-args3.rb

@@ -56,13 +56,13 @@ __END__
 # Classes
 class Object
   def f1 : { -> nil } -> ^(nil, ?:opt, *bot, nil) -> nil
-  def log1 : (nil, :opt, [], nil) -> nil
+  def log1 : (nil, :opt, Array[bot], nil) -> nil
   def f2 : { (:a) -> nil } -> ^(:a, ?:opt, *bot, nil) -> nil
-  def log2 : (:a, :opt, [], nil) -> nil
+  def log2 : (:a, :opt, Array[bot], nil) -> nil
   def f3 : { (:a, :b) -> nil } -> ^(:a, ?:opt, *bot, :b) -> nil
-  def log3 : (:a, :opt, [], :b) -> nil
+  def log3 : (:a, :opt, Array[bot], :b) -> nil
   def f4 : { (:a, :b, :c) -> nil } -> (^(:a, ?:b | :opt, *bot, :c) -> nil)
-  def log4 : (:a, :b | :opt, [], :c) -> nil
+  def log4 : (:a, :b | :opt, Array[bot], :c) -> nil
   def f5 : { (:a, :b, :c, :d) -> nil } -> (^(:a, ?:b | :opt, *:c, :d) -> nil)
   def log5 : (:a, :b | :opt, [:c], :d) -> nil
   def f6 : { (:a, :b, :c, :d, :e) -> nil } -> (^(:a, ?:b | :opt, *:c | :d, :e) -> nil)

data/smoke/block-blockarg.rb

@@ -23,5 +23,5 @@ class Object
   def log1 : (:a) -> nil
   def log2 : (:b) -> nil
   def log3 : (:c) -> nil
-  def f : { { (:a) -> :b } -> :c } -> :d
+  def f : { -> :c } -> :d
 end

data/smoke/block-kwarg.rb

@@ -46,7 +46,7 @@ class Object
   def f3 : { -> nil } -> nil
   def log3 : (Integer | String) -> nil
   def f4 : { -> nil } -> nil
-  def log4 : ({:k=>Integer}) -> nil
+  def log4 : ({k: Integer}) -> nil
   def f5 : { -> nil } -> untyped
   def f6 : { -> nil } -> untyped
 end

data/smoke/block10.rb

@@ -10,5 +10,5 @@ foo([1], ["str"])
 __END__
 # Classes
 class Object
-  def foo : ([Integer], [String]) -> [Integer]
+  def foo : ([Integer], [String]) -> ([Integer | String])
 end

data/smoke/block5.rb

@@ -15,5 +15,5 @@ __END__
 # Classes
 class Object
   F : ^(Integer) -> String
-  def foo : { (:sym) { (Integer) -> String } -> String } -> String
+  def foo : { (:sym) -> String } -> String
 end

data/smoke/constant2.rb

@@ -24,12 +24,11 @@ smoke/constant2.rb:15: [warning] already initialized constant Object::BAR
 
 # Classes
 class Object
-  C : String
   BAR : String
   def foo : (Integer | untyped) -> nil
   def log : (String) -> nil
 end
 
-class C(dummy)
+class C
   def foo : -> nil
 end

data/smoke/demo5.rb

@@ -9,7 +9,7 @@ B.foo(Integer)
 __END__
 # Classes
 class A
-  def self.foo : (Integer | Integer.class) -> String
+  def self.foo : (Integer | singleton(Integer)) -> String
 end
 
 class B < A

data/smoke/demo9.rb

@@ -12,5 +12,5 @@ __END__
 # Classes
 class Object
   F : ^(Integer) -> String
-  def foo : { (:sym) { (Integer) -> String } -> String } -> String
+  def foo : { (:sym) -> String } -> String
 end

data/smoke/hash-fetch.rb

@@ -21,7 +21,7 @@ baz(h)
 __END__
 # Classes
 class Object
-  def foo : ({:a=>:A, :b=>:B}) -> (:A | :B)
-  def bar : ({:a=>:A, :b=>:B}) -> (:A | :B | :C)
-  def baz : ({:a=>:A, :b=>:B}) -> ([:A | :B | :C, (:a | :b)?])
+  def foo : ({a: :A, b: :B}) -> (:A | :B)
+  def bar : ({a: :A, b: :B}) -> (:A | :B | :C)
+  def baz : ({a: :A, b: :B}) -> ([:A | :B | :C, (:a | :b)?])
 end

data/smoke/hash-merge-bang.rb

@@ -0,0 +1,11 @@
+def foo
+  h = { a: 42 }
+  h0 = h.merge!({ b: "str" })
+  return h0, h
+end
+
+__END__
+# Classes
+class Object
+  def foo : -> [{a: Integer}, {a: Integer, b: String}]
+end

data/smoke/hash1.rb

@@ -5,6 +5,7 @@ end
 foo
 
 def bar
+  # This returns {Integer=>Integer | String, String=>String} but RBS cannot express it
   { 1 => 1, 2 => "str", "s" => "s" }
 end
 
@@ -13,6 +14,6 @@ bar
 __END__
 # Classes
 class Object
-  def foo : -> {:int=>Integer, :str=>String}
-  def bar : -> ({Integer=>Integer | String, String=>String})
+  def foo : -> {int: Integer, str: String}
+  def bar : -> (Hash[Integer | String, Integer | String])
 end

data/smoke/hash3.rb

@@ -9,5 +9,5 @@ foo
 __END__
 # Classes
 class Object
-  def foo : -> {:int=>Integer, :str=>String}
+  def foo : -> {int: Integer, str: String}
 end

data/smoke/inheritance2.rb

@@ -21,11 +21,11 @@ end
 __END__
 # Classes
 class SuperBase
-  def self.foo : -> (A.class | B.class)
+  def self.foo : -> (singleton(A) | singleton(B))
 end
 
 class Base < SuperBase
-  def self.foo : -> (A.class | B.class)
+  def self.foo : -> (singleton(A) | singleton(B))
 end
 
 class A < Base

data/smoke/ivar2.rb

@@ -24,7 +24,7 @@ __END__
 # Classes
 class Foo
   attr_reader array : Array[:sym | Integer | String]
-  attr_reader hash : {:a=>Integer, :b=>String, :c=>:sym}
-  def initialize : -> {}
+  attr_reader hash : {a: Integer, b: String, c: :sym}
+  def initialize : -> Hash[bot, bot]
   def set : -> :sym
 end

data/smoke/kernel-class.rb

@@ -8,5 +8,5 @@ foo("")
 __END__
 # Classes
 class Object
-  def foo : (Integer | String) -> (Integer.class | String.class)
+  def foo : (Integer | String) -> (singleton(Integer) | singleton(String))
 end

data/smoke/keyword4.rb

@@ -7,5 +7,5 @@ foo(n: 42, s: "str")
 __END__
 # Classes
 class Object
-  def foo : (**{:n=>Integer, :s=>String}) -> {:n=>Integer, :s=>String}
+  def foo : (**{n: Integer, s: String}) -> {n: Integer, s: String}
 end

data/smoke/kwsplat1.rb

@@ -37,6 +37,6 @@ smoke/kwsplat1.rb:30: [error] undefined method: Object#any
 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
+  def baz : (**{int: Integer, str: String}) -> nil
+  def qux : (**Hash[untyped, untyped]) -> nil
 end

data/smoke/kwsplat2.rb

@@ -8,5 +8,5 @@ foo(*a, **h)
 __END__
 # Classes
 class Object
-  def foo : (*Integer | {:k=>Integer}, k: Integer) -> nil
+  def foo : (*Integer | {k: Integer}, k: Integer) -> nil
 end

data/smoke/multiple-superclass.rb

@@ -15,7 +15,7 @@ smoke/multiple-superclass.rb:9: [warning] superclass is not a class; Object is u
 
 # Classes
 class Object
-  Base : A.class | B.class
+  Base : singleton(A) | singleton(B)
 end
 
 class A

data/smoke/parameterizedd-self.rb

@@ -13,6 +13,6 @@ bar([])
 __END__
 # Classes
 class Object
-  def foo : -> []
-  def bar : ([]) -> []
+  def foo : -> Array[bot]
+  def bar : (Array[bot]) -> Array[bot]
 end

data/smoke/pattern-match1.rb

@@ -0,0 +1,23 @@
+# RUBY_VERSION >= 3.0
+
+def foo
+  case [:a, :b, :c]
+  in [a, b, :c]
+    # Due to very subtle detail of bytecode, the variables "a" and "b" could be nil
+    return a, b
+  end
+end
+
+foo
+
+__END__
+# Errors
+smoke/pattern-match1.rb:5: [error] undefined method: nil#length
+smoke/pattern-match1.rb:5: [error] undefined method: nil#[]
+smoke/pattern-match1.rb:5: [error] undefined method: nil#[]
+smoke/pattern-match1.rb:5: [error] undefined method: nil#[]
+
+# Classes
+class Object
+  def foo : -> ([:a | untyped, :b | untyped])
+end

data/smoke/pattern-match2.rb

@@ -0,0 +1,15 @@
+# RUBY_VERSION >= 3.0
+
+def foo
+  case { a: :A, b: :B, c: :C }
+  in { a:, b: bb, c: :C }
+    return a, bb
+  end
+end
+
+foo
+__END__
+# Classes
+class Object
+  def foo : -> [:A, :B]
+end

data/smoke/rbs-tyvar3.rb

@@ -1,25 +1,17 @@
-class StringFoo
-  def initialize
-    @foo = Foo.new
-  end
-
-  def set
-    @foo.set("42")
-  end
-
-  def get
-    @foo.get
-  end
+def foo
+  cell = Cell.new(42)
+  cell.map {|s| (s + 1).to_s }
 end
 
-StringFoo.new.set
-StringFoo.new.get
+def bar
+  cell = Cell.new(42)
+  cell.map! {|s| (s + 1).to_s }
+  cell
+end
 
 __END__
 # Classes
-class StringFoo
-  @foo : Foo[String] | Foo[bot]
-  def initialize : -> Foo[bot]
-  def set : -> void
-  def get : -> String
+class Object
+  def foo : -> Cell[String]
+  def bar : -> (Cell[Integer | String])
 end

data/smoke/rbs-tyvar3.rbs

@@ -1,4 +1,5 @@
-class Foo[X]
-  def set: (X) -> void
-  def get: -> X
+class Cell[T]
+  def initialize : (T) -> void
+  def map: [A] { (T) -> A } -> Cell[A]
+  def map!: { (T) -> T } -> self
 end

data/smoke/rbs-tyvar4.rb

@@ -0,0 +1,36 @@
+# This code is created by simplifying matrix.rb.
+# The issue occurs when `Array.new` creates a cell-type container,
+# so this test will be obsolete, but keep it just for case of regression.
+#
+# https://github.com/ruby/typeprof/issues/14
+
+class Foo
+  def initialize(ivar)
+    @ivar = ivar
+  end
+
+  def foo(n)
+    @ivar.each_with_index { }
+    nil
+  end
+end
+
+Foo.new([])
+
+rows = Array.new(1) do |i|
+  Array.new(1) do |j|
+    "str"
+  end
+end
+obj = Foo.new(rows)
+
+obj.foo(:a)
+obj.foo(:b)
+
+__END__
+# Classes
+class Foo
+  @ivar : Array[Array[String]]
+  def initialize : (Array[Array[String]]) -> Array[Array[String]]
+  def foo : (:a | :b) -> nil
+end

data/smoke/rbs-tyvar5.rb

@@ -0,0 +1,12 @@
+def foo
+  cell = Cell.new
+  cell.set { Foo.new(:a, :b) }
+  cell.dummy { }
+  cell
+end
+
+__END__
+# Classes
+class Object
+  def foo : -> Cell[Foo[:a, :b]]
+end

data/smoke/rbs-tyvar5.rbs

@@ -0,0 +1,8 @@
+class Cell[X]
+  def set: { -> X } -> self
+  def dummy: { -> void } -> self
+end
+
+class Foo[X, Y]
+  def initialize: (X, Y) -> void
+end

data/smoke/struct.rb

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

data/smoke/uninitialize-var.rb

@@ -0,0 +1,12 @@
+def foo
+  x = begin
+    return x
+    1
+  end
+end
+
+__END__
+# Classes
+class Object
+  def foo : -> nil
+end