typeprof 0.4.1 → 0.5.3

data/lib/typeprof/version.rb

@@ -1,3 +1,3 @@
 module TypeProf
-  VERSION = "0.4.1"
+  VERSION = "0.5.3"
 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/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/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

@@ -13,6 +13,6 @@ bar
 __END__
 # Classes
 class Object
-  def foo : -> {:int=>Integer, :str=>String}
+  def foo : -> {int: Integer, str: String}
   def bar : -> ({Integer=>Integer | String, String=>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/hash4.rb

@@ -6,5 +6,5 @@ foo
 __END__
 # Classes
 class Object
-  def foo : -> Hash[bot, bot]
+  def foo : -> {}
 end

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}
+  attr_reader hash : {a: Integer, b: String, c: :sym}
   def initialize : -> {}
   def set : -> :sym
 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 baz : (**{int: Integer, str: String}) -> nil
   def qux : (**{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/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/uninitialize-var.rb

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

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.4.1
+  version: 0.5.3
 platform: ruby
 authors:
 - Yusuke Endoh
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-11-05 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.
 
@@ -179,6 +179,7 @@ files:
 - smoke/gvar2.rb
 - smoke/gvar2.rbs
 - smoke/hash-fetch.rb
+- smoke/hash-merge-bang.rb
 - smoke/hash1.rb
 - smoke/hash2.rb
 - smoke/hash3.rb
@@ -230,6 +231,8 @@ files:
 - smoke/parameterizedd-self.rb
 - smoke/pathname1.rb
 - smoke/pathname2.rb
+- smoke/pattern-match1.rb
+- smoke/pattern-match2.rb
 - smoke/printf.rb
 - smoke/proc.rb
 - smoke/proc2.rb
@@ -258,6 +261,9 @@ files:
 - smoke/rbs-tyvar2.rbs
 - smoke/rbs-tyvar3.rb
 - smoke/rbs-tyvar3.rbs
+- smoke/rbs-tyvar4.rb
+- smoke/rbs-tyvar5.rb
+- smoke/rbs-tyvar5.rbs
 - smoke/rbs-vars.rb
 - smoke/rbs-vars.rbs
 - smoke/redo1.rb
@@ -293,6 +299,7 @@ files:
 - smoke/two-map.rb
 - smoke/type_var.rb
 - smoke/typed_method.rb
+- smoke/uninitialize-var.rb
 - smoke/union-recv.rb
 - smoke/user-demo.rb
 - smoke/wrong-extend.rb
@@ -327,7 +334,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.2.0.rc.2
 signing_key: 
 specification_version: 4
 summary: TypeProf is a type analysis tool for Ruby code based on abstract interpretation