steep 0.49.1 → 0.52.0

data/lib/steep/server/type_check_worker.rb

@@ -135,6 +135,21 @@ module Steep
       end
 
       def handle_job(job)
+        job_path = if job.respond_to?(:path)
+                     if Gem.win_platform?
+                       # FIXME: Sometimes drive letter is missing, using base_dir
+                       if job.path.to_s.start_with?(%r{/[a-z](:|%3A)/}i)
+                         job.path.to_s
+                       else
+                         "/#{project.base_dir.to_s.split("/").first}/#{job.path}"
+                       end
+                     else
+                       job.path.to_s
+                     end
+                   else
+                     nil
+                   end
+
         case job
         when StartTypeCheckJob
           Steep.logger.info { "Processing StartTypeCheckJob for guid=#{job.guid}" }
@@ -149,7 +164,7 @@ module Steep
               writer.write(
                 method: :"textDocument/publishDiagnostics",
                 params: LSP::Interface::PublishDiagnosticsParams.new(
-                  uri: URI.parse(job.path.to_s).tap {|uri| uri.scheme = "file"},
+                  uri: URI.parse(job_path).tap {|uri| uri.scheme = "file"},
                   diagnostics: diagnostics.map {|diagnostic| formatter.format(diagnostic) }.uniq
                 )
               )
@@ -167,7 +182,7 @@ module Steep
               writer.write(
                 method: :"textDocument/publishDiagnostics",
                 params: LSP::Interface::PublishDiagnosticsParams.new(
-                  uri: URI.parse(job.path.to_s).tap {|uri| uri.scheme = "file"},
+                  uri: URI.parse(job_path).tap {|uri| uri.scheme = "file"},
                   diagnostics: diagnostics.map {|diagnostic| formatter.format(diagnostic) }.uniq.compact
                 )
               )
@@ -186,7 +201,7 @@ module Steep
               writer.write(
                 method: :"textDocument/publishDiagnostics",
                 params: LSP::Interface::PublishDiagnosticsParams.new(
-                  uri: URI.parse(job.path.to_s).tap {|uri| uri.scheme = "file"},
+                  uri: URI.parse(job_path).tap {|uri| uri.scheme = "file"},
                   diagnostics: diagnostics.map {|diagnostic| formatter.format(diagnostic) }.uniq.compact
                 )
               )
@@ -268,7 +283,7 @@ module Steep
         line = job.params[:position][:line] + 1
         column = job.params[:position][:character]
 
-        goto_service = Services::GotoService.new(type_check: service)
+        goto_service = Services::GotoService.new(type_check: service, assignment: assignment)
         locations =
           case
           when job.definition?

data/lib/steep/server/worker_process.rb

@@ -18,13 +18,17 @@ module Steep
         @index = index
       end
 
-      def self.spawn_worker(type, name:, steepfile:, options: [], delay_shutdown: false, index: nil)
-        log_level = %w(debug info warn error fatal unknown)[Steep.logger.level]
+      def self.spawn_worker(type, name:, steepfile:, steep_command: "steep", options: [], delay_shutdown: false, index: nil)
+        args = ["--name=#{name}", "--steepfile=#{steepfile}"]
+        args << (%w(debug info warn error fatal unknown)[Steep.logger.level].yield_self {|log_level| "--log-level=#{log_level}" })
+        if Steep.log_output.is_a?(String)
+          args << "--log-output=#{Steep.log_output}"
+        end
         command = case type
                   when :interaction
-                    ["steep", "worker", "--interaction", "--name=#{name}", "--log-level=#{log_level}", "--steepfile=#{steepfile}", *options]
+                    [steep_command, "worker", "--interaction", *args, *options]
                   when :typecheck
-                    ["steep", "worker", "--typecheck", "--name=#{name}", "--log-level=#{log_level}", "--steepfile=#{steepfile}", *options]
+                    [steep_command, "worker", "--typecheck", *args, *options]
                   else
                     raise "Unknown type: #{type}"
                   end
@@ -33,7 +37,11 @@ module Steep
           command << "--delay-shutdown"
         end
 
