typeprof 0.31.1 → 0.33.0

data/lib/typeprof/core/service.rb

@@ -7,7 +7,7 @@ module TypeProf::Core
       @rbs_text_nodes = {}
 
       @genv = GlobalEnv.new
-      @genv.load_core_rbs(load_rbs_declarations(@options[:rbs_collection]).declarations)
+      @genv.load_core_rbs(load_rbs_declarations(@options[:rbs_collection]).declarations, @options[:position_encoding])
 
       Builtin.new(genv).deploy
     end
@@ -38,12 +38,12 @@ module TypeProf::Core
     end
 
     def add_workspace(rb_folder, rbs_folder)
-      Dir.glob(File.expand_path(rb_folder + "/**/*.{rb,rbs}")) do |path|
-        update_file(path, nil)
-      end
-      Dir.glob(File.expand_path(rbs_folder + "/**/*.{rb,rbs}")) do |path|
-        update_file(path, nil)
-      end
+      # Analyze RBS files first so that type declarations are available during RB type inference
+      all_files = [rb_folder, rbs_folder].flat_map { |folder| Dir.glob(File.expand_path(folder + "/**/*.{rb,rbs}")) }
+      rbs_files, rb_files = separate_rbs_and_rb(all_files.uniq)
+
+      rbs_files.each { |path| update_rbs_file(path, nil) }
+      rb_files.each { |path| update_rb_file(path, nil) }
     end
 
     def update_file(path, code)
@@ -58,7 +58,7 @@ module TypeProf::Core
       prev_node = @rb_text_nodes[path]
 
       code = File.read(path) unless code
-      node = AST.parse_rb(path, code)
+      node = AST.parse_rb(path, code, @options[:position_encoding])
       return false unless node
 
       node.diff(@rb_text_nodes[path]) if prev_node
@@ -76,13 +76,13 @@ module TypeProf::Core
       if prev_node
         live_vtxs = []
         node.get_vertexes(live_vtxs)
-        set = Set[]
+        set = Set.empty
         live_vtxs.uniq.each {|vtx| set << vtx }
         live_vtxs = set
 
         dead_vtxs = []
         prev_node.get_vertexes(dead_vtxs)
-        set = Set[]
+        set = Set.empty
         dead_vtxs.uniq.each {|vtx| set << vtx }
         dead_vtxs = set
 
@@ -93,7 +93,7 @@ module TypeProf::Core
 
         global_vtxs = []
         @genv.get_vertexes(global_vtxs)
-        set = Set[]
+        set = Set.empty
         global_vtxs.uniq.each {|vtx| set << vtx }
         global_vtxs = set
 
@@ -119,7 +119,7 @@ module TypeProf::Core
 
       code = File.read(path) unless code
       begin
-        decls = AST.parse_rbs(path, code)
+        decls = AST.parse_rbs(path, code, @options[:position_encoding])
       rescue RBS::ParsingError
         return false
       end
@@ -203,11 +203,20 @@ module TypeProf::Core
         if node.ret
           ty_defs = []
           node.ret.types.map do |ty, _source|
-            if ty.is_a?(Type::Instance)
-              ty.mod.module_decls.each do |mdecl|
-                # TODO
+            mod = case ty
+                  when Type::Instance, Type::Singleton
+                    ty.mod
+                  else
+                    base = ty.base_type(@genv)
+                    base.mod if base.is_a?(Type::Instance)
+                  end
+
+            if mod
+              mod.module_decls.each do |mdecl|
+                decl_path = mdecl.lenv.path
+                ty_defs << [decl_path, mdecl.code_range] if decl_path
               end
-              ty.mod.module_defs.each do |mdef_node|
+              mod.module_defs.each do |mdef_node|
                 ty_defs << [mdef_node.lenv.path, mdef_node.code_range]
               end
             end
@@ -396,7 +405,9 @@ module TypeProf::Core
                     break
                   end
                 end
