typeprof 0.5.4 → 0.9.0

data/lib/typeprof/type.rb

@@ -149,6 +149,10 @@ module TypeProf
       raise "cannot substitute abstract type: #{ self.class }"
     end
 
+    def generate_substitution
+      {}
+    end
+
     DummySubstitution = Object.new
     def DummySubstitution.[](_)
       Type.any
@@ -170,7 +174,7 @@ module TypeProf
         "untyped"
       end
 
-      def get_method(mid, scratch)
+      def method_dispatch_info
         nil
       end
 
@@ -203,11 +207,12 @@ module TypeProf
         local = nil
         tys.each do |ty|
           raise ty.inspect unless ty.is_a?(Type)
-          local = true if ty.is_a?(LocalArray) || ty.is_a?(LocalHash)
+          local = true if ty.is_a?(Local)
         end
         raise if local && elems
 
         @elems = elems
+        raise elems.inspect if elems && !elems.is_a?(::Hash)
       end
 
       def each_free_type_variable(&blk)
@@ -285,7 +290,7 @@ module TypeProf
             types.delete(Type::Instance.new(Type::Builtin[:true]))
             bool = true
           end
-          types.delete(Type.any) unless Config.options[:pedantic_output]
+          types.delete(Type.any) unless Config.options[:show_untyped]
           proc_tys, types = types.partition {|ty| ty.is_a?(Proc) }
           types = types.map {|ty| ty.screen_name(scratch) }
           types << scratch.show_proc_signature(proc_tys) unless proc_tys.empty?
@@ -310,9 +315,14 @@ module TypeProf
       def globalize(env, visited, depth)
         return Type.any if depth <= 0
         tys = Utils::Set[]
-        raise if @elems
+        if @elems
+          # XXX: If @elems is non nil, the Union type should global, so calling globalize against such a type should not occur.
+          # However, currently, ActualArguments may contain global types for flag_args_kw_splat case.
+          # This should be fixed in future in ActualArguments side. See Scratch#setup_actual_arguments.
+          #raise
+        end
 
-        elems = {}
+        elems = @elems ? @elems.dup : {}
         @types.each do |ty|
           ty = ty.globalize(env, visited, depth - 1)
           case ty
@@ -435,10 +445,12 @@ module TypeProf
         @idx = idx
         @type_params = type_params
         @superclass = superclass
+        raise if @kind == :class && !@superclass
         @_name = name
       end
 
       attr_reader :kind, :idx, :type_params, :superclass
+      attr_accessor :superclass_type_args
 
       def inspect
         if @_name
@@ -452,8 +464,8 @@ module TypeProf
         "singleton(#{ scratch.get_class_name(self) })"
       end
 
-      def get_method(mid, scratch)
-        scratch.get_method(self, true, mid)
+      def method_dispatch_info
+        [self, true]
       end
 
       def consistent?(other)
@@ -485,6 +497,8 @@ module TypeProf
       def initialize(klass)
         raise unless klass
         raise if klass == Type.any
+        raise if klass.is_a?(Type::Instance)
+        raise if klass.is_a?(Type::Union)
         @klass = klass
       end
 
@@ -504,8 +518,8 @@ module TypeProf
         end
       end
 
-      def get_method(mid, scratch)
-        scratch.get_method(@klass, false, mid)
+      def method_dispatch_info
+        [@klass, false]
       end
 
       def consistent?(other)
@@ -558,8 +572,8 @@ module TypeProf
         end
       end
 
-      def get_method(mid, scratch)
-        @base_type.get_method(mid, scratch)
+      def method_dispatch_info
+        @base_type.method_dispatch_info
       end
 
       def substitute(subst, depth)
@@ -600,8 +614,8 @@ module TypeProf
         end
       end
 
-      def get_method(mid, scratch)
-        @base_type.get_method(mid, scratch)
+      def method_dispatch_info
+        @base_type.method_dispatch_info
       end
 
       def substitute(_subst, _depth)
@@ -630,8 +644,8 @@ module TypeProf
         @base_type
       end
 
-      def get_method(mid, scratch)
-        @base_type.get_method(mid, scratch)
+      def method_dispatch_info
+        @base_type.method_dispatch_info
       end
 
       def consistent?(_other)
