typeprof 0.21.11 → 0.30.1

data/lib/typeprof/core/env/method.rb

@@ -0,0 +1,137 @@
+module TypeProf::Core
+  class FormalArguments
+    def initialize(req_positionals, opt_positionals, rest_positionals, post_positionals, req_keywords, opt_keywords, rest_keywords, block)
+      @req_positionals = req_positionals
+      @opt_positionals = opt_positionals
+      @rest_positionals = rest_positionals
+      @post_positionals = post_positionals
+      @req_keywords = req_keywords
+      @opt_keywords = opt_keywords
+      @rest_keywords = rest_keywords
+      @block = block
+    end
+
+    Empty = FormalArguments.new([], [], nil, [], [], [], nil, nil)
+
+    attr_reader :req_positionals
+    attr_reader :opt_positionals
+    attr_reader :rest_positionals
+    attr_reader :post_positionals
+    attr_reader :req_keywords
+    attr_reader :opt_keywords
+    attr_reader :rest_keywords
+    attr_reader :block
+  end
+
+  class ActualArguments
+    def initialize(positionals, splat_flags, keywords, block)
+      @positionals = positionals
+      @splat_flags = splat_flags
+      @keywords = keywords
+      @block = block
+    end
+
+    attr_reader :positionals, :splat_flags, :keywords, :block
+
+    def new_vertexes(genv, node)
+      positionals = @positionals.map {|arg| arg.new_vertex(genv, node) }
+      splat_flags = @splat_flags
+      keywords = @keywords ? @keywords.new_vertex(genv, node) : nil
+      block = @block ? @block.new_vertex(genv, node) : nil
+      ActualArguments.new(positionals, splat_flags, keywords, block)
+    end
+
+    def get_rest_args(genv, start_rest, end_rest)
+      vtxs = []
+
+      start_rest.upto(end_rest - 1) do |i|
+        a_arg = @positionals[i]
+        if @splat_flags[i]
+          a_arg.each_type do |ty|
+            ty = ty.base_type(genv)
+            if ty.is_a?(Type::Instance) && ty.mod == genv.mod_ary && ty.args[0]
+              vtxs << ty.args[0].new_vertex(genv, self)
+            else
+              "???"
+            end
+          end
+        else
+          vtxs << a_arg
+        end
+      end
+
+      vtxs.uniq
+    end
+
+    def get_keyword_arg(genv, changes, name)
+      vtx = Vertex.new(self)
+      @keywords.each_type do |ty|
+        case ty
+        when Type::Hash
+          changes.add_edge(genv, ty.get_value(name), vtx)
+        when Type::Instance
+          if ty.mod == genv.mod_hash
+            changes.add_edge(genv, ty.args[1], vtx)
+          end
+        else
+          # what to do?
+        end
+      end
+      vtx
+    end
+  end
+
+  class Block
+    def initialize(node, f_ary_arg, f_args, next_boxes)
+      @node = node
+      @f_ary_arg = f_ary_arg
+      @f_args = f_args
+      @next_boxes = next_boxes
+    end
+
+    attr_reader :node, :f_args, :ret
+
+    def accept_args(genv, changes, caller_positionals, caller_ret, ret_check)
+      if caller_positionals.size == 1 && @f_args.size >= 2
+        # TODO: support splat "do |a, *b, c|"
+        changes.add_edge(genv, caller_positionals[0].new_vertex(genv, @node), @f_ary_arg)
+      else
+        caller_positionals.zip(@f_args) do |a_arg, f_arg|
+          changes.add_edge(genv, a_arg, f_arg) if f_arg
+        end
+      end
+      if ret_check
+        @next_boxes.each do |box|
+          changes.add_edge(genv, caller_ret, box.f_ret)
+        end
+      else
+        @next_boxes.each do |box|
+          changes.add_edge(genv, box.a_ret, caller_ret)
+        end
+      end
+    end
+  end
+
+  class RecordBlock
+    def initialize(node)
+      @node = node
+      @used = false
+      @f_args = []
+      @ret = Vertex.new(node)
+    end
+
+    def get_f_arg(i)
+      @f_args[i] ||= Vertex.new(@node)
+    end
+
+    attr_reader :node, :f_args, :ret, :used
+
+    def accept_args(genv, changes, caller_positionals, caller_ret, ret_check)
+      @used = true
+      caller_positionals.each_with_index do |a_arg, i|
+        changes.add_edge(genv, a_arg.new_vertex(genv, @node), get_f_arg(i))
+      end
+      changes.add_edge(genv, caller_ret, @ret)
+    end
+  end
+end