-        stdin, stdout, thread = Open3.popen2(*command, pgroup: true)
+        stdin, stdout, thread = if Gem.win_platform?
+                                  Open3.popen2(*command, new_pgroup: true)
+                                else
+                                  Open3.popen2(*command, pgroup: true)
+                                end
         stderr = nil
 
         writer = LanguageServer::Protocol::Transport::Io::Writer.new(stdin)
@@ -42,11 +50,12 @@ module Steep
         new(reader: reader, writer: writer, stderr: stderr, wait_thread: thread, name: name, index: index)
       end
 
-      def self.spawn_typecheck_workers(steepfile:, args:, count: [Etc.nprocessors - 1, 1].max, delay_shutdown: false)
+      def self.spawn_typecheck_workers(steepfile:, args:, steep_command: "steep", count: [Etc.nprocessors - 1, 1].max, delay_shutdown: false)
         count.times.map do |i|
           spawn_worker(:typecheck,
                        name: "typecheck@#{i}",
                        steepfile: steepfile,
+                       steep_command: steep_command,
                        options: ["--max-index=#{count}", "--index=#{i}", *args],
                        delay_shutdown: delay_shutdown,
                        index: i)

data/lib/steep/services/completion_provider.rb

@@ -10,6 +10,30 @@ module Steep
 
       InstanceVariableItem = Struct.new(:identifier, :range, :type, keyword_init: true)
       LocalVariableItem = Struct.new(:identifier, :range, :type, keyword_init: true)
+      ConstantItem = Struct.new(:env, :identifier, :range, :type, :full_name, keyword_init: true) do
+        def class?
+          if decl = env.class_decls[full_name]
+            decl.primary.decl.is_a?(RBS::AST::Declarations::Class)
+          end
+        end
+
+        def module?
+          if decl = env.class_decls[full_name]
+            decl.primary.decl.is_a?(RBS::AST::Declarations::Module)
+          end
+        end
+
+        def comments
+          case
+          when decl = env.class_decls[full_name]
+            decl.decls.filter_map {|d| d.decl.comment }
+          when comment = env.constant_decls[full_name]&.decl&.comment
+            [comment]
+          else
+            []
+          end
+        end
+      end
       MethodNameItem = Struct.new(:identifier, :range, :receiver_type, :method_type, :method_decls, keyword_init: true) do
         def comment
           case method_decls.size
@@ -61,6 +85,10 @@ module Steep
         end
       end
 
+      def env
+        subtyping.factory.env
+      end
+
       def run(line:, column:)
         source_text = self.source_text.dup
         index = index_for(source_text, line:line, column: column)
@@ -92,6 +120,15 @@ module Steep
             source_text[index-1] = " "
             type_check!(source_text, line: line, column: column)
             items_for_atmark(position: position)
+          when ":"
+            if source_text[index-2] == ":"
+              source_text[index-1] = " "
+              source_text[index-2] = " "
+              type_check!(source_text, line: line, column: column)
+              items_for_colon2(position: position)
+            else
+              []
+            end
           else
             []
           end
@@ -170,8 +207,25 @@ module Steep
                                          prefix: prefix,
                                          position: position,
                                          items: items)
+          constant_items_for_context(context, prefix: prefix, position: position, items: items)
 
-        when node.type == :send && at_end?(position, of: node.loc.dot)
+        when node.type == :const && node.children[0] && at_end?(position, of: node.loc)
+          # Foo::Ba ← (const)
+          parent_node = node.children[0]
+          parent_type = typing.type_of(node: parent_node)
+
+          if parent_type
+            prefix = node.children[1].to_s
+
+            method_items_for_receiver_type(parent_type,
+                                           include_private: false,
+                                           prefix: prefix,
+                                           position: position,
+                                           items: items)
+            constant_items_for_context(context, parent: parent_node, prefix: prefix, position: position, items: items)
+          end
+
+        when node.type == :send && at_end?(position, of: node.loc.dot) && node.loc.dot.source == "."
           # foo.← ba
           receiver_type = case (type = typing.type_of(node: node.children[0]))
                           when AST::Types::Self
@@ -186,6 +240,10 @@ module Steep
                                          position: position,
                                          items: items)
 