@@ -675,6 +689,8 @@ module TypeProf
         Type::Literal.new(obj, Type::Instance.new(Type::Builtin[:int]))
       when ::Rational
         Type::Literal.new(obj, Type::Instance.new(Type::Builtin[:rational]))
+      when ::Complex
+        Type::Literal.new(obj, Type::Instance.new(Type::Builtin[:complex]))
       when ::Float
         Type::Literal.new(obj, Type::Instance.new(Type::Builtin[:float]))
       when ::Class
@@ -711,6 +727,8 @@ module TypeProf
         Type.nil
       when ::Range
         Type::Literal.new(obj, Type::Instance.new(Type::Builtin[:range]))
+      when ::Encoding
+        Type::Literal.new(obj, Type::Instance.new(Type::Builtin[:encoding]))
       else
         raise "unknown object: #{ obj.inspect }"
       end
@@ -813,8 +831,10 @@ module TypeProf
     def initialize(lead_tys, opt_tys, rest_ty, post_tys, kw_tys, kw_rest_ty, blk_ty)
       @lead_tys = lead_tys
       @opt_tys = opt_tys
+      raise unless opt_tys.is_a?(Array)
       @rest_ty = rest_ty
       @post_tys = post_tys
+      raise unless post_tys
       @kw_tys = kw_tys
       kw_tys.each {|a| raise if a.size != 3 } if kw_tys
       @kw_rest_ty = kw_rest_ty
@@ -834,6 +854,44 @@ module TypeProf
       MethodSignature.new(lead_tys, opt_tys, rest_ty, post_tys, kw_tys, kw_rest_ty, blk_ty)
     end
 
+    def merge_as_block_arguments(other)
+      lead_tys1, opt_tys1, rest_ty1, post_tys1 = @lead_tys, @opt_tys, @rest_ty, @post_tys
+      lead_tys2, opt_tys2, rest_ty2, post_tys2 = other.lead_tys, other.opt_tys, other.rest_ty, other.post_tys
+
+      case
+      when lead_tys1.size > lead_tys2.size
+        n = lead_tys2.size
+        lead_tys1, opt_tys1 = lead_tys1[0, n], lead_tys1[n..] + opt_tys1
+      when lead_tys1.size < lead_tys2.size
+        n = lead_tys1.size
+        lead_tys2, opt_tys2 = lead_tys2[0, n], lead_tys2[n..] + opt_tys2
+      end
+      case
+      when post_tys1.size > post_tys2.size
+        i = post_tys1.size - post_tys2.size
+        if rest_ty1
+          rest_ty1 = post_tys[0, i].inject(rest_ty1) {|ty1, ty2| ty1.union(ty2) }
+          post_tys1 = post_tys1[i..]
+        else
+          opt_tys1, post_tys1 = opt_tys1 + post_tys1[0, i], post_tys1[i..]
+        end
+      when post_tys1.size < post_tys2.size
+        i = post_tys2.size - post_tys1.size
+        if rest_ty2
+          rest_ty2 = post_tys[0, i].inject(rest_ty2) {|ty1, ty2| ty1.union(ty2) }
+          post_tys2 = post_tys2[i..]
+        else
+          opt_tys2, post_tys2 = opt_tys2 + post_tys2[0, i], post_tys2[i..]
+        end
+      end
+
+      # XXX: tweak keywords too
+
+      msig1 = MethodSignature.new(lead_tys1, opt_tys1, rest_ty1, post_tys1, @kw_tys, @kw_rest_ty, @blk_ty)
+      msig2 = MethodSignature.new(lead_tys2, opt_tys2, rest_ty2, post_tys2, other.kw_tys, other.kw_rest_ty, other.blk_ty)
+      msig1.merge(msig2)
+    end
+
     def merge(other)
       raise if @lead_tys.size != other.lead_tys.size
       raise if @post_tys.size != other.post_tys.size

data/lib/typeprof/version.rb

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

data/smoke/alias.rb

@@ -20,11 +20,12 @@ Test.new.qux("str")
 __END__
 # Classes
 class Object
-  def foo : (Integer) -> Integer
-  def bar : (String) -> String
+  private
+  def foo: (Integer) -> Integer
+  def bar: (String) -> String
 end
 
 class Test
