typeprof 0.4.1 → 0.5.3

data/lib/typeprof/config.rb

@@ -69,19 +69,23 @@ module TypeProf
     prologue_ep = ExecutionPoint.new(prologue_ctx, -1, nil)
     prologue_env = Env.new(StaticEnv.new(:top, Type.nil, false), [], [], Utils::HashWrapper.new({}))
 
-    Config.rb_files.each do |file|
-      if file.respond_to?(:read)
-        iseq = ISeq.compile_str(file.read, file.to_s)
+    Config.rb_files.each do |rb|
+      if rb.is_a?(Array) # [String name, String content]
+        iseq = ISeq.compile_str(*rb.reverse)
       else
-        iseq = ISeq.compile(file)
+        iseq = ISeq.compile(rb)
       end
       ep, env = TypeProf.starting_state(iseq)
       scratch.merge_env(ep, env)
       scratch.add_callsite!(ep.ctx, prologue_ep, prologue_env) {|ty, ep| }
     end
 
-    Config.rbs_files.each do |path|
-      Import.import_rbs_file(scratch, path)
+    Config.rbs_files.each do |rbs|
+      if rbs.is_a?(Array) # [String name, String content]
+        Import.import_rbs_code(scratch, *rbs)
+      else
+        Import.import_rbs_file(scratch, rbs)
+      end
     end
 
     result = scratch.type_profile

data/lib/typeprof/container-type.rb

@@ -19,13 +19,44 @@ module TypeProf
     # Cell, Array, and Hash are types for global interface, e.g., TypedISeq.
     # Do not push such types to local environment, stack, etc.
 
+    class ContainerType < Type
+      def match?(other)
+        return nil if self.class != other.class
+        return nil unless @base_type.consistent?(other.base_type)
+        @elems.match?(other.elems)
+      end
+
+      def each_free_type_variable(&blk)
+        @elems.each_free_type_variable(&blk)
+      end
+
+      def consistent?(other)
+        raise "must not be used"
+      end
+
+      def self.create_empty_instance(klass)
+        base_type = Type::Instance.new(klass)
+        case klass
+        when Type::Builtin[:ary] # XXX: check inheritance...
+          Type::Array.new(Type::Array::Elements.new([], Type.bot), base_type)
+        when Type::Builtin[:hash]
+          Type.gen_hash(base_type) {|h| }
+        else
+          Type::Cell.new(Type::Cell::Elements.new([Type.bot] * klass.type_params.size), base_type)
+        end
+      end
+    end
+
     # The most basic container type for default type parameter class
-    class Cell < Type
+    class Cell < ContainerType
       def initialize(elems, base_type)
         raise if !elems.is_a?(Cell::Elements)
         @elems = elems # Cell::Elements
         raise unless base_type
         @base_type = base_type
+        if base_type.klass.type_params.size != elems.elems.size
+          raise
+        end
       end
 
       attr_reader :elems, :base_type
@@ -44,7 +75,7 @@ module TypeProf
 
       def localize(env, alloc_site, depth)
         return env, Type.any if depth <= 0
-        alloc_site = alloc_site.add_id(:cell)
+        alloc_site = alloc_site.add_id(:cell).add_id(@base_type)
         env, elems = @elems.localize(env, alloc_site, depth)
         env.deploy_type(LocalCell, alloc_site, elems, @base_type)
       end
@@ -58,31 +89,13 @@ module TypeProf
         raise
       end
 
-      def consistent?(other, subst)
-        case other
-        when Type::Any then true
-        when Type::Var then other.add_subst!(self, subst)
-        when Type::Union
-          other.types.each do |ty2|
-            return true if consistent?(ty2, subst)
-          end
-          return false
-        when Type::Cell
-          @elems.size == other.elems.size &&
-            @base_type.consistent?(other.base_type, subst) &&
-            @elems.zip(other.elems).all? {|elem1, elem2| elem1..consistent?(elem2, subst) }
-        else
-          self == other
-        end
-      end
-
       def substitute(subst, depth)
         return Type.any if depth <= 0
         elems = @elems.substitute(subst, depth)
         Cell.new(elems, @base_type)
       end
 