-                yield mid, "#{ mod.cpath.join("::" )}#{ singleton ? "." : "#" }#{ mid } : #{ sig }" if sig
+                # The base class has no name to show
+                owner = mod.cpath.last == AST::StructNewNode::BASE_CNAME ? base_ty.mod : mod
+                yield mid, "#{ owner.cpath.join("::" )}#{ singleton ? "." : "#" }#{ mid } : #{ sig }" if sig
               end
             end
           end
@@ -405,15 +416,55 @@ module TypeProf::Core
       end
     end
 
+    def format_declared_const_path(cpath, stack)
+      scope_cpath =
+        stack.reverse_each.find do |entry|
+          (entry.is_a?(AST::ClassNode) || entry.is_a?(AST::ModuleNode)) &&
+            entry.static_cpath &&
+            !entry.static_cpath.empty?
+        end&.static_cpath
+
+      return cpath.join("::") unless scope_cpath
+      return cpath.join("::") unless cpath[0, scope_cpath.size] == scope_cpath
+
+      rel_cpath = cpath.drop(scope_cpath.size)
+      rel_cpath.empty? ? cpath.join("::") : rel_cpath.join("::")
+    end
+
+    def format_superclass_path(node, superclass)
+      sc_path = superclass.show_cpath
+
+      if node.is_a?(AST::ClassNode) && node.superclass_cpath
+        sc_node = node.superclass_cpath
+        if superclass_source_is_toplevel?(sc_node)
+          return "::#{ sc_path }"
+        end
+
+        if node.static_cpath && node.static_cpath.size > 1 &&
+           superclass.cpath == [node.static_cpath.last]
+          return "::#{ sc_path }"
+        end
+      end
+
+      sc_path
+    end
+
+    def superclass_source_is_toplevel?(const_node)
+      return false unless const_node.is_a?(AST::ConstantReadNode)
+      return true if const_node.toplevel
+      const_node.cbase ? superclass_source_is_toplevel?(const_node.cbase) : false
+    end
+
     def dump_declarations(path)
       stack = []
       out = []
+      seen_consts = Set.empty
       @rb_text_nodes[path]&.traverse do |event, node|
         case node
         when AST::ModuleNode
           if node.static_cpath
             if event == :enter
-              out << "  " * stack.size + "module #{ node.static_cpath.join("::") }"
+              out << "  " * stack.size + "module #{ format_declared_const_path(node.static_cpath, stack) }"
               if stack == [:toplevel]
                 out << "end"
                 stack.pop
@@ -424,18 +475,22 @@ module TypeProf::Core
               out << "  " * stack.size + "end"
             end
           end
-        when AST::ClassNode, AST::SingletonClassNode
+        when AST::ClassNode, AST::SingletonClassNode, AST::StructNewNode
           if node.static_cpath
             next if stack.any? { node.is_a?(AST::SingletonClassNode) && (_1.is_a?(AST::ClassNode) || _1.is_a?(AST::ModuleNode)) && node.static_cpath == _1.static_cpath }
 
             if event == :enter
-              s = "class #{ node.static_cpath.join("::") }"
+              s = "class #{ format_declared_const_path(node.static_cpath, stack) }"
               mod = @genv.resolve_cpath(node.static_cpath)
               superclass = mod.superclass
+              # The base class is not shown; its members are printed inline
+              while superclass && superclass.cpath.last == AST::StructNewNode::BASE_CNAME
+                superclass = superclass.superclass
+              end
               if superclass == nil
                 s << " # failed to identify its superclass"
               elsif superclass.cpath != []
-                s << " < #{ superclass.show_cpath }"
+                s << " < #{ format_superclass_path(node, superclass) }"
               end
               if stack == [:toplevel]
                 out << "end"
@@ -448,6 +503,18 @@ module TypeProf::Core
                   out << "  " * stack.size + "include #{ inc_mod.show_cpath }"
                 end
               end
+              mod.extended_modules.each do |ext_def, ext_mod|
+                if ext_def.is_a?(AST::ConstantReadNode) && ext_def.lenv.path == path
+                  out << "  " * stack.size + "extend #{ ext_mod.show_cpath }"
+                end
+              end
+              # Output method definitions from meta nodes (StructNewNode etc.)
+              node.boxes(:mdef) do |mdef|
+                # A user-written method overrides the generated one
+                next if node.is_a?(AST::StructNewNode) &&
+                        !@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
             else
               stack.pop
               out << "  " * stack.size + "end"