-  def baz : (Integer) -> Integer
-  def qux : (String) -> String
+  def baz: (Integer) -> Integer
+  def qux: (String) -> String
 end

data/smoke/alias2.rb

@@ -12,8 +12,8 @@ Foo[:x, :y, :z]
 __END__
 # Classes
 class Foo
-  @a : :x
-  @b : :y
-  @c : :z
-  def initialize : (:x, :y, :z) -> [:x, :y, :z]
+  @a: :x
+  @b: :y
+  @c: :z
+  def initialize: (:x, :y, :z) -> [:x, :y, :z]
 end

data/smoke/any1.rb

@@ -11,5 +11,6 @@ smoke/any1.rb:2: [error] undefined method: Integer#undefined_method
 
 # Classes
 class Object
-  def foo : -> untyped
+  private
+  def foo: -> untyped
 end

data/smoke/any2.rb

@@ -12,6 +12,7 @@ bar
 __END__
 # Classes
 class Object
-  def foo : -> untyped
-  def bar : -> Integer
+  private
+  def foo: -> untyped
+  def bar: -> Integer
 end

data/smoke/arguments.rb

@@ -11,6 +11,7 @@ smoke/arguments.rb:6: [error] wrong number of arguments (given 2, expected 1)
 
 # Classes
 class Object
-  def foo : (untyped) -> nil
-  def bar : (untyped) -> nil
+  private
+  def foo: (untyped) -> nil
+  def bar: (untyped) -> nil
 end

data/smoke/arguments2.rb

@@ -42,14 +42,15 @@ f10 {|n| }
 __END__
 # Classes
 class Object
-  def f1 : -> nil
-  def f2 : (:x, :y, :z) -> nil
-  def f3 : (?String, ?String) -> nil
-  def f4 : (*:a | :b | :c) -> nil
-  def f5 : (:x, ?String, :z) -> nil
-  def f6 : (k: :kk) -> nil
-  def f7 : (?k: Integer) -> nil
-  def f8 : (?k: String) -> nil
-  def f9 : (**{k: :kk}) -> nil
-  def f10 : { (Integer) -> nil } -> nil
+  private
+  def f1: -> nil
+  def f2: (:x, :y, :z) -> nil
+  def f3: (?String, ?String) -> nil
+  def f4: (*:a | :b | :c) -> nil
+  def f5: (:x, ?String, :z) -> nil
+  def f6: (k: :kk) -> nil
+  def f7: (?k: Integer) -> nil
+  def f8: (?k: String) -> nil
+  def f9: (**{k: :kk}) -> nil
+  def f10: { (Integer) -> nil } -> nil
 end

data/smoke/array-each.rb

@@ -10,5 +10,6 @@ log(nil)
 __END__
 # Classes
 class Object
-  def log : ((:sym | Integer | String)?) -> nil
+  private
+  def log: ((:sym | Integer | String)?) -> nil
 end

data/smoke/array-each2.rb

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

data/smoke/array-each3.rb

@@ -8,5 +8,6 @@ end
 __END__
 # Classes
 class Object
-  def log : (untyped) -> nil
+  private
+  def log: (bot) -> nil
 end

data/smoke/array-ltlt.rb

@@ -9,5 +9,6 @@ foo
 __END__
 # Classes
 class Object
-  def foo : -> (Array[Integer | String])
+  private
+  def foo: -> (Array[Integer | String])
 end

data/smoke/array-ltlt2.rb

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

data/smoke/array-map.rb

@@ -7,5 +7,6 @@ foo([1, 2, 3])
 __END__
 # Classes
 class Object
-  def foo : ([Integer, Integer, Integer]) -> Array[String]
+  private
+  def foo: ([Integer, Integer, Integer]) -> Array[String]
 end

data/smoke/array-map2.rb

@@ -6,5 +6,6 @@ foo([1, 2, 3])
 __END__
 # Classes
 class Object
-  def foo : ([Integer, Integer, Integer]) -> (Array[Integer | String])
+  private
+  def foo: ([Integer, Integer, Integer]) -> (Array[Integer | String])
 end

data/smoke/array-map3.rb

