typeprof 0.14.0 → 0.15.2

data/lib/typeprof/method.rb

@@ -283,12 +283,12 @@ module TypeProf
             # XXX: a block is passed to a method that does not accept block.
             # Should we call the passed block with any arguments?
             ret_ty = ret_ty.remove_type_vars
-            ctn[ret_ty, caller_ep, ncaller_env]
+            ctn[ret_ty, caller_ep, ncaller_env] if ret_ty != Type.bot
           end
         else
           ret_ty = ret_ty.substitute(subst, Config.options[:type_depth_limit])
           ret_ty = ret_ty.remove_type_vars
-          ctn[ret_ty, caller_ep, ncaller_env]
+          ctn[ret_ty, caller_ep, ncaller_env] if ret_ty != Type.bot
         end
       end
 

data/lib/typeprof/type.rb

@@ -102,34 +102,43 @@ module TypeProf
 
       ty1, ty2 = self, other
 
-      ty1 = container_to_union(ty1)
-      ty2 = container_to_union(ty2)
+      case
+      when ty1.is_a?(Union)
+        ty1_types = ty1.types
+        ty1_elems = ty1.elems
+      when ty1.is_a?(Array) || ty1.is_a?(Hash)
+        ty1_types = Utils::Set[]
+        ty1_elems = {[ty1.class, ty1.base_type] => ty1.elems}
+      else
+        ty1_types = ty1_elems = nil
+      end
+
+      case
+      when ty2.is_a?(Union)
+        ty2_types = ty2.types
+        ty2_elems = ty2.elems
+      when ty2.is_a?(Array) || ty2.is_a?(Hash)
+        ty2_types = Utils::Set[]
+        ty2_elems = {[ty2.class, ty2.base_type] => ty2.elems}
+      else
+        ty2_types = ty2_elems = nil
+      end
 
-      if ty1.is_a?(Union) && ty2.is_a?(Union)
-        ty = ty1.types.sum(ty2.types)
-        all_elems = ty1.elems.dup || {}
-        ty2.elems&.each do |key, elems|
+      if ty1_types && ty2_types
+        ty = ty1_types.sum(ty2_types)
+        all_elems = ty1_elems.dup || {}
+        ty2_elems&.each do |key, elems|
           all_elems[key] = union_elems(all_elems[key], elems)
         end
         all_elems = nil if all_elems.empty?
 
-        Type::Union.new(ty, all_elems).normalize
-      else
-        ty1, ty2 = ty2, ty1 if ty2.is_a?(Union)
-        if ty1.is_a?(Union)
-          Type::Union.new(ty1.types.add(ty2), ty1.elems).normalize
-        else
-          Type::Union.new(Utils::Set[ty1, ty2], nil).normalize
-        end
-      end
-    end
-
-    private def container_to_union(ty)
-      case ty
-      when Type::Array, Type::Hash
-        Type::Union.new(Utils::Set[], { [ty.class, ty.base_type] => ty.elems })
+        Type::Union.create(ty, all_elems)
+      elsif ty1_types
+        Type::Union.create(ty1_types.add(ty2), ty1_elems)
+      elsif ty2_types
+        Type::Union.create(ty2_types.add(ty1), ty2_elems)
       else
-        ty
+        Type::Union.create(Utils::Set[ty1, ty2], nil)
       end
     end
 
@@ -207,6 +216,37 @@ module TypeProf
 
 
     class Union < Type
+      def self.create(tys, elems)
+        if tys.size == 1 && !elems
+          tys.each {|ty| return ty }
+        elsif tys.size == 0
+          if elems && elems.size == 1
+            (container_kind, base_type), nelems = elems.first
+            # container_kind = Type::Array or Type::Hash
+            container_kind.new(nelems, base_type)
+          else
+            new(tys, elems)
+          end
+        else
+          class_instances = []
+          non_class_instances = []
+          degenerated = false
+          tys.each do |ty|
+            if ty != Type::Instance.new(Type::Builtin[:nil]) && ty.is_a?(Type::Instance) && ty.klass.kind == :class
+              class_instances << ty
+              degenerated = true if ty.include_subclasses
+            else
+              non_class_instances << ty
+            end
+          end
+          if (Config.options[:union_width_limit] >= 2 && class_instances.size >= Config.options[:union_width_limit]) || (degenerated && class_instances.size >= 2)
+            create(Utils::Set[Instance.new_degenerate(class_instances), *non_class_instances], elems)
+          else
+            new(tys, elems)
+          end
+        end
+      end
+
       def initialize(tys, elems)
         raise unless tys.is_a?(Utils::Set)
         @types = tys # Set
