typeprof 0.5.0 → 0.6.0

data/lib/typeprof/version.rb

@@ -1,3 +1,3 @@
 module TypeProf
-  VERSION = "0.5.0"
+  VERSION = "0.6.0"
 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/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-merge-bang.rb

@@ -7,5 +7,5 @@ end
 __END__
 # Classes
 class Object
-  def foo : -> ([{b: Integer | String, a: Integer | String}, {a: Integer}])
+  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
 
@@ -14,5 +15,5 @@ __END__
 # Classes
 class Object
   def foo : -> {int: Integer, str: String}
-  def bar : -> ({Integer=>Integer | String, String=>String})
+  def bar : -> (Hash[Integer | String, Integer | String])
 end

data/smoke/hash4.rb

@@ -6,5 +6,5 @@ foo
 __END__
 # Classes
 class Object
-  def foo : -> {}
+  def foo : -> Hash[bot, bot]
 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

@@ -25,6 +25,6 @@ __END__
 class Foo
   attr_reader array : Array[:sym | Integer | String]
   attr_reader hash : {a: Integer, b: String, c: :sym}
-  def initialize : -> {}
+  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/kwsplat1.rb

@@ -38,5 +38,5 @@ 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 qux : (**Hash[untyped, untyped]) -> 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/parameterizedd-self2.rb

@@ -0,0 +1,15 @@
+class Object
+  def foo
+    # The receiver is considered as an empty array
+    self[0]
+  end
+end
+
+# The elements are dropped when it is passed as a receiver (to avoid state explosion)
+[0].foo
+
+__END__
+# Classes
+class Object
+  def foo : -> nil
+end

data/smoke/rbs-tyvar6.rb

@@ -0,0 +1,17 @@
+def log1(obj) end
+def log2(obj) end
+def log3(obj) end
+
+obj = Bar.new("str")
+
+log1(obj)
+log2(obj.test_superclass)
+log3(obj.test_module)
+
+__END__
+# Classes
+class Object
+  def log1 : (Bar[String]) -> nil
+  def log2 : (Array[String]) -> nil
+  def log3 : (Integer) -> nil
+end

data/smoke/rbs-tyvar6.rbs

@@ -0,0 +1,12 @@
+class Foo[X]
+  def test_superclass: -> X
+end
+
+module M[X]
+  def test_module: -> X
+end
+
+class Bar[X] < Foo[Array[X]]
+  def initialize: (X) -> void
+  include M[Integer]
+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/super4.rb

@@ -0,0 +1,43 @@
+module M1
+  def f(m); super :M1; end
+end
+module M2
+  def f(m); super :M2; end
+end
+class C
+  def f(m); end
+end
+class D < C
+  def f(m); super :D; end
+  include M1
+end
+class E < D
+  def f(m); super :E; end
+  include M2
+end
+
+E.new.f(:top)
+
+__END__
+# Classes
+module M1
+  def f : (:D) -> nil
+end
+
+module M2
+  def f : (:E) -> nil
+end
+
+class C
+  def f : (:M1) -> nil
+end
+
+class D < C
+  include M1
+  def f : (:M2) -> nil
+end
+
+class E < D
+  include M2
+  def f : (:top) -> nil
+end

data/smoke/super5.rb

@@ -0,0 +1,36 @@
+module M
+  def f(m); super :M; end
+end
+class C
+  def f(m); end
+end
+class D < C
+  def f(m); super :D; end
+  include M
+end
+class E < D
+  def f(m); super :E; end
+  include M
+end
+
+E.new.f(:top)
+
+__END__
+# Classes
+module M
+  def f : (:D | :E) -> nil
+end
+
+class C
+  def f : (:M) -> nil
+end
+
+class D < C
+  include M
+  def f : (:M) -> nil
+end
+
+class E < D
+  include M
+  def f : (:top) -> nil
+end

data/smoke/union-recv.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/typeprof.gemspec

@@ -30,5 +30,5 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_runtime_dependency "rbs", ">= 0.16.0"
+  spec.add_runtime_dependency "rbs", ">= 0.17.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: typeprof
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Yusuke Endoh
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-11-14 00:00:00.000000000 Z
+date: 2020-11-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rbs
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.16.0
+        version: 0.17.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.16.0
+        version: 0.17.0
 description: |
   TypeProf performs a type analysis of non-annotated Ruby code.
 
@@ -229,6 +229,7 @@ files:
 - smoke/optional2.rb
 - smoke/optional3.rb
 - smoke/parameterizedd-self.rb
+- smoke/parameterizedd-self2.rb
 - smoke/pathname1.rb
 - smoke/pathname2.rb
 - smoke/pattern-match1.rb
@@ -264,6 +265,8 @@ files:
 - smoke/rbs-tyvar4.rb
 - smoke/rbs-tyvar5.rb
 - smoke/rbs-tyvar5.rbs
+- smoke/rbs-tyvar6.rb
+- smoke/rbs-tyvar6.rbs
 - smoke/rbs-vars.rb
 - smoke/rbs-vars.rbs
 - smoke/redo1.rb
@@ -292,6 +295,8 @@ files:
 - smoke/super1.rb
 - smoke/super2.rb
 - smoke/super3.rb
+- smoke/super4.rb
+- smoke/super5.rb
 - smoke/svar1.rb
 - smoke/symbol-proc.rb
 - smoke/tap1.rb