@@ -456,7 +523,14 @@ module TypeProf::Core
         when AST::ConstantWriteNode
           if node.static_cpath
             if event == :enter
-              out << "  " * stack.size + "#{ node.static_cpath.join("::") }: #{ node.ret.show }"
+              unless seen_consts.include?(node.static_cpath)
+                seen_consts << node.static_cpath
+                cdef = @genv.resolve_const(node.static_cpath)
+                # Use the assigned value for a single write so a same-named class
+                # or module (e.g. declared in RBS) is not mixed in; union the types otherwise.
+                ret = cdef.defs.size > 1 ? cdef.vtx : node.ret
+                out << "  " * stack.size + "#{ format_declared_const_path(node.static_cpath, stack) }: #{ ret.show }"
+              end
             end
           end
         else
@@ -496,10 +570,14 @@ module TypeProf::Core
         output.puts
       end
 
+      # Analyze RBS files first so that type declarations are available during RB type inference
+      rbs_files, rb_files = separate_rbs_and_rb(files)
+      sorted_files = rbs_files + rb_files
+
       i = 0
-      show_files = files.select do |file|
+      show_files = sorted_files.select do |file|
         if @options[:display_indicator]
-          $stderr << "\r[%d/%d] %s\e[K" % [i, files.size, file]
+          $stderr << "\r[%d/%d] %s\e[K" % [i, sorted_files.size, file]
           i += 1
         end
 
@@ -532,6 +610,244 @@ module TypeProf::Core
         end
         output.puts dump_declarations(file)
       end
