typeprof 0.30.1 → 0.31.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5f42086b6df655b0df5ea0e11633500c15735fc81713833c477536138de6cd70
-  data.tar.gz: 8e2c1bbd37db3e87fea65136cdbb78c31853ed0db434aeee76e9066cb15c125a
+  metadata.gz: af1ca7b849fb94f4a39e31b3e1b2c45b557936f68099002d69a25d09e2c76b51
+  data.tar.gz: cf3d5e1e88614b53a354f874ed0560e6b6bd965468e3be5f024594cf633e4b8d
 SHA512:
-  metadata.gz: 89feb1071cf88fb006b7c04312d2ef576e940023e096b0fed10178b1b89f70301cf50f8d53343983e33760f258d96e2c9244de44bec55e1437bf0857951d4b91
-  data.tar.gz: 4f63149902b7b926df8159a1d2dc18a7472d15e07df9a441483b1e401a313c9b0ddf201ffdaa8eaccda4115bf3ae88d1ec282e8c66a11230b342275842809ba4
+  metadata.gz: 84eec1b1d33b57ba5022bacab1f194a5942789282c3e19fcb32f2b4d3168f4ff826b5d176982a5ba36b7bbe3bba9f0fef5a0cb927811cba89b759ef337ab72f6
+  data.tar.gz: b196e236660ab1814456fd9586e122e135e7773e27c3f49151e6c7a18a015b8ac0562a08c1b740a1d8bcfcd0005c27aefa2dabbaf98085230fcff73933f8028b

data/README.md

@@ -2,12 +2,31 @@
 
 An experimental type-level Ruby interpreter for testing and understanding Ruby code.
 