+        when node.type == :send && at_end?(position, of: node.loc.dot) && node.loc.dot.source == "::"
+          # foo::← ba
+          items.push(*items_for_colon2(position: position))
+
         when node.type == :ivar && at_end?(position, of: node.loc)
           # @fo ←
           instance_variable_items_for_context(context, position: position, prefix: node.children[0].to_s, items: items)
@@ -198,6 +256,7 @@ module Steep
                                          items: items)
           local_variable_items_for_context(context, position: position, prefix: "", items: items)
           instance_variable_items_for_context(context, position: position, prefix: "", items: items)
+          constant_items_for_context(context, position: position, prefix: "", items: items)
         end
 
         items
@@ -236,6 +295,31 @@ module Steep
         end
       end
 
+      def items_for_colon2(position:)
+        # :: ←
+        shift_pos = position-2
+        node, *_ = source.find_nodes(line: shift_pos.line, column: shift_pos.column)
+        node ||= source.node
+
+        items = []
+        case node&.type
+        when :const
+          # Constant:: ←
+          context = typing.context_at(line: position.line, column: position.column)
+          constant_items_for_context(context, parent: node, position: position, items: items, prefix: "")
+        when nil
+          # :: ←
+          context = typing.context_at(line: position.line, column: position.column)
+          constant_items_for_context(context, parent: nil, position: position, items: items, prefix: "")
+        end
+
+        if node
+          items.push(*items_for_dot(position: position - 1))
+        end
+
+        items
+      end
+
       def items_for_atmark(position:)
         # @ ←
         shift_pos = position-1
@@ -290,6 +374,30 @@ module Steep
         end
       end
 
+      def constant_items_for_context(context, parent: nil, position:, prefix:, items:)
+        range = range_for(position, prefix: prefix)
+
+        if parent
+          case parent.type
+          when :const
+            const_name = typing.source_index.reference(constant_node: parent)
+            consts = context.module_context.const_env.children(const_name)
+          end
+        else
+          consts = context.module_context.const_env.constants
+        end
+
+        if consts
+          consts.each do |name, tuple|
+            type, full_name, _ = tuple
+
+            if name.to_s.start_with?(prefix)
+              items << ConstantItem.new(env: env, identifier: name, range: range, type: type, full_name: full_name)
+            end
+          end
+        end
+      end
+
       def instance_variable_items_for_context(context, position:, prefix:, items:)
         range = range_for(position, prefix: prefix)
         context.type_env.ivar_types.map do |name, type|

data/lib/steep/services/goto_service.rb

@@ -21,10 +21,11 @@ module Steep
       end
       TypeNameQuery = Struct.new(:name, keyword_init: true)
 
-      attr_reader :type_check
+      attr_reader :type_check, :assignment
 
-      def initialize(type_check:)
+      def initialize(type_check:, assignment:)
         @type_check = type_check
+        @assignment = assignment
       end
 
       def project
@@ -78,7 +79,17 @@ module Steep
           end
         end
 
-        locations.uniq
+        # Drop un-assigned paths here.
+        # The path assignment makes sense only for `.rbs` files, because un-assigned `.rb` files are already skipped since they are not type checked.
+        #
+        locations.uniq.select do |loc|
+          case loc
+          when RBS::Location
+            assignment =~ loc.name
+          else
+            true
+          end
+        end
       end
 
       def test_ast_location(loc, line:, column:)
@@ -100,14 +111,13 @@ module Steep
           typing, signature = type_check_path(target: target, path: relative_path, content: source.content, line: line, column: column)
           if typing
             node, *parents = typing.source.find_nodes(line: line, column: column)
+
             if node
               case node.type
               when :const, :casgn
                 if test_ast_location(node.location.name, line: line, column: column)
-                  if module_context = typing.context_at(line: line, column: column).module_context
-                    const_env = module_context.const_env
-                    const = const_env.lookup_constant(module_name_from_node(node))
-                    queries << ConstantQuery.new(name: const.name, from: :ruby)
+                  if name = typing.source_index.reference(constant_node: node)
+                    queries << ConstantQuery.new(name: name, from: :ruby)
                   end
                 end
               when :def, :defs
@@ -125,7 +135,10 @@ module Steep
                 end
               when :send
                 if test_ast_location(node.location.selector, line: line, column: column)