+
+      if @options[:output_stats]
+        rb_files = show_files.reject {|f| File.extname(f) == ".rbs" }
+        stats = collect_stats(rb_files)
+        output.puts
+        output.puts format_stats(stats)
+      end
+    end
+
+    def collect_stats(files)
+      file_stats = []
+
+      files.each do |path|
+        methods = []
+        constants = []
+        seen_ivars = Set.empty
+        ivars = []
+        seen_cvars = Set.empty
+        cvars = []
+        seen_gvars = Set.empty
+        gvars = []
+
+        @rb_text_nodes[path]&.traverse do |event, node|
+          next unless event == :enter
+
+          node.boxes(:mdef) do |mdef|
+            param_slots = []
+            f = mdef.f_args
+            [f.req_positionals, f.opt_positionals, f.post_positionals, f.req_keywords, f.opt_keywords].each do |ary|
+              ary.each {|vtx| param_slots << classify_vertex(vtx) }
+            end
+            [f.rest_positionals, f.rest_keywords].each do |vtx|
+              param_slots << classify_vertex(vtx) if vtx
+            end
+
+            is_initialize = mdef.mid == :initialize
+            ret_slots = is_initialize ? [] : [classify_vertex(mdef.ret)]
+
+            blk = mdef.record_block
+            block_param_slots = []
+            block_ret_slots = []
+            if blk.used
+              blk.f_args.each {|vtx| block_param_slots << classify_vertex(vtx) }
+              block_ret_slots << classify_vertex(blk.ret)
+            end
+
+            methods << {
+              mid: mdef.mid,
+              singleton: mdef.singleton,
+              param_slots: param_slots,
+              ret_slots: ret_slots,
+              block_param_slots: block_param_slots,
+              block_ret_slots: block_ret_slots,
+            }
+          end
+
+          if node.is_a?(AST::ConstantWriteNode) && node.static_cpath
+            constants << classify_vertex(node.ret)
+          end
+
+          if node.is_a?(AST::InstanceVariableWriteNode)
+            scope = node.lenv.cref.scope_level
+            if scope == :class || scope == :instance
+              key = [node.lenv.cref.cpath, scope == :class, node.var]
+              unless seen_ivars.include?(key)
+                seen_ivars << key
+                ve = @genv.resolve_ivar(key[0], key[1], key[2])
+                ivars << classify_vertex(ve.vtx)
+              end
+            end
+          end
+
+          if node.is_a?(AST::ClassVariableWriteNode)
+            key = [node.lenv.cref.cpath, node.var]
+            unless seen_cvars.include?(key)
+              seen_cvars << key
+              ve = @genv.resolve_cvar(key[0], key[1])
+              cvars << classify_vertex(ve.vtx)
+            end
+          end
+
+          if node.is_a?(AST::GlobalVariableWriteNode)
+            unless seen_gvars.include?(node.var)
+              seen_gvars << node.var
+              ve = @genv.resolve_gvar(node.var)
+              gvars << classify_vertex(ve.vtx)
+            end
+          end
+        end
+
+        file_stats << {
+          path: path,
+          methods: methods,
+          constants: constants,
+          ivars: ivars,
+          cvars: cvars,
+          gvars: gvars,
+        }
+      end
+
+      file_stats
+    end
+
+    def classify_vertex(vtx)
+      vtx.types.empty? ? :untyped : :typed
+    end
+
+    def format_stats(stats)
+      total_methods = 0
+      fully_typed = 0
+      partially_typed = 0
+      fully_untyped = 0
+
+      slot_categories = %i[param ret blk_param blk_ret const ivar cvar gvar]
+      typed = Hash.new(0)
+      untyped = Hash.new(0)
+
+      file_summaries = []
+
+      stats.each do |file|
+        f_typed = 0
+        f_total = 0
+
+        file[:methods].each do |m|
+          total_methods += 1
+
+          method_slot_keys = %i[param_slots ret_slots block_param_slots block_ret_slots]
+          category_keys = %i[param ret blk_param blk_ret]
+
+          all_slots = method_slot_keys.flat_map {|k| m[k] }
+
+          method_slot_keys.zip(category_keys) do |slot_key, cat|
+            m[slot_key].each do |s|
+              if s == :typed
+                typed[cat] += 1
+              else
+                untyped[cat] += 1
+              end
+            end
+          end
+
+          if all_slots.empty? || all_slots.all? {|s| s == :typed }
+            fully_typed += 1
+          elsif all_slots.none? {|s| s == :typed }
+            fully_untyped += 1
+          else
+            partially_typed += 1
+          end
+
+          f_typed += all_slots.count(:typed)
+          f_total += all_slots.size
+        end
+
+        %i[constants ivars cvars gvars].zip(%i[const ivar cvar gvar]) do |data_key, cat|
+          file[data_key].each do |s|
+            f_total += 1
+            if s == :typed
+              typed[cat] += 1
+              f_typed += 1
+            else
+              untyped[cat] += 1
+            end
+          end
+        end
+
+        if f_total > 0
+          file_summaries << {
+            path: file[:path],
+            methods: file[:methods].size,
+            typed: f_typed,
+            total: f_total,
+          }
+        end
+      end
+
+      overall_typed = slot_categories.sum {|c| typed[c] }
+      overall_untyped = slot_categories.sum {|c| untyped[c] }
+      overall_total = overall_typed + overall_untyped
+
+      labels = {
+        param: "Parameter slots",
+        ret: "Return slots",
+        blk_param: "Block parameter slots",
+        blk_ret: "Block return slots",
+        const: "Constants",
+        ivar: "Instance variables",
+        cvar: "Class variables",
+        gvar: "Global variables",
+      }
+
+      lines = []
+      lines << "# TypeProf Evaluation Statistics"
+      lines << "#"
+      lines << "# Total methods: #{ total_methods }"
+      lines << "#   Fully typed:     #{ fully_typed }"
+      lines << "#   Partially typed: #{ partially_typed }"
+      lines << "#   Fully untyped:   #{ fully_untyped }"
+
+      slot_categories.each do |cat|
+        total = typed[cat] + untyped[cat]
+        lines << "#"
+        lines << "# #{ labels[cat] }: #{ total }"
+        lines << "#   Typed:   #{ typed[cat] } (#{ pct(typed[cat], total) })"
+        lines << "#   Untyped: #{ untyped[cat] } (#{ pct(untyped[cat], total) })"
+      end
+
+      lines << "#"
+      lines << "# Overall: #{ overall_typed }/#{ overall_total } typed (#{ pct(overall_typed, overall_total) })"
+      lines << "#          #{ overall_untyped }/#{ overall_total } untyped (#{ pct(overall_untyped, overall_total) })"
+
+      if file_summaries.size > 1
+        lines << "#"
+        lines << "# Per-file breakdown:"
+        file_summaries.each do |fs|
+          lines << "#   #{ fs[:path] }: #{ fs[:methods] } methods, #{ fs[:typed] }/#{ fs[:total] } typed (#{ pct(fs[:typed], fs[:total]) })"
+        end
+      end
+
+      lines.join("\n")
+    end
+
+    def pct(n, total)
+      return "0.0%" if total == 0
+      "#{ (n * 100.0 / total).round(1) }%"
+    end
+
+    private
+
+    def separate_rbs_and_rb(files)
+      files
+        .reject { |file| exclude_files.include?(File.expand_path(file)) }
+        .partition { |file| File.extname(file) == ".rbs" }
+    end
+
+    def exclude_files
+      @exclude_files ||= (@options[:exclude_patterns] || []).each_with_object(::Set.new) { |pattern, set|
+        Dir.glob(File.expand_path(pattern)) { |path| set << path }
+      }
     end
   end
 end