data/lib/typeprof/core/env/method_entity.rb

@@ -0,0 +1,55 @@
+module TypeProf::Core
+  class MethodEntity
+    def initialize
+      @builtin = nil
+      @decls = Set[]
+      @defs = Set[]
+      @aliases = {}
+      @method_call_boxes = Set[]
+    end
+
+    attr_reader :decls, :defs, :aliases, :method_call_boxes
+    attr_accessor :builtin
+
+    def add_decl(decl)
+      @decls << decl
+    end
+
+    def remove_decl(decl)
+      @decls.delete(decl) || raise
+    end
+
+    def add_def(mdef)
+      @defs << mdef
+      self
+    end
+
+    def remove_def(mdef)
+      @defs.delete(mdef) || raise
+    end
+
+    def add_alias(node, old_mid)
+      @aliases[node] = old_mid
+    end
+
+    def remove_alias(node)
+      @aliases.delete(node) || raise
+    end
+
+    def exist?
+      @builtin || !@decls.empty? || !@defs.empty?
+    end
+
+    def add_run_all_mdefs(genv)
+      @defs.each do |mdef|
+        genv.add_run(mdef)
+      end
+    end
+
+    def add_run_all_method_call_boxes(genv)
+      @method_call_boxes.each do |box|
+        genv.add_run(box)
+      end
+    end
+  end
+end

data/lib/typeprof/core/env/module_entity.rb