+## Installation
+
+Install via RubyGems.
+
+```sh
+$ gem install typeprof
+```
+
+### Requirements
+
+TypeProf supports Ruby 3.3 or later.
+
+## Quick start
+
+1. Install VSCode [Ruby TypeProf](https://marketplace.visualstudio.com/items?itemName=mame.ruby-typeprof) extension: `code --install-extension mame.ruby-typeprof`
+2. Run `typeprof --init` in your project root to create `typeprof.conf.jsonc` file.
+    Other options are available. See [typeprof.conf.jsonc](typeprof.conf.jsonc) for details.
+
+3. Reopen your project in VSCode.
+
 ## Development
 
-1. Install Ruby 3.3 or later.
-2. Git clone this repository: `git clone https://github.com/ruby/typeprof.git`
-3. Install VSCode extension: `code --install-extension mame.ruby-typeprof`
-4. Open the repository in VSCode: `code typeprof`
+1. Git clone this repository: `git clone https://github.com/ruby/typeprof.git`
+2. Install VSCode [Ruby TypeProf](https://marketplace.visualstudio.com/items?itemName=mame.ruby-typeprof) extension: `code --install-extension mame.ruby-typeprof`
+3. Open the repository in VSCode: `code typeprof`
 
 ### Testing
 

data/lib/typeprof/cli/cli.rb

@@ -11,6 +11,7 @@ module TypeProf::CLI
 
       output = nil
       rbs_collection_path = nil
+      initialize_config_file = false
 
       opt.separator ""
       opt.separator "Options:"
@@ -39,6 +40,7 @@ module TypeProf::CLI
       opt.separator ""
       opt.separator "Advanced options:"
       opt.on("--[no-]stackprof MODE", /\Acpu|wall|object\z/, "Enable stackprof (for debugging purpose)") {|v| cli_options[:stackprof] = v.to_sym }
+      opt.on("--init", 'Generate TypeProf configuration file') {|v| initialize_config_file = true}
 
       opt.separator ""
       opt.separator "LSP options:"
@@ -47,6 +49,11 @@ module TypeProf::CLI
 
       opt.parse!(argv)
 
+      if initialize_config_file
+        generate_config_file
+        exit 0
+      end
+
       if !cli_options[:lsp] && !lsp_options.empty?
         raise OptionParser::InvalidOption.new("lsp options with non-lsp mode")
       end
@@ -101,27 +108,28 @@ module TypeProf::CLI
     attr_reader :core_options, :lsp_options, :cli_options
 
     def run
-      core = TypeProf::Core::Service.new(@core_options)
 
       if @cli_options[:lsp]
-        run_lsp(core)
+        run_lsp
       else
-        run_cli(core)
+        run_cli
       end
     end
 
-    def run_lsp(core)
+    def run_lsp
       if @lsp_options[:stdio]
-        TypeProf::LSP::Server.start_stdio(core)
+        TypeProf::LSP::Server.start_stdio(@core_options)
       else
-        TypeProf::LSP::Server.start_socket(core)
+        TypeProf::LSP::Server.start_socket(@core_options)
       end
     rescue Exception
       puts $!.detailed_message(highlight: false).gsub(/^/, "---")
       raise
     end
 
-    def run_cli(core)
+    def run_cli
+      core = TypeProf::Core::Service.new(@core_options)
+
       puts "typeprof #{ TypeProf::VERSION }" if @cli_options[:display_version]
 
       files = find_files
@@ -174,5 +182,17 @@ module TypeProf::CLI
         StackProf.results
       end
     end
+
+    def generate_config_file
+      exist_dirs = ["app", "lib"].select { |dir| File.exist?(File.join(Dir.pwd, dir)) }
+      File.write('typeprof.conf.jsonc', <<~JSONC, mode: "wx")
+        {
+          "typeprof_version": "experimental",
+          "rbs_dir": "sig/",
+          "analysis_unit_dirs": #{exist_dirs.inspect}
+          // "diagnostic_severity": "warning"
+        }
+      JSONC
+    end
   end
 end

data/lib/typeprof/code_range.rb

@@ -56,16 +56,13 @@ module TypeProf
     end
 
     def self.from_node(node, encoding = Encoding::UTF_16LE)
-      node = node.location if node.is_a?(Prism::Node)
+      node = node.location if node.respond_to?(:location)
       if node.is_a?(Prism::Location)
         pos1 = CodePosition.new(node.start_line, node.start_code_units_column(encoding))
         pos2 = CodePosition.new(node.end_line, node.end_code_units_column(encoding))
-      elsif node.respond_to?(:location)
-        loc = node.location
-        row, col = loc.start_loc
-        pos1 = CodePosition.new(row, col) # TODO: use SPLAT
-        row, col = loc.end_loc
-        pos2 = CodePosition.new(row, col)
+      elsif node.is_a?(RBS::Location)
+        pos1 = CodePosition.new(*node.start_loc)
+        pos2 = CodePosition.new(*node.end_loc)
       else
         p node.class.ancestors
         raise "unknown type: #{ node.class }"
@@ -108,5 +105,10 @@ module TypeProf
     def ==(other)
       @first == other.first && @last == other.last
     end
+
+    def <=>(other)
+      cmp = @first <=> other.first
+      cmp == 0 ? @last <=> other.last : cmp
+    end
   end
 end

data/lib/typeprof/core/ast/base.rb

@@ -9,6 +9,7 @@ module TypeProf::Core
         @ret = nil
 
         @changes = ChangeSet.new(self, nil)
+        @diagnostics = Set[]
       end
 
       attr_reader :lenv
@@ -16,6 +17,7 @@ module TypeProf::Core
       attr_reader :static_ret
       attr_reader :ret
       attr_reader :changes
+      attr_reader :diagnostics
 
       def subnodes = {}
       def attrs = {}
@@ -63,12 +65,12 @@ module TypeProf::Core
       end
 
       def define_copy(genv)
-        @lenv = @prev_node.lenv
+        @lenv = (@prev_node || raise).lenv
         each_subnode do |subnode|
           subnode.define_copy(genv)
         end
         @prev_node.instance_variable_set(:@reused, true)
-        @static_ret = @prev_node.static_ret
+        @static_ret = (@prev_node || raise).static_ret
       end
 
       def define0(genv)
@@ -90,6 +92,7 @@ module TypeProf::Core
         end
       end
 
+      #: (TypeProf::Core::GlobalEnv) -> TypeProf::Core::BasicVertex
       def install(genv)
         @ret = install0(genv)
         @changes.reinstall(genv)
@@ -97,14 +100,19 @@ module TypeProf::Core
       end
 
       def install_copy(genv)
-        @changes.copy_from(@prev_node.changes)
+        @changes.copy_from((@prev_node || raise).changes)
         @changes.reuse(self)
+        (@prev_node || raise).diagnostics.each do |diag|
+          diag.reuse(self)
+          @diagnostics << diag
+        end
         each_subnode do |subnode|
           subnode.install_copy(genv)
         end
-        @ret = @prev_node.ret
+        @ret = (@prev_node || raise).ret
       end
 
+      #: (TypeProf::Core::GlobalEnv) -> untyped
       def install0(_)
         raise "should override"
       end
@@ -116,6 +124,18 @@ module TypeProf::Core
         end
       end
 
+      def narrowings
+        Narrowing::EmptyNarrowings
+      end
+
+      def add_diagnostic(diag)
+        @diagnostics << diag
+      end
+
+      def remove_diagnostic(diag)
+        @diagnostics.delete(diag)
+      end
+
       def diff(prev_node)
         if prev_node.is_a?(self.class) && attrs.all? {|key, attr| attr == prev_node.send(key) }
           raise unless prev_node # annotation
@@ -159,13 +179,10 @@ module TypeProf::Core
         end
       end
 
-      def diagnostics(genv, &blk)
-        @changes.diagnostics.each(&blk)
-        @changes.boxes.each_value do |box|
-          box.diagnostics(genv, &blk)
-        end
+      def each_diagnostic(genv, &blk)
+        @diagnostics.each(&blk)
         each_subnode do |subnode|
-          subnode.diagnostics(genv, &blk)
+          subnode.each_diagnostic(genv, &blk)
         end
       end
 

data/lib/typeprof/core/ast/call.rb

@@ -17,22 +17,28 @@ module TypeProf::Core
         @block_tbl = nil
         @block_f_args = nil
         @block_body = nil
+        @safe_navigation = raw_node.respond_to?(:safe_navigation?) && raw_node.safe_navigation?
+        @anonymous_block_forwarding = false
 
         if raw_args
           args = []
           @splat_flags = []
           raw_args.arguments.each do |raw_arg|
-            if raw_arg.is_a?(Prism::SplatNode)
+            case raw_arg
+            when Prism::SplatNode
               args << raw_arg.expression
               @splat_flags << true
+            when Prism::ForwardingArgumentsNode
+              # TODO: Support forwarding arguments
             else
               args << raw_arg
               @splat_flags << false
             end
           end
-          @positional_args = args.map {|arg| AST.create_node(arg, lenv) }
+          @positional_args = args.map {|arg| arg ? AST.create_node(arg, lenv) : DummyNilNode.new(code_range, lenv) }
 
-          if @positional_args.last.is_a?(TypeProf::Core::AST::HashNode) && @positional_args.last.keywords
+          kw = @positional_args.last
+          if kw.is_a?(TypeProf::Core::AST::HashNode) && kw.keywords
             @keyword_args = @positional_args.pop
           end
         end
@@ -41,7 +47,11 @@ module TypeProf::Core
 
         if raw_block
           if raw_block.type == :block_argument_node
-            @block_pass = AST.create_node(raw_block.expression, lenv)
+            if raw_block.expression
+              @block_pass = AST.create_node(raw_block.expression, lenv)
+            else
+              @anonymous_block_forwarding = true
+            end
           else
             @block_pass = nil
             @block_tbl = raw_block.locals
@@ -51,6 +61,8 @@ module TypeProf::Core
                               raw_block.parameters.parameters.requireds.map {|n| n.is_a?(Prism::MultiTargetNode) ? nil : n.name }
                             when Prism::NumberedParametersNode
                               1.upto(raw_block.parameters.maximum).map { |n| :"_#{n}" }
+                            when Prism::ItParametersNode
+                              [:it]
                             when nil
                               []
                             else
@@ -67,51 +79,63 @@ module TypeProf::Core
 
       attr_reader :recv, :mid, :mid_code_range, :yield
       attr_reader :positional_args, :splat_flags, :keyword_args
-      attr_reader :block_tbl, :block_f_args, :block_body, :block_pass
+      attr_reader :block_tbl, :block_f_args, :block_body, :block_pass, :anonymous_block_forwarding
+      attr_reader :safe_navigation
 
       def subnodes = { recv:, positional_args:, keyword_args:, block_body:, block_pass: }
-      def attrs = { mid:, splat_flags:, block_tbl:, block_f_args:, yield: }
+      def attrs = { mid:, splat_flags:, block_tbl:, block_f_args:, yield:, safe_navigation:, anonymous_block_forwarding: }
 
       def install0(genv)
         recv = @recv ? @recv.install(genv) : @yield ? @lenv.get_var(:"*given_block") : @lenv.get_var(:"*self")
 
+        if @safe_navigation
+          allow_nil = NilFilter.new(genv, self, recv, true).next_vtx
+          recv = NilFilter.new(genv, self, recv, false).next_vtx
+        end
+
         positional_args = @positional_args.map do |arg|
-          arg.install(genv)
+          if arg.is_a?(DummyNilNode)
+            @lenv.get_var(:"*anonymous_rest")
+          else
+            arg.install(genv)
+          end
         end
 
         keyword_args = @keyword_args ? @keyword_args.install(genv) : nil
 
         if @block_body
-          @lenv.locals.each {|var, vtx| @block_body.lenv.locals[var] = vtx }
-          @block_tbl.each {|var| @block_body.lenv.locals[var] = Source.new(genv.nil_type) }
+          block_body = @block_body # kinda type annotationty
+          block_tbl = @block_tbl || raise
+          @lenv.locals.each {|var, vtx| block_body.lenv.locals[var] = vtx }
+          block_tbl.each {|var| block_body.lenv.locals[var] = Source.new(genv.nil_type) }
           @block_body.lenv.locals[:"*self"] = @block_body.lenv.cref.get_self(genv)
 
           blk_f_args = []
           if @block_f_args
             @block_f_args.each do |arg|
-              blk_f_args << @block_body.lenv.new_var(arg, self)
+              blk_f_args << block_body.lenv.new_var(arg, self)
             end
           end
 
           @lenv.locals.each do |var, vtx|
-            @block_body.lenv.set_var(var, vtx)
+            block_body.lenv.set_var(var, vtx)
           end
           vars = []
-          @block_body.modified_vars(@lenv.locals.keys - @block_tbl, vars)
+          @block_body.modified_vars(@lenv.locals.keys - block_tbl, vars)
           vars.uniq!
           vars.each do |var|
             vtx = @lenv.get_var(var)
             nvtx = vtx.new_vertex(genv, self)
             @lenv.set_var(var, nvtx)
-            @block_body.lenv.set_var(var, nvtx)
+            block_body.lenv.set_var(var, nvtx)
           end
 
-          e_ret = @block_body.lenv.locals[:"*expected_block_ret"] = Vertex.new(self)
+          @block_body.lenv.locals[:"*expected_block_ret"] = Vertex.new(self)
           @block_body.install(genv)
-          @block_body.lenv.add_next_box(@changes.add_escape_box(genv, @block_body.ret, e_ret))
+          @block_body.lenv.add_next_box(@changes.add_escape_box(genv, @block_body.ret))
 
           vars.each do |var|
-            @changes.add_edge(genv, @block_body.lenv.get_var(var), @lenv.get_var(var))
+            @changes.add_edge(genv, block_body.lenv.get_var(var), @lenv.get_var(var))
           end
 
           blk_f_ary_arg = Vertex.new(self)
@@ -120,19 +144,27 @@ module TypeProf::Core
           blk_ty = Source.new(Type::Proc.new(genv, block))
         elsif @block_pass
           blk_ty = @block_pass.install(genv)
+        elsif @anonymous_block_forwarding
+          blk_ty = @lenv.get_var(:"*anonymous_block")
         end
 
         a_args = ActualArguments.new(positional_args, @splat_flags, keyword_args, blk_ty)
         box = @changes.add_method_call_box(genv, recv, @mid, a_args, !@recv)
 
-        if @block_body && @block_body.lenv.break_vtx
+        block_body = @block_body
+        if block_body && block_body.lenv.break_vtx
           ret = Vertex.new(self)
           @changes.add_edge(genv, box.ret, ret)
-          @changes.add_edge(genv, @block_body.lenv.break_vtx, ret)
-          ret
+          @changes.add_edge(genv, block_body.lenv.break_vtx, ret)
         else
-          box.ret
+          ret = box.ret
+        end
+
+        if @safe_navigation
+          @changes.add_edge(genv, allow_nil, ret)
         end
+
+        ret
       end
 
       def block_last_stmt_code_range
@@ -158,10 +190,12 @@ module TypeProf::Core
       def modified_vars(tbl, vars)
         subnodes.each do |key, subnode|
           next unless subnode
-          if key == :block_body
-            subnode.modified_vars(tbl - self.block_tbl, vars)
-          elsif subnode.is_a?(AST::Node)
-            subnode.modified_vars(tbl, vars)
+          if subnode.is_a?(AST::Node)
+            if key == :block_body
+              subnode.modified_vars(tbl - self.block_tbl, vars)
+            else
+              subnode.modified_vars(tbl, vars)
+            end
           else
             subnode.each {|n| n.modified_vars(tbl, vars) }
           end
@@ -178,6 +212,33 @@ module TypeProf::Core
         raw_block = raw_node.block
         super(raw_node, recv, mid, mid_code_range, raw_args, nil, raw_block, lenv)
       end
+
+      def narrowings
+        @narrowings ||= begin
+          args = @positional_args
+          case @mid
+          when :is_a?
+            if @recv.is_a?(LocalVariableReadNode) && args && args.size == 1
+              [
+                Narrowing.new({ @recv.var => Narrowing::IsAConstraint.new(args[0], false) }),
+                Narrowing.new({ @recv.var => Narrowing::IsAConstraint.new(args[0], true) })
+              ]
+            elsif @recv.is_a?(InstanceVariableReadNode) && args && args.size == 1
+              [
+                Narrowing.new({ @recv.var => Narrowing::IsAConstraint.new(args[0], false) }),
+                Narrowing.new({ @recv.var => Narrowing::IsAConstraint.new(args[0], true) })
+              ]
+            else
+              super
+            end
+          when :!
+            then_narrowing, else_narrowing = @recv.narrowings
+            [else_narrowing, then_narrowing]
+          else
+            super
+          end
+        end
+      end
     end
 
     class SuperNode < CallBaseNode

data/lib/typeprof/core/ast/const.rb

@@ -17,29 +17,24 @@ module TypeProf::Core
             @cbase = nil
             @toplevel = true
           end
-          # temporarily support old Prism https://bugs.ruby-lang.org/issues/20467
-          if raw_node.respond_to?(:name)
-            @cname = raw_node.name
-            @cname_code_range = TypeProf::CodeRange.from_node(raw_node.name_loc)
-          else
-            @cname = raw_node.child.name
-            @cname_code_range = TypeProf::CodeRange.from_node(raw_node.child.location)
-          end
+          @cname = raw_node.name
+          @cname_code_range = TypeProf::CodeRange.from_node(raw_node.name_loc)
         else
           raise raw_node.type.to_s
         end
+        @strict_const_scope = lenv.strict_const_scope
       end
 
-      attr_reader :cname, :cbase, :toplevel, :cname_code_range
+      attr_reader :cname, :cbase, :toplevel, :cname_code_range, :strict_const_scope
 
-      def attrs = { cname:, toplevel: }
+      def attrs = { cname:, toplevel:, strict_const_scope: }
       def subnodes = { cbase: }
 
       def define0(genv)
         if @cbase
-          ScopedConstRead.new(@cname, @cbase.define(genv))
+          ScopedConstRead.new(@cname, @cbase.define(genv), @strict_const_scope)
         else
-          BaseConstRead.new(genv, @cname, @toplevel ? CRef::Toplevel : @lenv.cref)
+          BaseConstRead.new(genv, @cname, @toplevel ? CRef::Toplevel : @lenv.cref, @strict_const_scope)
         end
       end