data/lib/typeprof/core/type.rb

@@ -16,16 +16,33 @@ module TypeProf::Core
     end
 
     def self.extract_hash_value_type(s)
-      if s.start_with?("Hash[") && s.end_with?("]")
+      begin
         type = RBS::Parser.parse_type(s)
+        collect_hash_value_types(type).uniq.join(" | ")
+      rescue
+        s
+      end
+    end
 
-        if type.is_a?(RBS::Types::Union)
-          type.types.map {|t| t.args[1].to_s }.join(" | ")
+    # Returns an array of value type strings from hash-like types
+    def self.collect_hash_value_types(type)
+      case type
+      when RBS::Types::Record
+        # Extract value types from record fields
+        # all_fields returns { key => [type, required] }
+        type.all_fields.values.map { |t, _required| t.to_s }
+      when RBS::Types::ClassInstance
+        # Handle Hash[K, V]
+        if type.name.name == :Hash && type.args.size == 2
+          [type.args[1].to_s]
         else
-          type.args[1].to_s
+          [type.to_s]
         end
+      when RBS::Types::Union
+        # Handle union of types - extract value types from all hash-like types
+        type.types.flat_map { |t| collect_hash_value_types(t) }
       else
-        s
+        [type.to_s]
       end
     end
 
@@ -60,7 +77,7 @@ module TypeProf::Core
 
       def get_instance_type(genv)
         params = @mod.type_params
-        Instance.new(genv, @mod, params ? params.map { Source.new } : [])
+        Instance.new(genv, @mod, params ? params.map { Source.new } : []) # TODO: respect param_default_types
       end
     end
 
@@ -188,7 +205,24 @@ module TypeProf::Core
       end
 
       def show
-        "<Proc>"
+        "Proc"
+      end
+    end
+
+    class Method < Type
+      def initialize(genv, recv_ty, mid)
+        @recv_ty = recv_ty
+        @mid = mid
+      end
+
+      attr_reader :recv_ty, :mid
+
+      def base_type(genv)
+        genv.method_type
+      end
+
+      def show
+        "Method"
       end
     end
 

data/lib/typeprof/core/util.rb

@@ -6,6 +6,10 @@ module TypeProf::Core
       new(h)
     end
 
+    def self.empty
+      new(Hash.new(false))
+    end
+
     def initialize(hash)
       @hash = hash
     end
@@ -77,5 +81,7 @@ module TypeProf::Core
       end
       q.text "]"
     end
+
+    EMPTY = empty.freeze
   end
 end

data/lib/typeprof/lsp/messages.rb

@@ -56,6 +56,10 @@ module TypeProf::LSP
   class Message::Initialize < Message
     METHOD = "initialize" # request (required)
     def run