-      class Elements
+      class Elements # Cell
         include Utils::StructuralEquality
 
         def initialize(elems)
@@ -124,12 +137,21 @@ module TypeProf
           end
         end
 
-        def consistent?(other, subst)
-          false if @elems.size != other.elems.size
+        def match?(other)
+          return nil if @elems.size != other.elems.size
+          subst = nil
           @elems.zip(other.elems) do |ty0, ty1|
-            return false unless ty0.consistent?(ty1, subst)
+            subst2 = Type.match?(ty0, ty1)
+            return nil unless subst2
+            subst = Type.merge_substitution(subst, subst2)
+          end
+          subst
+        end
+
+        def each_free_type_variable(&blk)
+          @elems.each do |ty|
+            ty.each_free_type_variable(&blk)
           end
-          return true
         end
 
         def substitute(subst, depth)
@@ -146,6 +168,9 @@ module TypeProf
 
         def union(other)
           return self if self == other
+          if @elems.size != other.elems.size
+            raise "#{ @elems.size } != #{ other.elems.size }"
+          end
           elems = []
           @elems.zip(other.elems) do |ty0, ty1|
             elems << ty0.union(ty1)
@@ -155,7 +180,7 @@ module TypeProf
       end
     end
 
-    class LocalCell < Type
+    class LocalCell < ContainerType
       def initialize(id, base_type)
         @id = id
         raise unless base_type
@@ -184,6 +209,7 @@ module TypeProf
           else
             elems = Cell::Elements.new([]) # XXX
           end
+          visited.delete(self)
           Cell.new(elems, @base_type)
         end
       end
@@ -191,14 +217,10 @@ module TypeProf
       def get_method(mid, scratch)
         @base_type.get_method(mid, scratch)
       end
-
-      def consistent?(other, subst)
-        raise "must not be used"
-      end
     end
 
     # Do not insert Array type to local environment, stack, etc.
-    class Array < Type
+    class Array < ContainerType
       def initialize(elems, base_type)
         raise unless elems.is_a?(Array::Elements)
         @elems = elems # Array::Elements
@@ -223,7 +245,7 @@ module TypeProf
 
       def localize(env, alloc_site, depth)
         return env, Type.any if depth <= 0
-        alloc_site = alloc_site.add_id(:ary)
+        alloc_site = alloc_site.add_id(:ary).add_id(@base_type)
         env, elems = @elems.localize(env, alloc_site, depth - 1)
         env.deploy_type(LocalArray, alloc_site, elems, @base_type)
       end
@@ -237,29 +259,13 @@ module TypeProf
         raise
       end
 
-      def consistent?(other, subst)
-        case other
-        when Type::Any then true
-        when Type::Var then other.add_subst!(self, subst)
-        when Type::Union
-          other.types.each do |ty2|
-            return true if consistent?(ty2, subst)
-          end
-          return false
-        when Type::Array
-          @base_type.consistent?(other.base_type, subst) && @elems.consistent?(other.elems, subst)
-        else
-          self == other
-        end
-      end
-
       def substitute(subst, depth)
         return Type.any if depth <= 0
         elems = @elems.substitute(subst, depth - 1)
         Array.new(elems, @base_type)
       end
 
-      class Elements
+      class Elements # Array
         include Utils::StructuralEquality
 
         def initialize(lead_tys, rest_ty = Type.bot)
@@ -318,14 +324,24 @@ module TypeProf
           end
         end
 
-        def consistent?(other, subst)
+        def match?(other)
           n = [@lead_tys.size, other.lead_tys.size].min
-          n.times do |i|
-            return false unless @lead_tys[i].consistent?(other.lead_tys[i], subst)
-          end
           rest_ty1 = @lead_tys[n..].inject(@rest_ty) {|ty1, ty2| ty1.union(ty2) }
           rest_ty2 = other.lead_tys[n..].inject(other.rest_ty) {|ty1, ty2| ty1.union(ty2) }