@@ -16,7 +16,8 @@ map_bang_test_known_bug([1, 2, 3])
 __END__
 # Classes
 class Object
-  def map_test : ([Integer, Integer, Integer]) -> Array[String]
-  def map_bang_test : ([Integer, Integer, Integer]) -> (Array[Integer | String])
-  def map_bang_test_known_bug : ([Integer, Integer, Integer]) -> [Integer, Integer, Integer]
+  private
+  def map_test: ([Integer, Integer, Integer]) -> Array[String]
+  def map_bang_test: ([Integer, Integer, Integer]) -> (Array[Integer | String])
+  def map_bang_test_known_bug: ([Integer, Integer, Integer]) -> [Integer, Integer, Integer]
 end

data/smoke/array-mul.rb

@@ -12,6 +12,7 @@ bar([1, 2, 3])
 __END__
 # Classes
 class Object
-  def foo : ([Integer, Integer, Integer]) -> Array[Integer]
-  def bar : ([Integer, Integer, Integer]) -> String
+  private
+  def foo: ([Integer, Integer, Integer]) -> Array[Integer]
+  def bar: ([Integer, Integer, Integer]) -> String
 end

data/smoke/array-plus1.rb

@@ -6,5 +6,6 @@ log([1] + ["str"] + [2] + [:sym])
 __END__
 # Classes
 class Object
-  def log : (Array[:sym | Integer | String]) -> nil
+  private
+  def log: (Array[:sym | Integer | String]) -> nil
 end

data/smoke/array-plus2.rb

@@ -10,6 +10,6 @@ Foo.new.foo
 __END__
 # Classes
 class Foo
-  @var : Array[Integer]
-  def foo : -> Array[Integer]
+  @var: Array[Integer]
+  def foo: -> Array[Integer]
 end

data/smoke/array-pop.rb

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

data/smoke/array-range-aref.rb

@@ -0,0 +1,71 @@
+def f1(*ary)
+  ary[1..3]
+end
+
+def f2(*ary)
+  ary[1...3]
+end
+
+def f3(*ary)
+  ary[1..-3]
+end
+
+def f4(*ary)
+  ary[1...-3]
+end
+
+def f5(*ary)
+  ary[-4..3]
+end
+
+def f6(*ary)
+  ary[-4...3]
+end
+
+def f7(*ary)
+  ary[-4..-3]
+end
+
+def f8(*ary)
+  ary[-4...-3]
+end
+
+def f9(*ary)
+  ary[...3]
+end
+
+def f10(*ary)
+  ary[3..]
+end
+
+def dispatch(*ary)
+  f1(*ary)
+  f2(*ary)
+  f3(*ary)
+  f4(*ary)
+  f5(*ary)
+  f6(*ary)
+  f7(*ary)
+  f8(*ary)
+  f9(*ary)
+  f10(*ary)
+end
+
+dispatch(:a, :b, :c, :d, :e)
+
+__END__
+# Classes
+class Object
+  private
+  def f1: (*:a | :b | :c | :d | :e) -> (Array[:a | :b | :c | :d | :e])
+  def f2: (*:a | :b | :c | :d | :e) -> (Array[:a | :b | :c | :d | :e])
+  def f3: (*:a | :b | :c | :d | :e) -> (Array[:a | :b | :c | :d | :e])
+  def f4: (*:a | :b | :c | :d | :e) -> (Array[:a | :b | :c | :d | :e])
+  def f5: (*:a | :b | :c | :d | :e) -> (Array[:a | :b | :c | :d | :e])
+  def f6: (*:a | :b | :c | :d | :e) -> (Array[:a | :b | :c | :d | :e])
+  def f7: (*:a | :b | :c | :d | :e) -> (Array[:a | :b | :c | :d | :e])
+  def f8: (*:a | :b | :c | :d | :e) -> (Array[:a | :b | :c | :d | :e])
+  def f9: (*:a | :b | :c | :d | :e) -> (Array[:a | :b | :c | :d | :e])
+  def f10: (*:a | :b | :c | :d | :e) -> (Array[:a | :b | :c | :d | :e])
+  def dispatch: (*:a | :b | :c | :d | :e) -> (Array[:a | :b | :c | :d | :e])
+end