@@ -243,22 +283,6 @@ module TypeProf
 
       attr_reader :types, :elems
 
-      def normalize
-        if @types.size == 1 && !@elems
-          @types.each {|ty| return ty }
-        elsif @types.size == 0
-          if @elems && @elems.size == 1
-            (container_kind, base_type), elems = @elems.first
-            # container_kind = Type::Array or Type::Hash
-            container_kind.new(elems, base_type)
-          else
-            self
-          end
-        else
-          self
-        end
-      end
-
       def each_child(&blk) # local
         @types.each(&blk)
         raise if @elems
@@ -343,7 +367,7 @@ module TypeProf
         end
         elems = nil if elems.empty?
 
-        Type::Union.new(tys, elems).normalize
+        Type::Union.create(tys, elems)
       end
 
       def localize(env, alloc_site, depth)
@@ -357,7 +381,7 @@ module TypeProf
           env, ty = ty.localize(env, alloc_site, depth - 1)
           tys = tys.add(ty)
         end
-        ty = Union.new(tys, nil).normalize
+        ty = Union.create(tys, nil)
         return env, ty
       end
 
@@ -381,7 +405,7 @@ module TypeProf
         elems = @elems&.to_h do |(container_kind, base_type), elems|
           [[container_kind, base_type], elems.substitute(subst, depth - 1)]
         end
-        ty = Union.new(tys, elems).normalize
+        ty = Union.create(tys, elems)
         unions.each do |ty0|
           ty = ty.union(ty0)
         end
@@ -484,7 +508,7 @@ module TypeProf
       end
 
       def method_dispatch_info
-        [self, true]
+        [self, true, false]
       end
 
       def consistent?(other)
@@ -513,15 +537,40 @@ module TypeProf
     end
 
     class Instance < Type
-      def initialize(klass)
+      def initialize(klass, include_subclasses=false)
         raise unless klass
         raise if klass == Type.any
         raise if klass.is_a?(Type::Instance)
         raise if klass.is_a?(Type::Union)
         @klass = klass
+        @include_subclasses = include_subclasses
+      end
+
+      def self.new_degenerate(instances)
+        klass = instances.first.klass
+        ancestors = []
+        ancestor_idxs = {}
+        while klass != :__root__
+          ancestor_idxs[klass] = ancestors.size
+          ancestors << klass
+          klass = klass.superclass
+        end
+        common_superclass = nil
+        instances[1..].each do |instance|
+          klass = instance.klass
+          while !ancestor_idxs[klass]
+            klass = klass.superclass
+          end
+          common_superclass = klass
+          ancestor_idxs[klass].times do |i|
+            ancestor_idxs.delete(ancestors[i])
+            ancestors[i] = nil
+          end
+        end
+        new(common_superclass, true)
       end
 
-      attr_reader :klass
+      attr_reader :klass, :include_subclasses
 
       def inspect
         "I[#{ @klass.inspect }]"
@@ -533,12 +582,12 @@ module TypeProf
         when Type::Builtin[:true] then "true"
         when Type::Builtin[:false] then "false"
         else
-          scratch.get_class_name(@klass)
+          scratch.get_class_name(@klass) + (@include_subclasses ? "" : "")
         end
       end
 
       def method_dispatch_info
-        [@klass, false]
+        [@klass, false, @include_subclasses]
       end
 
       def consistent?(other)
@@ -846,7 +895,8 @@ module TypeProf
         fargs << ("**" + all_val_ty.screen_name(scratch))
       end
       if Config.options[:show_parameter_names]
-        farg_names = farg_names.map {|name| name == :type ? :type_ : name } # XXX: workaround of RBS parser bug
+        farg_names = farg_names.map {|name| RBS::Parser::KEYWORDS.key?(name.to_s) ? "`#{name}`" : name }
+        farg_names = farg_names.map {|name| name.is_a?(Integer) ? "noname_#{ name }" : name }
         fargs = fargs.zip(farg_names).map {|farg, name| name ? "#{ farg } #{ name }" : farg }
       end
       fargs = fargs.empty? ? "" : "(#{ fargs.join(", ") })"

data/lib/typeprof/version.rb

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

data/smoke/alias2.rb

@@ -17,5 +17,5 @@ class Foo
   @c: :z
 
   alias self.[] self.new
-  def initialize: (:x a, :y b, :z c) -> [:x, :y, :z]
+  def initialize: (:x a, :y b, :z c) -> void
 end

data/smoke/array3.rb

@@ -20,7 +20,7 @@ __END__
 class Foo
   @ary: [Integer, String?, :sym]
 
