typeprof 0.15.2 → 0.15.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c31fc03c67fa15924e901b70890318e2391fa58cfaf897e51ff6a00d673d792a
-  data.tar.gz: c6ce703ec1c5f8a41d04603162746adb8a9416ccf29abc8ef1441cf83a3b41e3
+  metadata.gz: 13f530c84fe1b38000dc93982adac87c01d6d3a3516f8502e3de252d56428a12
+  data.tar.gz: b799ff212fd16b59bb96f8b560252e687d206e9a3ba541eaa6033532108957e3
 SHA512:
-  metadata.gz: 790815f2528442ae742df0c3576a97ff6d2c856db374f2c8a63bb965dd6c715b6fa686d84b1fd56683e938e9c8e4014e9e86b53bb34ca4e9975b93bb5e5188df
-  data.tar.gz: ecc1433a74aebbe31c267c4697d71389a841cd66d74b251d1cc2d22bbeca228f141a8861ecbeebee3b16d54a8397f41eeab4f1f25ebac42103aee5e1146c9fe6
+  metadata.gz: 6e11866f36a7570ba564bf2abe6912f2531f728e76c4afc32f9bfddc436ea03a86a996eb4d3ddd2bf8c24e9eeae0986b45f17f06575d80df21b812585976f1ba
+  data.tar.gz: 8e990ceee15c1dba1cf529990fbb6e26a4f48946088549f51471c48ff1aeccfdc7cb8b6547c1105e00767263acee681db4340240f94c786b39bbeff842d501dc

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    typeprof (0.15.1)
+    typeprof (0.15.3)
       rbs (>= 1.3.1)
 
 GEM
@@ -11,7 +11,7 @@ GEM
     docile (1.4.0)
     power_assert (2.0.0)
     rake (13.0.1)
-    rbs (1.3.3)
+    rbs (1.6.1)
     simplecov (0.21.2)
       docile (~> 1.1)
       simplecov-html (~> 0.11)

data/lib/typeprof/container-type.rb

@@ -307,7 +307,11 @@ module TypeProf
         def screen_name(scratch)
           if @rest_ty == Type.bot
             if @lead_tys.empty?
-              return "Array[bot]" # RBS does not allow an empty tuple "[]"
+              # This is heuristic: in general, an empty array is a wrong guess.
+              # Note that an empty array is representable as "[ ]" in RBS, but
+              # users often have to modify it to "Array[something]".
+              # In this term, "Array[untyped]" is considered more useful than "[ ]".
+              return "Array[untyped]"
             end
             s = @lead_tys.map do |ty|
               ty.screen_name(scratch)
@@ -673,6 +677,8 @@ module TypeProf
               k_ty = k_ty.union(k)
               v_ty = v_ty.union(v)
             end
+            k_ty = Type.any if k_ty == Type.bot
+            v_ty = Type.any if v_ty == Type.bot
             k_ty = k_ty.screen_name(scratch)
             v_ty = v_ty.screen_name(scratch)
             "Hash[#{ k_ty }, #{ v_ty }]"

data/lib/typeprof/import.rb

@@ -459,6 +459,8 @@ module TypeProf
         end
       when RBS::Types::Union
         [:union, ty.types.map {|ty2| conv_type(ty2) }.compact]
+      when RBS::Types::Intersection
+        [:intersection, ty.types.map {|ty2| conv_type(ty2) }.compact]
       when RBS::Types::Optional
         [:optional, conv_type(ty.type)]
       when RBS::Types::Interface
@@ -729,6 +731,9 @@ module TypeProf
       when :union
         tys = ty[1]
         Type::Union.create(Utils::Set[*tys.map {|ty2| conv_type(ty2) }], nil) # XXX: Array and Hash support
+      when :intersection
+        tys = ty[1]
+        conv_type(tys.first) # XXX: This is wrong! We need to support intersection type
       when :var
         Type::Var.new(ty[1])
       when :proc

data/lib/typeprof/version.rb

@@ -1,3 +1,3 @@
 module TypeProf
-  VERSION = "0.15.2"
+  VERSION = "0.15.3"
 end

data/smoke/array15.rb

@@ -12,5 +12,5 @@ Foo.new[1] = "str"
 __END__
 # Classes
 class Foo
-  def []=: (*Integer | String args) -> Array[bot]
+  def []=: (*Integer | String args) -> Array[untyped]
 end

data/smoke/array6.rb

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

data/smoke/array8.rb

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

data/smoke/block-args2.rb

@@ -48,11 +48,11 @@ __END__
 class Object
   private
   def f1: { -> nil } -> ^(nil, *bot, nil) -> nil
-  def log1: (nil a, Array[bot] r, nil c) -> nil
+  def log1: (nil a, Array[untyped] r, nil c) -> nil
   def f2: { (:a) -> nil } -> ^(:a, *bot, nil) -> nil
-  def log2: (:a a, Array[bot] r, nil c) -> 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[bot] r, :b c) -> 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)

data/smoke/block-args3.rb

@@ -57,13 +57,13 @@ __END__
 class Object
   private
   def f1: { -> nil } -> ^(nil, ?:opt, *bot, nil) -> nil
-  def log1: (nil a, :opt o, Array[bot] r, nil c) -> 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[bot] r, nil c) -> 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[bot] r, :b c) -> 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[bot] r, :c 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)

data/smoke/hash-bot.rb

@@ -8,5 +8,5 @@ __END__
 # Classes
 class Object
   private
-  def foo: -> Hash[Integer, Array[bot]]
+  def foo: -> Hash[Integer, Array[untyped]]
 end

data/smoke/hash4.rb

@@ -7,5 +7,5 @@ __END__
 # Classes
 class Object
   private
-  def foo: -> Hash[bot, bot]
+  def foo: -> Hash[untyped, untyped]
 end

data/smoke/parameterizedd-self.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: typeprof
 version: !ruby/object:Gem::Version
-  version: 0.15.2
+  version: 0.15.3
 platform: ruby
 authors:
 - Yusuke Endoh
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-08-18 00:00:00.000000000 Z
+date: 2021-09-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rbs
@@ -419,7 +419,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.0.dev
+rubygems_version: 3.2.15
 signing_key: 
 specification_version: 4
 summary: TypeProf is a type analysis tool for Ruby code based on abstract interpretation