typeprof 0.33.1 → 0.33.2

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,7 +55,7 @@ module TypeProf::Core
     end
 
     def update_rb_file(path, code)
-      code = File.read(path) unless code
+      code = File.binread(path) unless code
       update_rb_ast(path, Prism.parse(code))
     end
 
@@ -122,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
@@ -520,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"
@@ -586,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.1"
+  VERSION = "0.33.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: typeprof
 version: !ruby/object:Gem::Version
-  version: 0.33.1
+  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: []