-          rest_ty1.consistent?(rest_ty2, subst)
+          subst = nil
+          (@lead_tys[0, n] + [rest_ty1]).zip(other.lead_tys[0, n] + [rest_ty2]) do |ty0, ty1|
+            subst2 = Type.match?(ty0, ty1)
+            return nil unless subst2
+            subst = Type.merge_substitution(subst, subst2)
+          end
+          subst
+        end
+
+        def each_free_type_variable(&blk)
+          @lead_tys.each do |ty|
+            ty.each_free_type_variable(&blk)
+          end
+          @rest_ty&.each_free_type_variable(&blk)
         end
 
         def substitute(subst, depth)
@@ -476,7 +492,7 @@ module TypeProf
     end
 
     # Do not insert Array type to local environment, stack, etc.
-    class LocalArray < Type
+    class LocalArray < ContainerType
       def initialize(id, base_type)
         @id = id
         raise unless base_type
@@ -506,6 +522,7 @@ module TypeProf
             # TODO: currently out-of-scope array cannot be accessed
             elems = Array::Elements.new([], Type.any)
           end
+          visited.delete(self)
           Array.new(elems, @base_type)
         end
       end
@@ -513,14 +530,10 @@ module TypeProf
       def get_method(mid, scratch)
         @base_type.get_method(mid, scratch)
       end
-
-      def consistent?(other, subst)
-        raise "must not be used"
-      end
     end
 
 
-    class Hash < Type
+    class Hash < ContainerType
       def initialize(elems, base_type)
         @elems = elems
         raise unless elems
@@ -539,7 +552,7 @@ module TypeProf
 
       def localize(env, alloc_site, depth)
         return env, Type.any if depth <= 0
-        alloc_site = alloc_site.add_id(:hash)
+        alloc_site = alloc_site.add_id(:hash).add_id(@base_type)
         env, elems = @elems.localize(env, alloc_site, depth - 1)
         env.deploy_type(LocalHash, alloc_site, elems, @base_type)
       end
@@ -553,29 +566,13 @@ module TypeProf
         raise
       end
 
-      def consistent?(other, subst)
-        case other
-        when Type::Any then true
-        when Type::Var then other.add_subst!(self, subst)
-        when Type::Union
-          other.types.each do |ty2|
-            return true if consistent?(ty2, subst)
-          end
-          return false
-        when Type::Hash
-          @base_type.consistent?(other.base_type, subst) && @elems.consistent?(other.elems, subst)
-        else
-          self == other
-        end
-      end
-
       def substitute(subst, depth)
         return Type.any if depth <= 0
         elems = @elems.substitute(subst, depth - 1)
         Hash.new(elems, @base_type)
       end
 
-      class Elements
+      class Elements # Hash
         include Utils::StructuralEquality
 
         def initialize(map_tys)
@@ -635,9 +632,13 @@ module TypeProf
 
         def screen_name(scratch)
           s = @map_tys.map do |k_ty, v_ty|
-            k = k_ty.screen_name(scratch)
             v = v_ty.screen_name(scratch)
-            "#{ k }=>#{ v }"
+            if k_ty.is_a?(Type::Symbol)
+              "#{ k_ty.sym }: #{ v }"
+            else
+              k = k_ty.screen_name(scratch)
+              "#{ k }=>#{ v }"
+            end
           end.join(", ")
           "{#{ s }}"
         end
@@ -657,22 +658,31 @@ module TypeProf
           end
         end
 
-        def consistent?(other, subst)
-          subst2 = subst.dup
+        def match?(other)
+          subst = nil
           other.map_tys.each do |k1, v1|
-            found = false
+            subst2 = nil
             @map_tys.each do |k0, v0|
-              subst3 = subst2.dup
-              if k0.consistent?(k1, subst3) && v0.consistent?(v1, subst3)
-                subst2.replace(subst3)
-                found = true
-                break
+              subst3 = Type.match?(k0, k1)
+              if subst3
+                subst4 = Type.match?(v0, v1)
+                if subst4
+                  subst2 = Type.merge_substitution(subst2, subst3)
+                  subst2 = Type.merge_substitution(subst2, subst4)
+                end
               end
             end
-            return false unless found
+            return nil unless subst2
+            subst = Type.merge_substitution(subst, subst2)
+          end
+          subst
+        end
+
+        def each_free_type_variable(&blk)
+          @map_tys.each do |k, v|
+            k.each_free_type_variable(&blk)
+            v.each_free_type_variable(&blk)
           end