@@ -0,0 +1,408 @@
+module TypeProf::Core
+  class ModuleEntity
+    def initialize(cpath, outer_module = self)
+      @cpath = cpath
+
+      @module_decls = Set[]
+      @module_defs = Set[]
+      @include_decls = Set[]
+      @include_defs = Set[]
+
+      @inner_modules = {}
+      @outer_module = outer_module
+
+      # parent modules (superclass and all modules that I include)
+      @superclass = nil
+      @self_types = {}
+      @included_modules = {}
+      @basic_object = @cpath == [:BasicObject]
+
+      # child modules (subclasses and all modules that include me)
+      @child_modules = {}
+
+      # class Foo[X, Y, Z] < Bar[A, B, C]
+      @superclass_type_args = nil # A, B, C
+      @type_params = [] # X, Y, Z
+
+      @consts = {}
+      @methods = { true => {}, false => {} }
+      @ivars = { true => {}, false => {} }
+      @cvars = {}
+      @type_aliases = {}
+
+      @static_reads = {}
+      @subclass_checks = Set[]
+      @ivar_reads = Set[] # should be handled in @ivars ??
+      @cvar_reads = Set[]
+    end
+
+    attr_reader :cpath
+    attr_reader :module_decls
+    attr_reader :module_defs
+
+    attr_reader :inner_modules
+    attr_reader :outer_module
+
+    attr_reader :superclass
+    attr_reader :self_types
+    attr_reader :included_modules
+    attr_reader :child_modules
+
+    attr_reader :superclass_type_args
+    attr_reader :type_params
+
+    attr_reader :consts
+    attr_reader :methods
+    attr_reader :ivars
+    attr_reader :cvars
+    attr_reader :type_aliases
+
+    attr_reader :static_reads
+    attr_reader :subclass_checks
+    attr_reader :ivar_reads
+    attr_reader :cvar_reads
+
+    def module?
+      !@superclass && !@basic_object
+    end
+
+    def interface?
+      @cpath.last && @cpath.last.start_with?("_")
+    end
+
+    def get_cname
+      @cpath.empty? ? :Object : @cpath.last
+    end
+
+    def exist?
+      !@module_decls.empty? || !@module_defs.empty?
+    end
+
+    def on_inner_modules_changed(genv, changed_cname)
+      @child_modules.each_key do |child_mod|
+        child_mod.on_inner_modules_changed(genv, changed_cname)
+      end
+      if @static_reads[changed_cname]
+        @static_reads[changed_cname].each do |static_read|
+          genv.add_static_eval_queue(:static_read_changed, static_read)
+        end
+      end
+    end
+
+    def on_module_added(genv)
+      return if @cpath.empty?
+      unless exist?
+        genv.add_static_eval_queue(:inner_modules_changed, [@outer_module, get_cname])
+      end
+      genv.add_static_eval_queue(:parent_modules_changed, self)
+    end
+
+    def on_module_removed(genv)
+      return if @cpath.empty?
+      genv.add_static_eval_queue(:parent_modules_changed, self)
+      unless exist?
+        genv.add_static_eval_queue(:inner_modules_changed, [@outer_module, get_cname])
+      end
+    end
+
+    def add_module_decl(genv, decl)
+      on_module_added(genv)
+
+      @module_decls << decl
+
+      if @type_params
+        update_type_params if @type_params != decl.params
+      else
+        @type_params = decl.params
+      end
+
+      if decl.is_a?(AST::SigClassNode) && !@superclass_type_args
+        @superclass_type_args = decl.superclass_args
+      end
+
+      ce = @outer_module.get_const(get_cname)
+      ce.add_decl(decl)
+      ce
+    end
+
+    def remove_module_decl(genv, decl)
+      @outer_module.get_const(get_cname).remove_decl(decl)
+      @module_decls.delete(decl) || raise
+
+      update_type_params if @type_params == decl.params
+      if decl.is_a?(AST::SigClassNode) && @superclass_type_args == decl.superclass_args
+        @superclass_type_args = nil
+        @module_decls.each do |decl|
+          if decl.superclass_args
+            @superclass_type_args = decl.superclass_args
+            break
+          end
+        end
+      end
+
+      on_module_removed(genv)
+    end
+
+    def update_type_params
+      @type_params = nil
+      @module_decls.each do |decl|
+        params = decl.params
+        next unless params
+        if @type_params
+          @type_params = params if (@type_params <=> params) > 0
+        else
+          @type_params = params
+        end
+      end
+      @type_params ||= []
+      # TODO: report an error if there are multiple inconsistent declarations
+    end
+
+    def add_module_def(genv, node)
+      on_module_added(genv)
+      @module_defs << node
+      ce = @outer_module.get_const(get_cname)
+      ce.add_def(node)
+      ce
+    end
+
+    def remove_module_def(genv, node)
+      @outer_module.get_const(get_cname).remove_def(node)
+      @module_defs.delete(node) || raise
+      on_module_removed(genv)
+    end
+
+    def add_include_decl(genv, node)
+      @include_decls << node
+      genv.add_static_eval_queue(:parent_modules_changed, self)
+    end
+
+    def remove_include_decl(genv, node)
+      @include_decls.delete(node) || raise
+      genv.add_static_eval_queue(:parent_modules_changed, self)
+    end
+
+    def add_include_def(genv, node)
+      @include_defs << node
+      genv.add_static_eval_queue(:parent_modules_changed, self)
+    end
+
+    def remove_include_def(genv, node)
+      @include_defs.delete(node) || raise
+      genv.add_static_eval_queue(:parent_modules_changed, self)
+    end
+
+    def update_parent(genv, origin, old_parent, new_parent_cpath)
+      new_parent = new_parent_cpath ? genv.resolve_cpath(new_parent_cpath) : nil
+      if old_parent != new_parent
+        # check circular inheritance
+        mod = new_parent
+        while mod
+          if mod == self
+            # TODO: report an "circular inheritance" error
+            new_parent = nil
+            break
+          end
+          mod = mod.superclass
+        end
+
+        if old_parent != new_parent
+          if old_parent
+            set = old_parent.child_modules[self]
+            set.delete(origin)
+            old_parent.child_modules.delete(self) if set.empty?
+          end
+          if new_parent
+            set = new_parent.child_modules[self] ||= Set[]
+            set << origin
+          end
+          return [new_parent, true]
+        end
+      end
+      return [new_parent, false]
+    end
+
+    def find_superclass_const_read
+      return nil if @basic_object
+
+      if @module_decls.empty?
+        @module_defs.each do |mdef|
+          case mdef
+          when AST::ClassNode
+            if mdef.superclass_cpath
+              const_read = mdef.superclass_cpath.static_ret
+              return const_read ? const_read.cpath : []
+            end
+          when AST::SingletonClassNode
+            next
+          when AST::ModuleNode
+            return nil
+          else
+            raise
+          end
+        end
+      else
+        @module_decls.each do |mdecl|
+          case mdecl
+          when AST::SigClassNode
+            if mdecl.superclass_cpath
+              const_read = mdecl.static_ret[:superclass_cpath].last
+              return const_read ? const_read.cpath : []
+            end
+          when AST::SigModuleNode, AST::SigInterfaceNode
+            return nil
+          end
+        end
+      end
+
+      return []
+    end
+
+    def on_parent_modules_changed(genv)
+      any_updated = false
+
+      unless @basic_object
+        new_superclass_cpath = find_superclass_const_read
+
+        new_superclass, updated = update_parent(genv, :superclass, @superclass, new_superclass_cpath)
+        if updated
+          @superclass = new_superclass
+          any_updated = true
+        end
+      end
+
+      @module_decls.each do |mdecl|
+        case mdecl
+        when AST::SigModuleNode
+          mdecl.static_ret[:self_types].each_with_index do |const_reads, i|
+            key = [mdecl, i]
+            new_parent_cpath = const_reads.last.cpath
+            new_self_type, updated = update_parent(genv, key, @self_types[key], new_parent_cpath)
+            if updated
+              if new_self_type
+                @self_types[key] = new_self_type
+              else
+                @self_types.delete(key) || raise
+              end
+              any_updated = true
+            end
+          end
+        end
+      end
+      @self_types.delete_if do |(origin_mdecl, origin_idx), old_mod|
+        if @module_decls.include?(origin_mdecl)
+          false
+        else
+          _new_self_type, updated = update_parent(genv, [origin_mdecl, origin_idx], old_mod, nil)
+          any_updated ||= updated
+          true
+        end
+      end
+
+      @include_decls.each do |idecl|
+        new_parent_cpath = idecl.static_ret.last.cpath
+        new_parent, updated = update_parent(genv, idecl, @included_modules[idecl], new_parent_cpath)
+        if updated
+          if new_parent
+            @included_modules[idecl] = new_parent
+          else
+            @included_modules.delete(idecl) || raise
+          end
+          any_updated = true
+        end
+      end
+      @include_defs.each do |idef|
+        new_parent_cpath = idef.static_ret ? idef.static_ret.cpath : nil
+        new_parent, updated = update_parent(genv, idef, @included_modules[idef], new_parent_cpath)
+        if updated
+          if new_parent
+            @included_modules[idef] = new_parent
+          else
+            @included_modules.delete(idef) || raise
+          end
+          any_updated = true
+        end
+      end
+      @included_modules.delete_if do |origin, old_mod|
+        if @include_decls.include?(origin) || @include_defs.include?(origin)
+          false
+        else
+          _new_parent, updated = update_parent(genv, origin, old_mod, nil)
+          any_updated ||= updated
+          true
+        end
+      end
+
+      if any_updated
+        @subclass_checks.each do |mcall_box|
+          genv.add_run(mcall_box)
+        end
+        on_ancestors_updated(genv, nil)
+      end
+    end
+
+    def on_ancestors_updated(genv, base_mod)
+      @child_modules.each_key {|child_mod| child_mod.on_ancestors_updated(genv, base_mod || self) }
+      @static_reads.each_value do |static_reads|
+        static_reads.each do |static_read|
+          genv.add_static_eval_queue(:static_read_changed, static_read)
+        end
+      end
+      @methods.each do |_, methods|
+        methods.each_value do |me|
+          me.method_call_boxes.each do |box|
+            genv.add_run(box)
+          end
+        end
+      end
+      @ivar_reads.each {|ivar_read| genv.add_run(ivar_read) }
+      @cvar_reads.each {|cvar_read| genv.add_run(cvar_read) }
+    end
+
+    def each_descendant(base_mod = nil, &blk)
+      return if base_mod == self
+      yield self
+      @child_modules.each_key do |child_mod|
+        child_mod.each_descendant(base_mod || self, &blk)
+      end
+    end
+
+    def get_const(cname)
+      @consts[cname] ||= ValueEntity.new
+    end
+
+    def get_method(singleton, mid)
+      @methods[singleton][mid] ||= MethodEntity.new
+    end
+
+    def get_ivar(singleton, name)
+      @ivars[singleton][name] ||= ValueEntity.new
+    end
+
+    def get_cvar(name)
+      @cvars[name] ||= ValueEntity.new
+    end
+
+    def get_type_alias(name)
+      @type_aliases[name] ||= TypeAliasEntity.new
+    end
+
+    def get_vertexes(vtxs)
+      @inner_modules.each_value do |mod|
+        next if self.equal?(mod) # for Object
+        mod.get_vertexes(vtxs)
+      end
+      @consts.each_value do |cdef|
+        vtxs << cdef.vtx
+      end
+    end
+
+    def show_cpath
+      @cpath.empty? ? "Object" : @cpath.join("::" )
+    end
+
+    def pretty_print(q)
+      q.text "#<ModuleEntity[::#{ @cpath.empty? ? "Object" : @cpath.join("::") }]>"
+    end
+  end
+end