steep 0.44.1 → 0.45.0

data/lib/steep/server/interaction_worker.rb

@@ -7,6 +7,8 @@ module Steep
       HoverJob = Struct.new(:id, :path, :line, :column, keyword_init: true)
       CompletionJob = Struct.new(:id, :path, :line, :column, :trigger, keyword_init: true)
 
+      LSP = LanguageServer::Protocol
+
       attr_reader :service
 
       def initialize(project:, reader:, writer:, queue: Queue.new)
@@ -77,11 +79,12 @@ module Steep
             Steep.logger.info { "path=#{job.path}, line=#{job.line}, column=#{job.column}" }
 
             hover = Services::HoverContent.new(service: service)
-            content = hover.content_for(path: job.path, line: job.line, column: job.column+1)
+            content = hover.content_for(path: job.path, line: job.line, column: job.column)
             if content
               range = content.location.yield_self do |location|
-                start_position = { line: location.line - 1, character: location.column }
-                end_position = { line: location.last_line - 1, character: location.last_column }
+                lsp_range = location.as_lsp_range
+                start_position = { line: lsp_range[:start][:line], character: lsp_range[:start][:character] }
+                end_position = { line: lsp_range[:end][:line], character: lsp_range[:end][:character] }
                 { start: start_position, end: end_position }
               end
 
@@ -99,6 +102,36 @@ module Steep
 
       def format_hover(content)
         case content
+        when Services::HoverContent::TypeAliasContent
+          comment = content.decl.comment&.string || ''
+
+          <<-MD
+#{comment}
+
+```rbs
+#{retrieve_decl_information(content.decl)}
+```
+          MD
+        when Services::HoverContent::InterfaceContent
+          comment = content.decl.comment&.string || ''
+
+          <<-MD
+#{comment}
+
+```rbs
+#{retrieve_decl_information(content.decl)}
+```
+          MD
+        when Services::HoverContent::ClassContent
+          comment = content.decl.comment&.string || ''
+
+          <<-MD
+#{comment}
+
+```rbs
+#{retrieve_decl_information(content.decl)}
+```
+          MD
         when Services::HoverContent::VariableContent
           "`#{content.name}`: `#{content.type.to_s}`"
         when Services::HoverContent::MethodCallContent
@@ -151,32 +184,207 @@ HOVER
         Steep.logger.tagged("#response_to_completion") do
           Steep.measure "Generating response" do
             Steep.logger.info "path: #{job.path}, line: #{job.line}, column: #{job.column}, trigger: #{job.trigger}"
+            case
+            when target = project.target_for_source_path(job.path)
+              file = service.source_files[job.path] or return
+              subtyping = service.signature_services[target.name].current_subtyping or return
+
+              provider = Services::CompletionProvider.new(source_text: file.content, path: job.path, subtyping: subtyping)
+              items = begin
+                        provider.run(line: job.line, column: job.column)
+                      rescue Parser::SyntaxError
+                        []
+                      end
+
+              completion_items = items.map do |item|
+                format_completion_item(item)
+              end
+
+              Steep.logger.debug "items = #{completion_items.inspect}"
+
+              LSP::Interface::CompletionList.new(
+                is_incomplete: false,
+                items: completion_items
+              )
+            when (_, targets = project.targets_for_path(job.path))
+              target = targets[0] or return
+              sig_service = service.signature_services[target.name]
+              relative_path = job.path
+              buffer = RBS::Buffer.new(name: relative_path, content: sig_service.files[relative_path].content)
+              pos = buffer.loc_to_pos([job.line, job.column])
+              prefix = buffer.content[0...pos].reverse[/\A[\w\d]*/].reverse
+
+              case sig_service.status
+              when Steep::Services::SignatureService::SyntaxErrorStatus, Steep::Services::SignatureService::AncestorErrorStatus
+                return
+              end
+
+              decls = sig_service.files[relative_path].decls
+              locator = RBS::Locator.new(decls: decls)
+
+              hd, tail = locator.find2(line: job.line, column: job.column)
+
+              namespace = []
+              tail.each do |t|
+                case t
+                when RBS::AST::Declarations::Module, RBS::AST::Declarations::Class
+                  namespace << t.name.to_namespace
+                end
+              end
+              context = []
 