-          subst.replace(subst2)
-          true
         end
 
         def substitute(subst, depth)
@@ -706,7 +716,7 @@ module TypeProf
         def [](key_ty)
           val_ty = Type.bot
           @map_tys.each do |k_ty, v_ty|
-            if k_ty.consistent?(key_ty, {})
+            if Type.match?(k_ty, key_ty)
               val_ty = val_ty.union(v_ty)
             end
           end
@@ -763,7 +773,7 @@ module TypeProf
       end
     end
 
-    class LocalHash < Type
+    class LocalHash < ContainerType
       def initialize(id, base_type)
         @id = id
         @base_type = base_type
@@ -791,6 +801,7 @@ module TypeProf
           else
             elems = Hash::Elements.new({Type.any => Type.any})
           end
+          visited.delete(self)
           Hash.new(elems, @base_type)
         end
       end
@@ -798,10 +809,6 @@ module TypeProf
       def get_method(mid, scratch)
         @base_type.get_method(mid, scratch)
       end
-
-      def consistent?(other, subst)
-        raise "must not be used"
-      end
     end
   end
 end

data/lib/typeprof/export.rb

@@ -174,7 +174,7 @@ module TypeProf
       cvars = cvars.map do |var, entry|
         next if entry.absolute_paths.all? {|path| Config.check_dir_filter(path) == :exclude }
         [var, entry.type.screen_name(@scratch), entry.rbs_declared]
-      end
+      end.compact
 
       if !class_def.absolute_path || Config.check_dir_filter(class_def.absolute_path) == :exclude
         return nil if consts.empty? && included_mods.empty? && extended_mods.empty? && ivars.empty? && cvars.empty? && iseq_methods.empty? && attr_methods.empty? && inner_classes.empty?

data/lib/typeprof/import.rb

@@ -10,7 +10,10 @@ module TypeProf
     def self.get_builtin_env
       unless @builtin_env
         @builtin_env = RBS::Environment.new
-        @builtin_env_json = load_rbs(@builtin_env, builtin: true)
+
+        loader = RBS::EnvironmentLoader.new
+        new_decls = loader.load(env: @builtin_env).map {|decl,| decl }
+        @builtin_env_json = load_rbs(@builtin_env, new_decls)
       end
 
       return @builtin_env.dup, @builtin_env_json
@@ -21,27 +24,34 @@ module TypeProf
     end
 
     def load_library(lib)
-      RBSReader.load_rbs(@env, library: lib)
+      loader = RBS::EnvironmentLoader.new(core_root: nil)
+      loader.add(library: lib)
+      new_decls = loader.load(env: @env).map {|decl,| decl }
+      RBSReader.load_rbs(@env, new_decls)
     end
 
     def load_path(path)
-      RBSReader.load_rbs(@env, path: path)
+      loader = RBS::EnvironmentLoader.new(core_root: nil)
+      loader.add(path: path)
+      new_decls = loader.load(env: @env).map {|decl,| decl }
+      RBSReader.load_rbs(@env, new_decls)
     end
 
-    def self.load_rbs(env, builtin: false, **opt)
-      if builtin
-        loader = RBS::EnvironmentLoader.new
-      else
-        loader = RBS::EnvironmentLoader.new(core_root: nil)
-        loader.add(**opt)
+    def load_rbs_string(name, content)
+      buffer = RBS::Buffer.new(name: name, content: content)
+      new_decls = []
+      RBS::Parser.parse_signature(buffer).each do |decl|
+        @env << decl
+        new_decls << decl
       end
-      new_decls = loader.load(env: env)
+      RBSReader.load_rbs(@env, new_decls)
+    end
 
+    def self.load_rbs(env, new_decls)
       all_env = env.resolve_type_names
-
       resolver = RBS::TypeNameResolver.from_env(all_env)
       cur_env = RBS::Environment.new
-      new_decls.each do |decl,|
+      new_decls.each do |decl|
         cur_env << env.resolve_declaration(resolver, decl, outer: [], prefix: RBS::Namespace.root)
       end
 