-                  node = parents[0] if parents[0]&.type == :block
+                  if (parent = parents[0]) && parent.type == :block && parent.children[0] == node
+                    node = parents[0]
+                  end
+
                   case call = typing.call_of(node: node)
                   when TypeInference::MethodCall::Typed, TypeInference::MethodCall::Error
                     call.method_decls.each do |decl|
@@ -232,8 +245,8 @@ module Steep
             entry = typing.source_index.entry(constant: name)
             entry.definitions.each do |node|
               case node.type
-              when :class, :module
-                locations << node.children[0].location.expression
+              when :const
+                locations << node.location.expression
               when :casgn
                 parent = node.children[0]
                 location =

data/lib/steep/services/hover_content.rb

@@ -5,16 +5,42 @@ module Steep
       VariableContent = Struct.new(:node, :name, :type, :location, keyword_init: true)
       MethodCallContent = Struct.new(:node, :method_name, :type, :definition, :location, keyword_init: true)
       DefinitionContent = Struct.new(:node, :method_name, :method_type, :definition, :location, keyword_init: true) do
-      TypeAliasContent = Struct.new(:location, :decl, keyword_init: true)
-      ClassContent = Struct.new(:location, :decl, keyword_init: true)
-      InterfaceContent = Struct.new(:location, :decl, keyword_init: true)
-
         def comment_string
           if comments = definition&.comments
             comments.map {|c| c.string.chomp }.uniq.join("\n----\n")
           end
         end
       end
+      ConstantContent = Struct.new(:location, :full_name, :type, :decl, keyword_init: true) do
+        def comment_string
+          if class_or_module?
+            comments = decl.decls.filter_map {|d| d.decl.comment&.string }
+            unless comments.empty?
+              return comments.join("\n----\n")
+            end
+          end
+
+          if constant?
+            if comment = decl.decl.comment
+              return comment.string
+            end
+          end
+
+          nil
+        end
+
+        def constant?
+          decl.is_a?(RBS::Environment::SingleEntry)
+        end
+
+        def class_or_module?
+          decl.is_a?(RBS::Environment::MultiEntry)
+        end
+      end
+
+      TypeAliasContent = Struct.new(:location, :decl, keyword_init: true)
+      ClassContent = Struct.new(:location, :decl, keyword_init: true)
+      InterfaceContent = Struct.new(:location, :decl, keyword_init: true)
 
       InstanceMethodName = Struct.new(:class_name, :method_name)
       SingletonMethodName = Struct.new(:class_name, :method_name)
@@ -190,6 +216,28 @@ module Steep
                 location: node.loc.expression
               )
             end
+          when :const, :casgn
+            context = typing.context_at(line: line, column: column)
+
+            type = typing.type_of(node: node)
+            const_name = typing.source_index.reference(constant_node: node)
+
+            if const_name
+              decl = context.env.class_decls[const_name] || context.env.constant_decls[const_name]
+
+              ConstantContent.new(
+                location: node.location.name,
+                full_name: const_name,
+                type: type,
+                decl: decl
+              )
+            else
+              TypeContent.new(
+                node: node,
+                type: type,
+                location: node.location.expression
+              )
+            end
           else
             type = typing.type_of(node: node)
 

data/lib/steep/services/type_check_service.rb

@@ -338,8 +338,12 @@ module Steep
       end
 
       def self.type_check(source:, subtyping:)