-            target = project.target_for_source_path(job.path) or return
-            file = service.source_files[job.path] or return
-            subtyping = service.signature_services[target.name].current_subtyping or return
+              namespace.each do |ns|
+                context.map! { |n| ns + n }
+                context << ns
+              end
+
+              context.map!(&:absolute!)
+
+              class_items = sig_service.latest_env.class_decls.keys.map { |type_name|
+                format_completion_item_for_rbs(sig_service, type_name, context, job, prefix)
+              }.compact
+
+              alias_items = sig_service.latest_env.alias_decls.keys.map { |type_name|
+                format_completion_item_for_rbs(sig_service, type_name, context, job, prefix)
+              }.compact
+
+              interface_items = sig_service.latest_env.interface_decls.keys.map {|type_name|
+                format_completion_item_for_rbs(sig_service, type_name, context, job, prefix)
+              }.compact
 
-            provider = Services::CompletionProvider.new(source_text: file.content, path: job.path, subtyping: subtyping)
-            items = begin
-                      provider.run(line: job.line, column: job.column)
-                    rescue Parser::SyntaxError
-                      []
-                    end
+              completion_items = class_items + alias_items + interface_items
 
-            completion_items = items.map do |item|
-              format_completion_item(item)
+              LSP::Interface::CompletionList.new(
+                is_incomplete: false,
+                items: completion_items
+              )
             end
+          end
+        end
+      end
+
+      def format_completion_item_for_rbs(sig_service, type_name, context, job, prefix)
+        range = LanguageServer::Protocol::Interface::Range.new(
+          start: LanguageServer::Protocol::Interface::Position.new(
+            line: job.line - 1,
+            character: job.column - prefix.size
+          ),
+          end: LanguageServer::Protocol::Interface::Position.new(
+            line: job.line - 1,
+            character: job.column - prefix.size
+          )
+        )
 
-            Steep.logger.debug "items = #{completion_items.inspect}"
+        name = relative_name_in_context(type_name, context).to_s
 
-            LSP::Interface::CompletionList.new(
-              is_incomplete: false,
-              items: completion_items
-            )
+        return unless name.start_with?(prefix)
+
+        case type_name.kind
+        when :class
+          class_decl = sig_service.latest_env.class_decls[type_name]&.decls[0]&.decl or raise
+
+          LanguageServer::Protocol::Interface::CompletionItem.new(
+            label: "#{name}",
+            documentation:  format_comment(class_decl.comment),
+            text_edit: LanguageServer::Protocol::Interface::TextEdit.new(
+              range: range,
+              new_text: name
+            ),
+            kind: LSP::Constant::CompletionItemKind::CLASS,
+            insert_text_format: LSP::Constant::InsertTextFormat::SNIPPET
+
+          )
+        when :alias
+          alias_decl = sig_service.latest_env.alias_decls[type_name]&.decl or raise
+          LanguageServer::Protocol::Interface::CompletionItem.new(
+            label: "#{name}",
+            text_edit: LanguageServer::Protocol::Interface::TextEdit.new(
+              range: range,
+              new_text: name
+            ),
+            documentation: format_comment(alias_decl.comment),
+            # https://github.com/microsoft/vscode-languageserver-node/blob/6d78fc4d25719b231aba64a721a606f58b9e0a5f/client/src/common/client.ts#L624-L650
+            kind: LSP::Constant::CompletionItemKind::FIELD,
+            insert_text_format: LSP::Constant::InsertTextFormat::SNIPPET
+          )
+        when :interface
+          interface_decl = sig_service.latest_env.interface_decls[type_name]&.decl or raise
+
+          LanguageServer::Protocol::Interface::CompletionItem.new(
+            label: "#{name}",
+            text_edit: LanguageServer::Protocol::Interface::TextEdit.new(
+              range: range,
+              new_text: name
+            ),
+            documentation: format_comment(interface_decl.comment),
+            kind: LanguageServer::Protocol::Constant::CompletionItemKind::INTERFACE,
+            insert_text_format: LanguageServer::Protocol::Constant::InsertTextFormat::SNIPPET
+          )
+        end
+      end
+
+      def format_comment(comment)
+        if comment
+          LSP::Interface::MarkupContent.new(
+            kind: LSP::Constant::MarkupKind::MARKDOWN,
+            value: comment.string
+          )
+        end
+      end
+
+      def name_and_params(name, params)
+        if params.empty?
+          "#{name}"
+        else
+          ps = params.each.map do |param|
+            s = ""
+            if param.skip_validation
+              s << "unchecked "
+            end
+            case param.variance
+            when :invariant
+              # nop
+            when :covariant
+              s << "out "
+            when :contravariant
+              s << "in "
+            end
+            s + param.name.to_s
+          end
+
+          "#{name}[#{ps.join(", ")}]"
+        end
+      end
+
+      def name_and_args(name, args)
+        if name && args
+          if args.empty?
+            "#{name}"
+          else
+            "#{name}[#{args.join(", ")}]"
           end
         end
       end
 
