typeprof 0.33.0 → 0.33.2

data/lib/typeprof/core/env.rb

@@ -42,6 +42,11 @@ module TypeProf::Core
 
       @bot_type = Type::Bot.new(self)
 
+      # The vertex for a type argument that is not given. This must be shared:
+      # a fresh vertex makes a different Instance type and a different edge on
+      # every run, so a box that uses it is re-run forever.
+      @untyped_arg = Source.new
+
       @run_count = 0
     end
 
@@ -52,7 +57,7 @@ module TypeProf::Core
     attr_reader :obj_type, :nil_type, :true_type, :false_type, :str_type
     attr_reader :int_type, :float_type, :rational_type, :complex_type
     attr_reader :proc_type, :symbol_type, :method_type, :set_type, :regexp_type
-    attr_reader :bot_type
+    attr_reader :bot_type, :untyped_arg
 
     def gen_ary_type(elem_vtx)
       Type::Instance.new(self, @mod_ary, [elem_vtx])
@@ -130,18 +135,18 @@ module TypeProf::Core
       ty_env = base_ty_env.dup
       if base_ty.is_a?(Type::Instance)
         base_ty.mod.type_params.zip(base_ty.args) do |(param, default_ty), arg|
-          ty_env[param] = arg || (default_ty ? default_ty.covariant_vertex(self, changes, ty_env) : Source.new)
+          ty_env[param] = arg || (default_ty ? default_ty.covariant_vertex(self, changes, ty_env) : @untyped_arg)
         end
       elsif base_ty.is_a?(Type::Singleton)
         base_ty.mod.type_params&.each do |(param, default_ty)|
-          ty_env[param] = default_ty ? default_ty.covariant_vertex(self, changes, ty_env) : Source.new
+          ty_env[param] = default_ty ? default_ty.covariant_vertex(self, changes, ty_env) : @untyped_arg
         end
       end
       args = mod.type_params.zip(type_args).map do |(param, default_ty), arg|
         if changes
-          (arg || default_ty)&.covariant_vertex(self, changes, ty_env) || Source.new
+          (arg || default_ty)&.covariant_vertex(self, changes, ty_env) || @untyped_arg
         else
-          Source.new
+          @untyped_arg
         end
       end
       Type::Instance.new(self, mod, args)
@@ -283,17 +288,6 @@ module TypeProf::Core
       mod.get_type_alias(name)
     end
 
-    # Returns the type parameter names of the first generic declaration of cpath
-    def find_type_params(decls, cpath)
-      decls.each do |decl|
-        next unless decl.cpath == cpath
-        next unless decl.respond_to?(:params)
-        params = decl.params
-        return params if params && !params.empty?
-      end
-      nil
-    end
-
     def load_core_rbs(raw_decls, position_encoding)
       file_context = FileContext.new(nil, position_encoding)
       lenv = LocalEnv.new(file_context, CRef::Toplevel, {}, [])
@@ -301,11 +295,6 @@ module TypeProf::Core
         AST.create_rbs_decl(raw_decl, lenv)
       end.compact
 
-      # A module entity has one set of parameter names shared by all its declarations,
-      # so the shim must reuse the core's ones (Array's was `Elem`, and is `E` since RBS 4.1)
-      ary_elem, = find_type_params(decls, [:Array]) || [:Elem]
-      hash_key, hash_val = find_type_params(decls, [:Hash]) || [:K, :V]
-
       decls += AST.parse_rbs("typeprof-rbs-shim.rbs", <<-RBS, position_encoding)
         class Exception
           include _Exception
@@ -314,12 +303,12 @@ module TypeProf::Core
           include _ToS
           include _ToStr
         end