-        annotations = source.annotations(block: source.node, factory: subtyping.factory, current_module: RBS::Namespace.root)
-        const_env = TypeInference::ConstantEnv.new(factory: subtyping.factory, context: [RBS::Namespace.root])
+        annotations = source.annotations(block: source.node, factory: subtyping.factory, context: nil)
+        const_env = TypeInference::ConstantEnv.new(
+          factory: subtyping.factory,
+          context: nil,
+          resolver: RBS::Resolver::ConstantResolver.new(builder: subtyping.factory.definition_builder)
+        )
         type_env = TypeInference::TypeEnv.build(annotations: annotations,
                                                 subtyping: subtyping,
                                                 const_env: const_env,
@@ -357,7 +361,6 @@ module Steep
             instance_type: AST::Builtin::Object.instance_type,
             module_type: AST::Builtin::Object.module_type,
             implement_name: nil,
-            current_namespace: RBS::Namespace.root,
             const_env: const_env,
             class_name: AST::Builtin::Object.module_name,
             instance_definition: subtyping.factory.definition_builder.build_instance(AST::Builtin::Object.module_name),

data/lib/steep/source.rb

@@ -283,11 +283,11 @@ module Steep
       node.updated(nil, children)
     end
 
-    def annotations(block:, factory:, current_module:)
+    def annotations(block:, factory:, context:)
       AST::Annotation::Collection.new(
         annotations: (mapping[block] || []).map(&:annotation),
         factory: factory,
-        current_module: current_module
+        context: context
       )
     end
 
@@ -301,11 +301,42 @@ module Steep
       end
     end
 
-    def find_nodes(line:, column:, node: self.node, position: nil, parents: [])
-      position ||= (line-1).times.sum do |i|
-        node.location.expression.source_buffer.source_line(i+1).size + 1
-      end + column
+    def each_heredoc_node(node = self.node, parents = [], &block)
+      if block
+        case node.type
+        when :dstr, :str
+          if node.location.is_a?(Parser::Source::Map::Heredoc)
+            yield [node, *parents]
+          end
+        end
+
+        parents.unshift(node)
+        Source.each_child_node(node) do |child|
+          each_heredoc_node(child, parents, &block)
+        end
+        parents.shift()
+      else
+        enum_for :each_heredoc_node, node
+      end
+    end
 
+    def find_heredoc_nodes(line, column, position)
+      each_heredoc_node() do |nodes|
+        node = nodes[0]
+
+        range = node.location.heredoc_body&.yield_self do |r|
+          r.begin_pos..r.end_pos
+        end
+
+        if range && (range === position)
+          return nodes
+        end
+      end
+
+      nil
+    end
+
+    def find_nodes_loc(node, position, parents)
       range = node.location.expression&.yield_self do |r|
         r.begin_pos..r.end_pos
       end
@@ -315,7 +346,7 @@ module Steep
           parents.unshift node
 
           Source.each_child_node(node) do |child|
-            ns = find_nodes(line: line, column: column, node: child, position: position, parents: parents) and return ns
+            ns = find_nodes_loc(child, position, parents) and return ns
           end
 
           parents
@@ -323,6 +354,24 @@ module Steep
       end
     end
 
+    def find_nodes(line:, column:)
+      return [] unless node
+
+      position = (line-1).times.sum do |i|
+        node.location.expression.source_buffer.source_line(i+1).size + 1
+      end + column
+
+      if nodes = find_heredoc_nodes(line, column, position)
+        Source.each_child_node(nodes[0]) do |child|
+          find_nodes_loc(child, position, nodes) and break
+        end
+
+        nodes
+      else
+        find_nodes_loc(node, position, [])
+      end
+    end
+
     def self.delete_defs(node, allow_list)
       case node.type
       when :def
@@ -345,22 +394,26 @@ module Steep
     end
 
     def without_unrelated_defs(line:, column:)
-      nodes = find_nodes(line: line, column: column) || []
-      defs = Set[].compare_by_identity.merge(nodes.select {|node| node.type == :def || node.type == :defs })
+      if node
+        nodes = find_nodes(line: line, column: column) || []
+        defs = Set[].compare_by_identity.merge(nodes.select {|node| node.type == :def || node.type == :defs })
 
-      node_ = Source.delete_defs(node, defs)
+        node_ = Source.delete_defs(node, defs)
 
-      mapping = {}.compare_by_identity
+        mapping = {}.compare_by_identity
 
-      annotations = self.mapping.values.flatten
-      Source.construct_mapping(node: node_, annotations: annotations, mapping: mapping)
+        annotations = self.mapping.values.flatten
+        Source.construct_mapping(node: node_, annotations: annotations, mapping: mapping)
 
-      annotations.each do |annot|
-        mapping[node] ||= []
-        mapping[node] << annot
-      end
+        annotations.each do |annot|
+          mapping[node] ||= []
+          mapping[node] << annot
+        end
 
-      Source.new(path: path, node: node_, mapping: mapping)
+        Source.new(path: path, node: node_, mapping: mapping)
+      else
+        self
+      end
     end
 
     def compact_siblings(node)