+      # Must negotiate encoding before add_workspaces so newly created Services honor it.
+      client_encodings = @params.dig(:capabilities, :general, :positionEncodings)
+      @server.negotiate_position_encoding(client_encodings)
+
       folders = @params[:workspaceFolders].map do |folder|
         folder => { uri:, }
         @server.uri_to_path(uri)
@@ -65,6 +69,7 @@ module TypeProf::LSP
 
       respond(
         capabilities: {
+          positionEncoding: @server.lsp_position_encoding,
           textDocumentSync: {
             openClose: true,
             change: 2, # Incremental

data/lib/typeprof/lsp/server.rb

@@ -21,8 +21,8 @@ module TypeProf::LSP
       new(core_options, reader, writer).run
     end
 
-    def self.start_socket(core_options)
-      Socket.tcp_server_sockets("localhost", nil) do |servs|
+    def self.start_socket(core_options, port = 0)
+      Socket.tcp_server_sockets("localhost", port) do |servs|
         serv = servs[0].local_address
         $stdout << JSON.generate({
           host: serv.ip_address,
@@ -47,6 +47,15 @@ module TypeProf::LSP
       end
     end
 
+    # see: https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#textDocuments
+    LSP_POSITION_ENCODINGS = {
+      Encoding::UTF_8 => "utf-8",
+      Encoding::UTF_16LE => "utf-16",
+      Encoding::UTF_32LE => "utf-32",
+    }.freeze
+
+    private_constant :LSP_POSITION_ENCODINGS
+
     def initialize(core_options, reader, writer, url_schema: nil)
       @core_options = core_options
       @cores = {}
@@ -62,9 +71,29 @@ module TypeProf::LSP
       @diagnostic_severity = :error
     end
 
-    attr_reader :open_texts
+    attr_reader :open_texts, :position_encoding
     attr_accessor :signature_enabled
 
+    # Pick the first mutually-supported encoding from the client's preference-ordered list
+    # and store it. Falls back to UTF-16LE (mandatory per LSP 3.17 spec).
+    def negotiate_position_encoding(client_encodings)
+      @position_encoding = pick_position_encoding(client_encodings)
+    end
+
+    def lsp_position_encoding
+      LSP_POSITION_ENCODINGS.fetch(@position_encoding)
+    end
+
+    def pick_position_encoding(client_encodings)
+      return Encoding::UTF_16LE unless client_encodings.is_a?(Array)
+      client_encodings.each do |enc|
+        encoding = LSP_POSITION_ENCODINGS.key(enc)
+        return encoding if encoding
+      end
+      Encoding::UTF_16LE
+    end
+    private :pick_position_encoding
+
     #: (String) -> String
     def path_to_uri(path)
       @url_schema + File.expand_path(path).split("/").map {|s| CGI.escapeURIComponent(s) }.join("/")
@@ -104,9 +133,11 @@ module TypeProf::LSP
                 puts "unknown severity: #{ severity }"
               end
             end
+            @core_options[:exclude_patterns] = conf[:exclude] if conf[:exclude]
+            service_options = @core_options.merge(position_encoding: @position_encoding)
             conf[:analysis_unit_dirs].each do |dir|
               dir = File.expand_path(dir, path)
-              core = @cores[dir] = TypeProf::Core::Service.new(@core_options)
+              core = @cores[dir] = TypeProf::Core::Service.new(service_options)
               core.add_workspace(dir, @rbs_dir)
             end
           else

data/lib/typeprof/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: typeprof
 version: !ruby/object:Gem::Version
-  version: 0.31.1
+  version: 0.33.0
 platform: ruby
 authors:
 - Yusuke Endoh
@@ -53,6 +53,7 @@ files:
 - bin/typeprof
 - doc/doc.ja.md
 - doc/doc.md
+- doc/report_guide.md
 - lib/typeprof.rb
 - lib/typeprof/cli.rb
 - lib/typeprof/cli/cli.rb
@@ -117,7 +118,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.16
 specification_version: 4
 summary: TypeProf is a type analysis tool for Ruby code based on abstract interpretation
 test_files: []