@@ -210,7 +220,7 @@ module TypeProf
       #   * superclasses and modules appear earlier than their subclasses (Object is earlier than String)
       #   * namespace module appers earlier than its children (Process is earlier than Process::Status)
       visited = {}
-      queue = @cur_env.class_decls.keys.map {|name| [:visit, name] }
+      queue = @cur_env.class_decls.keys.map {|name| [:visit, name] }.reverse
       until queue.empty?
         event, name = queue.pop
         case event
@@ -365,10 +375,15 @@ module TypeProf
           raise if ty.args.size != 2
           [:array, [:Enumerator], [], conv_type(ty.args.first)]
         else
-          [:instance, klass]
+          if ty.args.empty?
+            [:instance, klass]
+          else
+            [:cell, [:instance, klass], ty.args.map {|ty| conv_type(ty) }]
+          end
         end
       when RBS::Types::Bases::Bool   then [:bool]
       when RBS::Types::Bases::Any    then [:any]
+      when RBS::Types::Bases::Top    then [:any]
       when RBS::Types::Bases::Void   then [:void]
       when RBS::Types::Bases::Self   then [:self]
       when RBS::Types::Bases::Nil    then [:nil]
@@ -440,6 +455,10 @@ module TypeProf
       Import.new(scratch, scratch.rbs_reader.load_path(rbs_path)).import(true)
     end
 
+    def self.import_rbs_code(scratch, rbs_name, rbs_code)
+      Import.new(scratch, scratch.rbs_reader.load_rbs_string(rbs_name, rbs_code)).import(true)
+    end
+
     def initialize(scratch, json)
       @scratch = scratch
       @json = json
@@ -485,11 +504,11 @@ module TypeProf
         rbs_sources = members[:rbs_sources]
 
         included_modules.each do |mod|
-          @scratch.include_module(klass, path_to_klass(mod), nil)
+          @scratch.include_module(klass, path_to_klass(mod), false, nil)
         end
 
         extended_modules.each do |mod|
-          @scratch.extend_module(klass, path_to_klass(mod), nil)
+          @scratch.include_module(klass, path_to_klass(mod), true, nil)
         end
 
         methods.each do |(singleton, method_name), mdef|
@@ -499,24 +518,25 @@ module TypeProf
         end
 
         ivars.each do |ivar_name, ty|
-          ty = conv_type(ty)
+          ty = conv_type(ty).remove_type_vars
           @scratch.add_ivar_write!(Type::Instance.new(klass), ivar_name, ty, nil)
         end
 
         cvars.each do |ivar_name, ty|
-          ty = conv_type(ty)
+          ty = conv_type(ty).remove_type_vars
           @scratch.add_cvar_write!(klass, ivar_name, ty, nil)
         end
       end
 
       @json[:constants].each do |classpath, value|
         base_klass = path_to_klass(classpath[0..-2])
-        value = conv_type(value)
+        value = conv_type(value).remove_type_vars
         @scratch.add_constant(base_klass, classpath[-1], value, nil)
       end
 
-      @json[:globals].each do |name, value|
-        @scratch.add_gvar_write!(name, conv_type(value), nil)
+      @json[:globals].each do |name, ty|
+        ty = conv_type(ty).remove_type_vars
+        @scratch.add_gvar_write!(name, ty, nil)
       end
 
       true
@@ -574,6 +594,8 @@ module TypeProf
       case ty.first
       when :class then path_to_klass(ty[1])
       when :instance then Type::Instance.new(path_to_klass(ty[1]))
+      when :cell
+        Type::Cell.new(Type::Cell::Elements.new(ty[2].map {|ty| conv_type(ty) }), conv_type(ty[1]))
       when :any then Type.any
       when :void then Type::Void.new
       when :nil then Type.nil
@@ -609,7 +631,7 @@ module TypeProf
         end
       when :union
         tys = ty[1]
-        Type::Union.new(Utils::Set[*tys.map {|ty2| conv_type(ty2) }], nil) # XXX: Array and Hash support
+        Type::Union.new(Utils::Set[*tys.map {|ty2| conv_type(ty2) }], nil).normalize # XXX: Array and Hash support
       when :var
         Type::Var.new(ty[1])
       when :proc