-  def initialize: -> [Integer, String, :sym]
+  def initialize: -> void
   def foo: -> String?
   def bar: -> nil
 end

data/smoke/attr-module.rb

@@ -10,18 +10,15 @@ end
 Foo.foo = 42
 Bar.new.foo = "str"
 
-# XXX: the output may be improved
-
 __END__
 # Classes
 module Foo
   self.@foo: Integer
 
-  attr_accessor foo: untyped
+  attr_accessor foo: String
   attr_accessor self.foo: Integer
 end
 
 class Bar
   include Foo
-  @foo: String
 end

data/smoke/attr-vis.rb

@@ -30,7 +30,7 @@ smoke/attr-vis.rb:20: [warning] inconsistent assignment to RBS-declared variable
 
 # Classes
 class Foo
-  def initialize: -> Integer
+  def initialize: -> void
 
   private
   attr_accessor foo: Integer | String

data/smoke/attr.rb

@@ -20,7 +20,7 @@ foo.c = :ccc
 __END__
 # Classes
 class Foo
-  def initialize: (:aaa a) -> :aaa
+  def initialize: (:aaa a) -> void
   attr_reader a: :aaa
   attr_writer b: :bbb
   def get_b: -> :bbb

data/smoke/break2.rb

@@ -12,5 +12,5 @@ __END__
 # Classes
 class Object
   private
-  def foo: -> (Integer | String)
+  def foo: -> String
 end

data/smoke/gvar2.rb

@@ -8,9 +8,6 @@ __END__
 # Errors
 smoke/gvar2.rb:1: [warning] inconsistent assignment to RBS-declared variable
 
-# Global variables
-#$foo: String
-
 # Classes
 class Object
   private

data/smoke/huge_union.rb

@@ -0,0 +1,86 @@
+class C0; end
+class C1 < C0; def foo(n); end; end
+class C2 < C0; def foo(n); end; end
+class C3 < C0; def foo(n); end; end
+class C4 < C0; def foo(n); end; end
+class C5 < C0; def foo(n); end; end
+class C6 < C0; def foo(n); end; end
+class C7 < C0; def foo(n); end; end
+class C8 < C0; def foo(n); end; end
+class C9 < C0; def foo(n); end; end
+class C10 < C0; def foo(n); end; end
+class C11 < C0; def foo(n); end; end
+class C12 < C0; def foo(n); end; end
+
+def dispatch_foo(n)
+  n.foo("str")
+end
+
+dispatch_foo(C1.new)
+dispatch_foo(C2.new)
+dispatch_foo(C3.new)
+dispatch_foo(C4.new)
+dispatch_foo(C5.new)
+dispatch_foo(C6.new)
+dispatch_foo(C7.new)
+dispatch_foo(C8.new)
+dispatch_foo(C9.new)
+dispatch_foo(C10.new)
+
+__END__
+# Classes
+class Object
+  private
+  def dispatch_foo: (C0 n) -> nil
+end
+
+class C0
+end
+
+class C1 < C0
+  def foo: (String n) -> nil
+end
+
+class C2 < C0
+  def foo: (String n) -> nil
+end
+
+class C3 < C0
+  def foo: (String n) -> nil
+end
+
+class C4 < C0
+  def foo: (String n) -> nil
+end
+
+class C5 < C0
+  def foo: (String n) -> nil
+end
+
+class C6 < C0
+  def foo: (String n) -> nil
+end
+
+class C7 < C0
+  def foo: (String n) -> nil
+end
+
+class C8 < C0
+  def foo: (String n) -> nil
+end
+
+class C9 < C0
+  def foo: (String n) -> nil
+end
+
+class C10 < C0
+  def foo: (String n) -> nil
+end
+
+class C11 < C0
+  def foo: (String n) -> nil
+end
+
+class C12 < C0
+  def foo: (String n) -> nil
+end

data/smoke/identifier_keywords.rb

@@ -0,0 +1,17 @@
+def type(type)
+end
+
+def out(*out)
+end
+
+def untyped(untyped:)
+end
+
+__END__
+# Classes
+class Object
+  private
+  def type: (untyped `type`) -> nil
+  def out: (*untyped `out`) -> nil
+  def untyped: (untyped: untyped) -> nil
+end

data/smoke/initialize.rb

@@ -24,5 +24,5 @@ class A
   @str: String
   @val: (Integer | String)?
 
-  def initialize: ((Integer | String)? x) -> ((Integer | String)?)
+  def initialize: ((Integer | String)? x) -> void
 end

data/smoke/ivar2.rb

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