+      def retrieve_decl_information(decl)
+        case decl
+        when RBS::AST::Declarations::Class
+          super_class = if super_class = decl.super_class
+                          " < #{name_and_args(super_class.name, super_class.args)}"
+                        end
+          "class #{name_and_params(decl.name, decl.type_params)}#{super_class}"
+        when RBS::AST::Declarations::Module
+          self_type = unless decl.self_types.empty?
+                        " : #{decl.self_types.join(", ")}"
+                      end
+          "module #{name_and_params(decl.name, decl.type_params)}#{self_type}"
+        when RBS::AST::Declarations::Alias
+          "type #{decl.name} = #{decl.type}"
+        when RBS::AST::Declarations::Interface
+          "interface #{name_and_params(decl.name, decl.type_params)}"
+        end
+    end
+
       def format_completion_item(item)
         range = LanguageServer::Protocol::Interface::Range.new(
           start: LanguageServer::Protocol::Interface::Position.new(
@@ -297,6 +505,17 @@ HOVER
 
         params.join(", ")
       end
+
+      def relative_name_in_context(type_name, context)
+        context.each do |namespace|
+          if (type_name.to_s == namespace.to_type_name.to_s || type_name.namespace.to_s == "::")
+            return RBS::TypeName.new(namespace: RBS::Namespace.empty, name: type_name.name)
+          elsif type_name.to_s.start_with?(namespace.to_s)
+            return TypeName(type_name.to_s.sub(namespace.to_type_name.to_s, '')).relative!
+          end
+        end
+        type_name
+      end
     end
   end
 end

data/lib/steep/services/file_loader.rb

@@ -8,29 +8,36 @@ module Steep
       end
 
       def each_path_in_patterns(pattern, commandline_patterns = [])
-        pats = commandline_patterns.empty? ? pattern.patterns : commandline_patterns
-
-        pats.each do |path|
-          absolute_path = base_dir + path
-
-          if absolute_path.file?
-            yield absolute_path.relative_path_from(base_dir)
-          else
-            files = if absolute_path.directory?
-                      Pathname.glob("#{absolute_path}/**/*#{pattern.ext}")
-                    else
-                      Pathname.glob(absolute_path)
-                    end
-
-            files.sort.each do |source_path|
-              if source_path.file?
-                relative_path = source_path.relative_path_from(base_dir)
-                unless pattern.ignore?(relative_path)
-                  yield relative_path
+        if block_given?
+          pats = commandline_patterns.empty? ? pattern.patterns : commandline_patterns
+
+          pats.each do |path|
+            absolute_path = base_dir + path
+
+            if absolute_path.file?
+              if pattern =~ path
+                yield absolute_path.relative_path_from(base_dir)
+              end
+            else
+              files = if absolute_path.directory?
+                        Pathname.glob("#{absolute_path}/**/*#{pattern.ext}")
+                      else
+                        Pathname.glob(absolute_path)
+                      end
+
+              files.sort.each do |source_path|
+                if source_path.file?
+                  relative_path = source_path.relative_path_from(base_dir)
+                  unless pattern.ignore?(relative_path)
+                    yield relative_path
+                  end
                 end
               end
             end
+
           end
+        else
+          enum_for :each_path_in_patterns, pattern, commandline_patterns
         end
       end
 

data/lib/steep/services/hover_content.rb

@@ -5,6 +5,10 @@ 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")
@@ -50,99 +54,147 @@ module Steep
       end
 
       def content_for(path:, line:, column:)
-        target = project.target_for_source_path(path)
+        target_for_code, targets_for_sigs = project.targets_for_path(path)
+
+        case
+        when target = target_for_code
+          Steep.logger.info "target #{target}"
+
+          hover_for_source(column, line, path, target)
+
+        when target = targets_for_sigs[0]
+          service = self.service.signature_services[target.name]
+
+          _buffer, decls = service.latest_env.buffers_decls.find do |buffer, _|
+            Pathname(buffer.name) == path
+          end
+
+          return if decls.nil?
+
+          locator = RBS::Locator.new(decls: decls)
+          hd, tail = locator.find2(line: line, column: column)
+
+          case type = tail[0]
+          when RBS::Types::Alias
+            alias_decl = service.latest_env.alias_decls[type.name]&.decl or raise
+
+            location = tail[0].location
+            TypeAliasContent.new(
+              location: location,
+              decl: alias_decl
+            )
+          when RBS::Types::ClassInstance, RBS::Types::ClassSingleton
+            if hd == :name
+              env = service.latest_env
+              class_decl = env.class_decls[type.name]&.decls[0]&.decl or raise
+              location = tail[0].location[:name]
+              ClassContent.new(
+                location: location,
+                decl: class_decl
+              )
+            end
+          when RBS::Types::Interface
+            env = service.latest_env
+            interface_decl = env.interface_decls[type.name]&.decl or raise
+            location = type.location[:name]
+
+            InterfaceContent.new(
+              location: location,
+              decl: interface_decl
+            )
+          end
+        end
+      end
 
-        if target
-          file = service.source_files[path]
-          typing = typecheck(target, path: path, content: file.content, line: line, column: column) or return
+      def hover_for_source(column, line, path, target)
+        file = service.source_files[path]
+        typing = typecheck(target, path: path, content: file.content, line: line, column: column) or return
+        node, *parents = typing.source.find_nodes(line: line, column: column)
 
-          node, *parents = typing.source.find_nodes(line: line, column: column)
+        if node
+          case node.type
+          when :lvar
+            var_name = node.children[0]
+            context = typing.context_at(line: line, column: column)
+            var_type = context.lvar_env[var_name] || AST::Types::Any.new(location: nil)
 
-          if node
-            case node.type
-            when :lvar
-              var_name = node.children[0]
-              context = typing.context_at(line: line, column: column)
-              var_type = context.lvar_env[var_name] || AST::Types::Any.new(location: nil)
+            VariableContent.new(node: node, name: var_name, type: var_type, location: node.location.name)
+          when :lvasgn
+            var_name, rhs = node.children
+            context = typing.context_at(line: line, column: column)
+            type = context.lvar_env[var_name] || typing.type_of(node: rhs)
 
-              VariableContent.new(node: node, name: var_name, type: var_type, location: node.location.name)
-            when :lvasgn
-              var_name, rhs = node.children
-              context = typing.context_at(line: line, column: column)
-              type = context.lvar_env[var_name] || typing.type_of(node: rhs)
+            VariableContent.new(node: node, name: var_name, type: type, location: node.location.name)
+          when :send
+            receiver, method_name, *_ = node.children
 
-              VariableContent.new(node: node, name: var_name, type: type, location: node.location.name)
-            when :send
-              receiver, method_name, *_ = node.children
 
+            result_node = if parents[0]&.type == :block
+                            parents[0]
+                          else
+                            node
+                          end
 
-              result_node = if parents[0]&.type == :block
-                              parents[0]
+            context = typing.context_at(line: line, column: column)
+
+            receiver_type = if receiver
+                              typing.type_of(node: receiver)
                             else
-                              node
+                              context.self_type
                             end
 
-              context = typing.context_at(line: line, column: column)
-
-              receiver_type = if receiver
-                                typing.type_of(node: receiver)
-                              else
-                                context.self_type
-                              end
-
-              factory = context.type_env.subtyping.factory
-              method_name, definition = case receiver_type
-                                        when AST::Types::Name::Instance
-                                          method_definition = method_definition_for(factory, receiver_type.name, instance_method: method_name)
-                                          if method_definition&.defined_in
-                                            owner_name = method_definition.defined_in
-                                            [
-                                              InstanceMethodName.new(owner_name, method_name),
-                                              method_definition
-                                            ]
-                                          end
-                                        when AST::Types::Name::Singleton
-                                          method_definition = method_definition_for(factory, receiver_type.name, singleton_method: method_name)
-                                          if method_definition&.defined_in
-                                            owner_name = method_definition.defined_in
-                                            [
-                                              SingletonMethodName.new(owner_name, method_name),
-                                              method_definition
-                                            ]
-                                          end
-                                        else
-                                          nil
+            factory = context.type_env.subtyping.factory
+            method_name, definition = case receiver_type
+                                      when AST::Types::Name::Instance
+                                        method_definition = method_definition_for(factory, receiver_type.name, instance_method: method_name)
+                                        if method_definition&.defined_in
+                                          owner_name = method_definition.defined_in
+                                          [
+                                            InstanceMethodName.new(owner_name, method_name),
+                                            method_definition
+                                          ]
                                         end
-
-              MethodCallContent.new(
-                node: node,
-                method_name: method_name,
-                type: typing.type_of(node: result_node),
-                definition: definition,
-                location: result_node.location.expression
-              )
-            when :def, :defs
-              context = typing.context_at(line: line, column: column)
-              method_context = context.method_context
-
-              if method_context && method_context.method
-                DefinitionContent.new(
-                  node: node,
-                  method_name: method_context.name,
-                  method_type: method_context.method_type,
-                  definition: method_context.method,
-                  location: node.loc.expression
-                )
-              end
-            else
-              type = typing.type_of(node: node)
-
-              TypeContent.new(
+                                      when AST::Types::Name::Singleton
+                                        method_definition = method_definition_for(factory, receiver_type.name, singleton_method: method_name)
+                                        if method_definition&.defined_in
+                                          owner_name = method_definition.defined_in
+                                          [
+                                            SingletonMethodName.new(owner_name, method_name),
+                                            method_definition
+                                          ]
+                                        end
+                                      else
+                                        nil
+                                      end
+
+            MethodCallContent.new(
+              node: node,
+              method_name: method_name,
+              type: typing.type_of(node: result_node),
+              definition: definition,
+              location: result_node.location.expression
+            )
+          when :def, :defs
+            context = typing.context_at(line: line, column: column)
+            method_context = context.method_context
+
+            if method_context && method_context.method
+              DefinitionContent.new(
                 node: node,
-                type: type,
-                location: node.location.expression
+                method_name: method_context.name,
+                method_type: method_context.method_type,
+                definition: method_context.method,
+                location: node.loc.expression
               )
             end
+          else
+            type = typing.type_of(node: node)
+
+            TypeContent.new(
+              node: node,
+              type: type,
+              location: node.location.expression
+            )
           end
         end
       end