-        class Array[#{ ary_elem }]
-          include _ToAry[#{ ary_elem }]
-          include _Each[#{ ary_elem }]
+        class Array[Elem]
+          include _ToAry[Elem]
+          include _Each[Elem]
         end
-        class Hash[#{ hash_key }, #{ hash_val }]
-          include _Each[[#{ hash_key }, #{ hash_val }]]
+        class Hash[K, V]
+          include _Each[[K, V]]
         end
         class Object
           include Hash::_Key
@@ -380,7 +369,7 @@ module TypeProf::Core
   end
 
   class LocalEnv
-    def initialize(file_context, cref, locals, return_boxes, forward_args = nil)
+    def initialize(file_context, cref, locals, return_boxes, forward_args = nil, sig_type_params: nil)
       @file_context = file_context
       @cref = cref
       @locals = locals
@@ -390,10 +379,13 @@ module TypeProf::Core
       @ivar_narrowings = {}
       @strict_const_scope = false
       @forward_args = forward_args
+      @shadowed_vars = {}
+      # [cpath, names] of the type parameters of the enclosing RBS declaration
+      @sig_type_params = sig_type_params
     end
 
-    attr_reader :file_context, :cref, :locals, :return_boxes, :break_vtx, :next_boxes, :strict_const_scope
-    attr_accessor :module_function, :forward_args
+    attr_reader :file_context, :cref, :locals, :return_boxes, :break_vtx, :next_boxes, :strict_const_scope, :sig_type_params
+    attr_accessor :module_function, :forward_args, :shadowed_vars
 
     def path = @file_context&.path
     def code_range_from_node(node)
@@ -412,6 +404,12 @@ module TypeProf::Core
       @locals[name] || raise("#{ name }")
     end
 
+    # A bare `super` passes the variables of the method, not the block
+    # parameters that shadow them
+    def get_method_var(name)
+      @shadowed_vars[name] || get_var(name)
+    end
+
     def exist_var?(name)
       !!@locals[name]
     end
@@ -457,20 +455,23 @@ module TypeProf::Core
   end
 
   class CRef
-    def initialize(cpath, scope_level, mid, outer)
+    # in_method: whether this is inside a method body, which a define_method
+    # block is even though its method name (mid) is not known
+    def initialize(cpath, scope_level, mid, outer, in_method: !mid.nil?)
       @cpath = cpath
       @scope_level = scope_level
       @mid = mid
       @outer = outer
+      @in_method = in_method
     end
 
-    attr_reader :cpath, :scope_level, :mid, :outer
+    attr_reader :cpath, :scope_level, :mid, :outer, :in_method
 
     def get_self(genv)
       case @scope_level
       when :instance
         mod = genv.resolve_cpath(@cpath || [])
-        type_params = mod.type_params.map {|(_name, _default_ty)| Source.new() } # TODO: better support
+        type_params = mod.type_params.map {|(_name, _default_ty)| genv.untyped_arg } # TODO: better support
         ty = Type::Instance.new(genv, mod, type_params)
         Source.new(ty)
       when :class

data/lib/typeprof/core/graph/box.rb

@@ -399,7 +399,7 @@ module TypeProf::Core
         a_args.block.each_type do |ty|
           case ty
           when Type::Proc
-            ty.block.accept_args(genv, changes, blk_a_args)
+            ty.block.pass_arguments(genv, changes, ActualArguments.new(blk_a_args, ::Array.new(blk_a_args.size, false), nil, nil))
 
             if ty.block.is_a?(Block)
               ty.block.next_boxes.each do |next_box|
@@ -625,20 +625,7 @@ module TypeProf::Core
     def wrong_return_type(f_ret_show, changes)
       actual_ty = @a_ret.show
       msg = "expected: #{ f_ret_show }; actual: #{ actual_ty }"
-      case @node
-      when AST::ReturnNode
-        changes.add_diagnostic(:code_range, msg, @node)
-      when AST::DefNode
-        changes.add_diagnostic(:last_stmt_code_range, msg, @node)
-      when AST::NextNode
-        changes.add_diagnostic(:code_range, msg, @node)
-      when AST::CallNode
-        changes.add_diagnostic(:block_last_stmt_code_range, msg, @node)
-      when AST::AttrReaderMetaNode, AST::AttrAccessorMetaNode
-        changes.add_diagnostic(:code_range, msg, @node)
-      else
-        pp @node.class
-      end
+      changes.add_diagnostic(:ret_code_range, msg, @node)
     end
   end
 
@@ -693,6 +680,8 @@ module TypeProf::Core
       @fallback = fallback
       @rest.add_edge(genv, self)
       @ret = Vertex.new(node)
+      # An empty rest never triggers a run, but the fallback still has to flow
+      genv.add_run(self)
     end
 
     attr_reader :ret
@@ -790,7 +779,7 @@ module TypeProf::Core
         ty = Type::Singleton.new(genv, mod)
         param_map0 = Type.default_param_map(genv, ty)
       else
-        type_params = mod.type_params.map {|(_name, _default_ty)| Source.new() } # TODO: better support
+        type_params = mod.type_params.map {|(_name, _default_ty)| genv.untyped_arg } # TODO: better support
         ty = Type::Instance.new(genv, mod, type_params)
         param_map0 = Type.default_param_map(genv, ty)
         if ty.is_a?(Type::Instance)
@@ -838,143 +827,11 @@ module TypeProf::Core
     end
 
     def pass_arguments(changes, genv, a_args)
-      if a_args.splat_flags.any?
-        # there is at least one splat actual argument
-
-        lower = @f_args.req_positionals.size + @f_args.post_positionals.size
-        upper = @f_args.rest_positionals ? nil : lower + @f_args.opt_positionals.size
-        if upper && upper < a_args.positionals.size
-          meth = changes.node.mid_code_range ? :mid_code_range : :code_range
-          err = "#{ a_args.positionals.size } for #{ lower }#{ upper ? lower < upper ? "...#{ upper }" : "" : "+" }"
-          changes.add_diagnostic(meth, "wrong number of arguments (#{ err })")
-          return false
-        end
-
-        start_rest = [a_args.splat_flags.index(true), @f_args.req_positionals.size + @f_args.opt_positionals.size].min
-        end_rest = [a_args.splat_flags.rindex(true) + 1, a_args.positionals.size - @f_args.post_positionals.size].max
-        rest_vtxs = a_args.get_rest_args(genv, changes, start_rest, end_rest)
-
-        @f_args.req_positionals.each_with_index do |f_vtx, i|
-          if i < start_rest
-            changes.add_edge(genv, a_args.positionals[i], f_vtx)
-          else
-            rest_vtxs.each do |vtx|
-              changes.add_edge(genv, vtx, f_vtx)
-            end
-          end
-        end
-        @f_args.opt_positionals.each_with_index do |f_vtx, i|
-          i += @f_args.req_positionals.size
-          if i < start_rest
-            changes.add_edge(genv, a_args.positionals[i], f_vtx)
-          else
-            rest_vtxs.each do |vtx|
-              changes.add_edge(genv, vtx, f_vtx)
-            end
-          end
-        end
-        @f_args.post_positionals.each_with_index do |f_vtx, i|
-          i += a_args.positionals.size - @f_args.post_positionals.size
-          if end_rest <= i
-            changes.add_edge(genv, a_args.positionals[i], f_vtx)
-          else
-            rest_vtxs.each do |vtx|
-              changes.add_edge(genv, vtx, f_vtx)
-            end
-          end
-        end
-
-        if @f_args.rest_positionals
-          rest_vtxs.each do |vtx|
-            @f_args.rest_positionals.each_type do |ty|
-              if ty.is_a?(Type::Instance) && ty.mod == genv.mod_ary && ty.args[0]
-                changes.add_edge(genv, vtx, ty.args[0])
-              end
-            end
-          end
-        end
-      else
-        # there is no splat actual argument
-
-        lower = @f_args.req_positionals.size + @f_args.post_positionals.size
-        upper = @f_args.rest_positionals ? nil : lower + @f_args.opt_positionals.size
-        if a_args.positionals.size < lower || (upper && upper < a_args.positionals.size)
-          meth = changes.node.mid_code_range ? :mid_code_range : :code_range
-          err = "#{ a_args.positionals.size } for #{ lower }#{ upper ? lower < upper ? "...#{ upper }" : "" : "+" }"
-          changes.add_diagnostic(meth, "wrong number of arguments (#{ err })")
-          return false
-        end
-
-        @f_args.req_positionals.each_with_index do |f_vtx, i|
-          changes.add_edge(genv, a_args.positionals[i], f_vtx)
-        end
-        @f_args.post_positionals.each_with_index do |f_vtx, i|
-          i -= @f_args.post_positionals.size
-          changes.add_edge(genv, a_args.positionals[i], f_vtx)
-        end
-        start_rest = @f_args.req_positionals.size
-        end_rest = a_args.positionals.size - @f_args.post_positionals.size
-        i = 0
-        while i < @f_args.opt_positionals.size && start_rest < end_rest
-          f_arg = @f_args.opt_positionals[i]
-          changes.add_edge(genv, a_args.positionals[start_rest], f_arg)
-          i += 1
-          start_rest += 1
-        end
-
-        if start_rest < end_rest
-          if @f_args.rest_positionals
-            (start_rest..end_rest-1).each do |i|
-              @f_args.rest_positionals.each_type do |ty|
-                if ty.is_a?(Type::Instance) && ty.mod == genv.mod_ary && ty.args[0]
-                  changes.add_edge(genv, a_args.positionals[i], ty.args[0])
-                end
-              end
-            end
-          end
-        end
-      end
-
-      if a_args.keywords
-        # TODO: support diagnostics
-        @node.req_keywords.zip(@f_args.req_keywords) do |name, f_vtx|
-          changes.add_edge(genv, a_args.get_keyword_arg(genv, changes, name), f_vtx)
-        end
-
-        @node.opt_keywords.zip(@f_args.opt_keywords).each do |name, f_vtx|
-          changes.add_edge(genv, a_args.get_keyword_arg(genv, changes, name), f_vtx)
-        end
-
-        if @node.rest_keywords
-          named_keys = @node.req_keywords + @node.opt_keywords
-          a_args.keywords.each_type do |kw_ty|
-            case kw_ty
-            when Type::Record
-              rest_fields = kw_ty.fields.reject {|key, _| named_keys.include?(key) }
-              base = kw_ty.base_type(genv)
-              rest_record = Type::Record.new(genv, rest_fields, base)
-              changes.add_edge(genv, Source.new(rest_record), @f_args.rest_keywords)
-            when Type::Hash, Type::Instance
-              changes.add_edge(genv, Source.new(kw_ty), @f_args.rest_keywords)
-            end
-          end
-        end
-      end
-
-      return true
-    end
-
-    def normalize_keyword_hash_argument_for_def(a_args)
-      return a_args unless a_args.keywords
-      return a_args if @node.no_keywords
-      return a_args if @node.rest_keywords
-      return a_args unless @node.req_keywords.empty? && @node.opt_keywords.empty?
-
-      a_args.with_keywords_as_last_positional_hash
+      @f_args.pass_arguments(changes, genv, a_args, @node)
     end
 
     def call(changes, genv, a_args, ret)
-      a_args = normalize_keyword_hash_argument_for_def(a_args)
+      a_args = a_args.with_keywords_normalized_for(@node)
       if pass_arguments(changes, genv, a_args)
         if @node.is_a?(AST::DefNode)
           @node.body.lenv.forward_args&.accept_actual_arguments(genv, changes, a_args)
@@ -985,7 +842,7 @@ module TypeProf::Core
       end
     end
 
-    def show(output_parameter_names)
+    def show(output_parameter_names, ret: nil)
       block_show = []
       if @record_block.used
         blk_f_args = @record_block.f_args.map {|arg| arg.show }.join(", ")
@@ -1036,7 +893,7 @@ module TypeProf::Core
       args = args.join(", ")
       s = args.empty? ? [] : ["(#{ args })"]
       s << "#{ block_show.sort.join(" | ") }" unless block_show.empty?
-      s << "-> #{ @mid == :initialize ? "void" : @ret.show }"
+      s << "-> #{ ret || (@mid == :initialize ? "void" : @ret.show) }"
       s.join(" ")
     end
   end
@@ -1127,7 +984,7 @@ module TypeProf::Core
             ty_env = Type.default_param_map(genv, orig_ty)
             if ty.is_a?(Type::Instance)
               ty.mod.type_params.zip(ty.args) do |(param, default_ty), arg|
-                ty_env[param] = arg || (default_ty ? default_ty.covariant_vertex(genv, changes, ty_env) : Source.new)
+                ty_env[param] = arg || (default_ty ? default_ty.covariant_vertex(genv, changes, ty_env) : genv.untyped_arg)
               end
             end
             mdecl.resolve_overloads(changes, genv, @node, ty_env, a_args, @ret) do |method_type|
@@ -1170,6 +1027,8 @@ module TypeProf::Core
         next if orig_ty == genv.bot_type
         if @mid == :"*super"
           mid = @node.lenv.cref.mid
+          # Outside a method or in a define_method block, the method is unknown
+          next unless mid
           skip = true
         else
           mid = @mid
@@ -1236,7 +1095,7 @@ module TypeProf::Core
         if prep_decl.is_a?(AST::SigPrependNode) && prep_mod.type_params
           prep_ty = genv.get_instance_type(prep_mod, prep_decl.args, changes, base_ty_env, ty)
         else
-          type_params = prep_mod.type_params.map { Source.new() } # TODO: better support
+          type_params = prep_mod.type_params.map { genv.untyped_arg } # TODO: better support
           prep_ty = Type::Instance.new(genv, prep_mod, type_params)
         end
 
@@ -1291,7 +1150,7 @@ module TypeProf::Core
         if inc_decl.is_a?(AST::SigIncludeNode) && inc_mod.type_params
           inc_ty = genv.get_instance_type(inc_mod, inc_decl.args, changes, base_ty_env, ty)
         else
-          type_params = inc_mod.type_params.map { Source.new() } # TODO: better support
+          type_params = inc_mod.type_params.map { genv.untyped_arg } # TODO: better support
           inc_ty = Type::Instance.new(genv, inc_mod, type_params)
         end
 
@@ -1322,7 +1181,7 @@ module TypeProf::Core
         if ext_decl.is_a?(AST::SigExtendNode) && ext_mod.type_params
           ext_ty = genv.get_instance_type(ext_mod, ext_decl.args, changes, base_ty_env, ty)
         else
-          type_params = ext_mod.type_params.map { Source.new() } # TODO: better support
+          type_params = ext_mod.type_params.map { genv.untyped_arg } # TODO: better support
           ext_ty = Type::Instance.new(genv, ext_mod, type_params)
         end
 
@@ -1351,6 +1210,8 @@ module TypeProf::Core
         base_ty = ty.base_type(genv)
         singleton = base_ty.is_a?(Type::Singleton)
         mod = base_ty.mod
+        # Every class descends from Object, so this would only find unrelated methods
+        next if mod.cpath.empty?
         mod.each_descendant do |desc_mod|
           next if mod == desc_mod
           me = desc_mod.get_method(singleton, @mid)

data/lib/typeprof/core/service.rb

@@ -55,10 +55,15 @@ module TypeProf::Core
     end
 
     def update_rb_file(path, code)
+      code = File.binread(path) unless code
+      update_rb_ast(path, Prism.parse(code))
+    end
+
+    # path is used only as a key to find the previous analysis; the file is not read.
+    def update_rb_ast(path, parse_result)
       prev_node = @rb_text_nodes[path]
 
-      code = File.read(path) unless code
-      node = AST.parse_rb(path, code, @options[:position_encoding])
+      node = AST.build_rb(path, parse_result, @options[:position_encoding])
       return false unless node
 
       node.diff(@rb_text_nodes[path]) if prev_node
@@ -117,7 +122,8 @@ module TypeProf::Core
     def update_rbs_file(path, code)
       prev_decls = @rbs_text_nodes[path]
 
-      code = File.read(path) unless code
+      code = File.read(path, encoding: "UTF-8") unless code
+      return false unless code.valid_encoding?
       begin
         decls = AST.parse_rbs(path, code, @options[:position_encoding])
       rescue RBS::ParsingError
@@ -515,6 +521,14 @@ module TypeProf::Core
                         !@genv.resolve_method(node.static_cpath, mdef.singleton, mdef.mid).defs.empty?
                 out << "  " * stack.size + "def #{ mdef.singleton ? "self." : "" }#{ mdef.mid }: " + mdef.show(@options[:output_parameter_names])
               end
+              if node.is_a?(AST::StructNewNode) && node.kind == :struct &&
+                 @genv.resolve_method(node.static_cpath, true, :[]).defs.empty?
+                # Struct.[] takes the same arguments as the initialize it reaches
+                init_mdef = @genv.resolve_method(node.static_cpath, false, :initialize).defs.to_a.first ||
+                            @genv.resolve_method(node.struct_base_cpath, false, :initialize).defs.to_a.first
+                ret = Type::Instance.new(@genv, mod, []).show
+                out << "  " * stack.size + "def self.[]: " + init_mdef.show(@options[:output_parameter_names], ret:)
+              end
             else
               stack.pop
               out << "  " * stack.size + "end"
@@ -581,7 +595,7 @@ module TypeProf::Core
           i += 1
         end
 
-        res = update_file(file, File.read(file))
+        res = update_file(file, nil)
 
         if res
           true

data/lib/typeprof/core/type.rb

@@ -48,7 +48,7 @@ module TypeProf::Core
 
     def self.default_param_map(genv, ty)
       ty = ty.base_type(genv)
-      instance_ty = ty.is_a?(Type::Instance) ? ty : Type::Instance.new(genv, ty.mod, []) # TODO: type params
+      instance_ty = ty.is_a?(Type::Instance) ? ty : ty.get_instance_type(genv)
       singleton_ty = ty.is_a?(Type::Instance) ? Type::Singleton.new(genv, ty.mod) : ty
       {
         "*self": Source.new(ty),
@@ -77,7 +77,7 @@ module TypeProf::Core
 
       def get_instance_type(genv)
         params = @mod.type_params
-        Instance.new(genv, @mod, params ? params.map { Source.new } : []) # TODO: respect param_default_types
+        Instance.new(genv, @mod, params ? params.map { genv.untyped_arg } : []) # TODO: respect param_default_types
       end
     end
 

data/lib/typeprof/lsp/util.rb

@@ -1,6 +1,6 @@
 module TypeProf::LSP
   def self.load_json_with_comments(path, **opts)
-    json = File.read(path)
+    json = File.read(path, encoding: "UTF-8")
 
     state = :normal
     last_comma_index = nil

data/lib/typeprof/version.rb

@@ -1,3 +1,3 @@
 module TypeProf
-  VERSION = "0.33.0"
+  VERSION = "0.33.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: typeprof
 version: !ruby/object:Gem::Version
-  version: 0.33.0
+  version: 0.33.2
 platform: ruby
 authors:
 - Yusuke Endoh
@@ -118,7 +118,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.16
+rubygems_version: 4.0.20
 specification_version: 4
 summary: TypeProf is a type analysis tool for Ruby code based on abstract interpretation
 test_files: []