steep 1.4.0 → 1.5.0.pre.1

data/lib/steep/expectations.rb

@@ -1,5 +1,136 @@
 module Steep
   class Expectations
+    class Diagnostic < Struct.new(:start_position, :end_position, :severity, :message, :code, keyword_init: true)
+      DiagnosticSeverity = LanguageServer::Protocol::Constant::DiagnosticSeverity
+
+      def self.from_hash(hash)
+        start_position = {
+          line: hash.dig("range", "start", "line") - 1,
+          character: hash.dig("range", "start", "character")
+        } #: position
+        end_position = {
+          line: hash.dig("range", "end", "line") - 1,
+          character: hash.dig("range", "end", "character")
+        } #: position
+
+        severity =
+          case hash["severity"] || "ERROR"
+          when "ERROR"
+            :error
+          when "WARNING"
+            :warning
+          when "INFORMATION"
+            :information
+          when "HINT"
+            :hint
+          end #: Diagnostic::LSPFormatter::severity
+
+        Diagnostic.new(
+          start_position: start_position,
+          end_position: end_position,
+          severity: severity,
+          message: hash["message"],
+          code: hash["code"]
+        )
+      end
+
+      def self.from_lsp(diagnostic)
+        start_position = {
+          line: diagnostic.dig(:range, :start, :line),
+          character: diagnostic.dig(:range, :start, :character)
+        } #: position
+        end_position = {
+          line: diagnostic.dig(:range, :end, :line),
+          character: diagnostic.dig(:range, :end, :character)
+        } #: position
+
+        severity =
+          case diagnostic[:severity]
+          when DiagnosticSeverity::ERROR
+            :error
+          when DiagnosticSeverity::WARNING
+            :warning
+          when DiagnosticSeverity::INFORMATION
+            :information
+          when DiagnosticSeverity::HINT
+            :hint
+          else
+            :error
+          end #: Diagnostic::LSPFormatter::severity
+
+        Diagnostic.new(
+          start_position: start_position,
+          end_position: end_position,
+          severity: severity,
+          message: diagnostic[:message],
+          code: diagnostic[:code]
+        )
+      end
+
+      def to_hash
+        {
+          "range" => {
+            "start" => {
+              "line" => start_position[:line] + 1,
+              "character" => start_position[:character]
+            },
+            "end" => {
+              "line" => end_position[:line] + 1,
+              "character" => end_position[:character]
+            }
+          },
+          "severity" => severity.to_s.upcase,
+          "message" => message,
+          "code" => code
+        }
+      end
+
+      def lsp_severity
+        case severity
+        when :error
+          DiagnosticSeverity::ERROR
+        when :warning
+          DiagnosticSeverity::WARNING
+        when :information
+          DiagnosticSeverity::INFORMATION
+        when :hint
+          DiagnosticSeverity::HINT
+        else
+          raise
+        end
+      end
+
+      def to_lsp
+        {
+          range: {
+            start: {
+              line: start_position[:line],
+              character: start_position[:character]
+            },
+            end: {
+              line: end_position[:line],
+              character: end_position[:character]
+            }
+          },
+          severity: lsp_severity,
+          message: message,
+          code: code
+        }
+      end
+
+      def sort_key
+        [
+          start_position[:line],
+          start_position[:character],
+          end_position[:line],
+          end_position[:character],
+          code,
+          severity,
+          message
+        ]
+      end
+    end
+
     class TestResult
       attr_reader :path
       attr_reader :expectation
@@ -21,17 +152,17 @@ module Steep
 
       def each_diagnostics
         if block_given?
-          expected_set = Set.new(expectation)
-          actual_set = Set.new(actual)
+          expected_set = Set.new(expectation) #: Set[Diagnostic]
+          actual_set = Set.new(actual) #: Set[Diagnostic]
 
-          (expected_set + actual_set).sort_by {|a| Expectations.sort_key(a) }.each do |lsp|
+          (expected_set + actual_set).sort_by(&:sort_key).each do |diagnostic|
             case
-            when expected_set.include?(lsp) && actual_set.include?(lsp)
-              yield :expected, lsp
-            when expected_set.include?(lsp)
-              yield :missing, lsp
-            when actual_set.include?(lsp)
-              yield :unexpected, lsp
+            when expected_set.include?(diagnostic) && actual_set.include?(diagnostic)
+              yield [:expected, diagnostic]
+            when expected_set.include?(diagnostic)
+              yield [:missing, diagnostic]
+            when actual_set.include?(diagnostic)
+              yield [:unexpected, diagnostic]
             end
           end
         else
@@ -56,18 +187,6 @@ module Steep
 
     attr_reader :diagnostics
 
-    def self.sort_key(hash)
-      [
-        hash.dig(:range, :start, :line),
-        hash.dig(:range, :start, :character),
-        hash.dig(:range, :end, :line),
-        hash.dig(:range, :end, :character),
-        hash[:code],
-        hash[:severity],
-        hash[:message]
-      ]
-    end
-
     def initialize()
       @diagnostics = {}
     end
@@ -81,14 +200,13 @@ module Steep
     end
 
     def to_yaml
-      array = []
+      array = [] #: Array[{ "file" => String, "diagnostics" => Array[untyped] }]
 
       diagnostics.each_key.sort.each do |key|
         ds = diagnostics[key]
         array << {
           "file" => key.to_s,
-          'diagnostics' => ds.sort_by {|hash| Expectations.sort_key(hash) }
-                             .map { |d| Expectations.lsp_to_hash(d) }
+          'diagnostics' => ds.sort_by(&:sort_key).map(&:to_hash)
         }
       end
 
@@ -100,60 +218,11 @@ module Steep
 
       YAML.load(content, filename: path.to_s).each do |entry|
         file = Pathname(entry["file"])
-        expectations.diagnostics[file] = entry["diagnostics"]
-                                           .map {|hash| hash_to_lsp(hash) }
-                                           .sort_by! {|h| sort_key(h) }
+        expectations.diagnostics[file] =
+          entry["diagnostics"].map {|hash| Diagnostic.from_hash(hash) }.sort_by!(&:sort_key)
       end
 
       expectations
     end
-
-    # Translate hash to LSP Diagnostic message
-    def self.hash_to_lsp(hash)
-      {
-        range: {
-          start: {
-            line: hash.dig("range", "start", "line") - 1,
-            character: hash.dig("range", "start", "character")
-          },
-          end: {
-            line: hash.dig("range", "end", "line") - 1,
-            character: hash.dig("range", "end", "character")
-          }
-        },
-        severity: {
-          "ERROR" => LSP::Constant::DiagnosticSeverity::ERROR,
-          "WARNING" => LSP::Constant::DiagnosticSeverity::WARNING,
-          "INFORMATION" => LSP::Constant::DiagnosticSeverity::INFORMATION,
-          "HINT" => LSP::Constant::DiagnosticSeverity::HINT
-        }[hash["severity"] || "ERROR"],
-        message: hash["message"],
-        code: hash["code"]
-      }
-    end
-
-    # Translate LSP diagnostic message to hash
-    def self.lsp_to_hash(lsp)
-      {
-        "range" => {
-          "start" => {
-            "line" => lsp.dig(:range, :start, :line) + 1,
-            "character" => lsp.dig(:range, :start, :character)
-          },
-          "end" => {
-            "line" => lsp.dig(:range, :end, :line) + 1,
-            "character" => lsp.dig(:range, :end, :character)
-          }
-        },
-        "severity" => {
-          LSP::Constant::DiagnosticSeverity::ERROR => "ERROR",
-          LSP::Constant::DiagnosticSeverity::WARNING => "WARNING",
-          LSP::Constant::DiagnosticSeverity::INFORMATION => "INFORMATION",
-          LSP::Constant::DiagnosticSeverity::HINT => "HINT"
-        }[lsp[:severity] || LSP::Constant::DiagnosticSeverity::ERROR],
-        "message" => lsp[:message],
-        "code" => lsp[:code]
-      }
-    end
   end
 end

data/lib/steep/index/signature_symbol_provider.rb

@@ -2,7 +2,9 @@ module Steep
   module Index
     class SignatureSymbolProvider
       LSP = LanguageServer::Protocol
-      SymbolInformation = Struct.new(:name, :kind, :container_name, :location, keyword_init: true)
+
+      class SymbolInformation < Struct.new(:name, :kind, :container_name, :location, keyword_init: true)
+      end
 
       attr_reader :project
       attr_reader :indexes
@@ -48,7 +50,7 @@ module Steep
       end
 
       def query_symbol(query)
-        symbols = []
+        symbols = [] #: Array[SymbolInformation]
 
         indexes.each do |index|
           index.each_entry do |entry|
@@ -60,34 +62,35 @@ module Steep
               name = entry.type_name.name.to_s
 
               entry.declarations.each do |decl|
-                next unless assigned?(Pathname(decl.location.buffer.name))
+                location = decl.location or next
+                next unless assigned?(Pathname(location.buffer.name))
 
                 case decl
                 when RBS::AST::Declarations::Class
                   symbols << SymbolInformation.new(
                     name: name,
-                    location: decl.location,
+                    location: location,
                     kind: LSP::Constant::SymbolKind::CLASS,
                     container_name: container_name
                   )
                 when RBS::AST::Declarations::Module
                   symbols << SymbolInformation.new(
                     name: name,
-                    location: decl.location,
+                    location: location,
                     kind: LSP::Constant::SymbolKind::MODULE,
                     container_name: container_name
                   )
                 when RBS::AST::Declarations::Interface
                   symbols << SymbolInformation.new(
                     name: name,
-                    location: decl.location,
+                    location: location,
                     kind: LSP::Constant::SymbolKind::INTERFACE,
                     container_name: container_name
                   )
                 when RBS::AST::Declarations::TypeAlias
                   symbols << SymbolInformation.new(
                     name: name,
-                    location: decl.location,
+                    location: location,
                     kind: LSP::Constant::SymbolKind::ENUM,
                     container_name: container_name
                   )
@@ -101,31 +104,34 @@ module Steep
                        "##{entry.method_name.method_name}"
                      when SingletonMethodName
                        ".#{entry.method_name.method_name}"
+                     else
+                       raise
                      end
               container_name = entry.method_name.type_name.relative!.to_s
 
               entry.declarations.each do |decl|
-                next unless assigned?(Pathname(decl.location.buffer.name))
+                location = decl.location or next
+                next unless assigned?(Pathname(location.buffer.name))
 
                 case decl
                 when RBS::AST::Members::MethodDefinition
                   symbols << SymbolInformation.new(
                     name: name,
-                    location: decl.location,
+                    location: location,
                     kind: LSP::Constant::SymbolKind::METHOD,
                     container_name: container_name
                   )
                 when RBS::AST::Members::Alias
                   symbols << SymbolInformation.new(
                     name: name,
-                    location: decl.location,
+                    location: location,
                     kind: LSP::Constant::SymbolKind::METHOD,
                     container_name: container_name
                   )
                 when RBS::AST::Members::AttrAccessor, RBS::AST::Members::AttrReader, RBS::AST::Members::AttrWriter
                   symbols << SymbolInformation.new(
                     name: name,
-                    location: decl.location,
+                    location: location,
                     kind: LSP::Constant::SymbolKind::PROPERTY,
                     container_name: container_name
                   )
@@ -133,7 +139,7 @@ module Steep
                   if decl.ivar_name
                     symbols << SymbolInformation.new(
                       name: decl.ivar_name.to_s,
-                      location: decl.location,
+                      location: location,
                       kind: LSP::Constant::SymbolKind::FIELD,
                       container_name: container_name
                     )
@@ -144,6 +150,7 @@ module Steep
               next unless SignatureSymbolProvider.test_const_name(query, entry.const_name)
 
               entry.declarations.each do |decl|
+                next unless decl.location
                 next unless assigned?(Pathname(decl.location.buffer.name))
 
                 symbols << SymbolInformation.new(
@@ -157,12 +164,14 @@ module Steep
               next unless SignatureSymbolProvider.test_global_name(query, entry.global_name)
 
               entry.declarations.each do |decl|
+                next unless decl.location
                 next unless assigned?(Pathname(decl.location.buffer.name))
 
                 symbols << SymbolInformation.new(
                   name: decl.name.to_s,
                   location: decl.location,
-                  kind: LSP::Constant::SymbolKind::VARIABLE
+                  kind: LSP::Constant::SymbolKind::VARIABLE,
+                  container_name: nil
                 )
               end
             end

data/lib/steep/node_helper.rb

@@ -25,6 +25,8 @@ module Steep
 
     def value_node?(node)
       case node.type
+      when :self
+        true
       when :true, :false, :str, :sym, :int, :float, :nil
         true
       when :lvar
@@ -45,5 +47,175 @@ module Steep
         false
       end
     end
+
+    def deconstruct_if_node(node)
+      if node.type == :if
+        [
+          node.children[0],
+          node.children[1],
+          node.children[2],
+          _ = node.location
+        ]
+      end
+    end
+
+    def deconstruct_if_node!(node)
+      deconstruct_if_node(node) or raise
+    end
+
+    def test_if_node(node)
+      if (a, b, c, d = deconstruct_if_node(node))
+        yield(a, b, c, d)
+      else
+        false
+      end
+    end
+
+    def deconstruct_whileish_node(node)
+      case node.type
+      when :while, :until, :while_post, :until_post
+        [
+          node.children[0],
+          node.children[1],
+          _ = node.location
+        ]
+      end
+    end
+
+    def deconstruct_whileish_node!(node)
+      deconstruct_whileish_node(node) or raise
+    end
+
+    def test_whileish_node(node)
+      if (a, b, c = deconstruct_whileish_node(node))
+        yield(a, b, c)
+      else
+        false
+      end
+    end
+
+    def deconstruct_case_node(node)
+      case node.type
+      when :case
+        cond, *whens, else_ = node.children
+        [
+          cond,
+          whens,
+          else_,
+          _ = node.loc
+        ]
+      end
+    end
+
+    def deconstruct_case_node!(node)
+      deconstruct_case_node(node) or raise
+    end
+
+    def test_case_node(node)
+      if (a, b, c, d = deconstruct_case_node(node))
+        yield a, b, c, d
+      else
+        false
+      end
+    end
+
+    def deconstruct_when_node(node)
+      case node.type
+      when :when
+        *conds, body = node.children
+        [
+          conds,
+          body,
+          _ = node.loc
+        ]
+      end
+    end
+
+    def deconstruct_when_node!(node)
+      deconstruct_when_node(node) or raise
+    end
+
+    def test_when_node(node)
+      if (a, b, c = deconstruct_when_node(node))
+        yield a, b, c
+      else
+        false
+      end
+    end
+
+    def deconstruct_rescue_node(node)
+      case node.type
+      when :rescue
+        body, *resbodies, else_ = node.children
+
+        [
+          body,
+          resbodies,
+          else_,
+          _ = node.loc
+        ]
+      end
+    end
+
+    def deconstruct_rescue_node!(node)
+      deconstruct_rescue_node(node) or raise
+    end
+
+    def test_rescue_node(node)
+      if (a, b, c, d = deconstruct_rescue_node(node))
+        yield a, b, c, d
+      else
+        false
+      end
+    end
+
+    def deconstruct_resbody_node(node)
+      case node.type
+      when :resbody
+        [
+          node.children[0],
+          node.children[1],
+          node.children[2],
+          _  = node.loc
+        ]
+      end
+    end
+
+    def deconstruct_resbody_node!(node)
+      deconstruct_resbody_node(node) or raise
+    end
+
+    def test_resbody_node(node)
+      if (a, b, c, d = deconstruct_resbody_node(node))
+        yield a, b, c, d
+      else
+        false
+      end
+    end
+
+    def deconstruct_send_node(node)
+      case node.type
+      when :send, :csend
+        receiver, selector, *args = node.children
+        [
+          receiver,
+          selector,
+          args,
+          _  = node.loc
+        ]
+      end
+    end
+
+    def deconstruct_send_node!(node)
+      deconstruct_send_node(node) or raise
+    end
+
+    def test_send_node(node)
+      if (a, b, c, d = deconstruct_send_node(node))
+        yield a, b, c, d
+      else
+        false
+      end
+    end
   end
 end

data/lib/steep/server/base_worker.rb

@@ -40,6 +40,8 @@ module Steep
       def run
         tags = Steep.logger.formatter.current_tags.dup
         thread = Thread.new do
+          Thread.current.abort_on_exception = true
+
           Steep.logger.formatter.push_tags(*tags)
           Steep.logger.tagged "background" do
             while job = queue.pop
@@ -69,7 +71,6 @@ module Steep
             end
           end
         end
-        thread.abort_on_exception = true
 
         Steep.logger.tagged "frontend" do
           begin

data/lib/steep/server/change_buffer.rb

@@ -16,7 +16,7 @@ module Steep
           buffered_changes.clear
           copy
         end
-        
+
         if block_given?
           yield changes
         else
@@ -41,21 +41,23 @@ module Steep
 
       def collect_changes(request)
         push_buffer do |changes|
-          path = project.relative_path(Steep::PathHelper.to_pathname(request[:params][:textDocument][:uri]))
-          version = request[:params][:textDocument][:version]
-          Steep.logger.info { "Updating source: path=#{path}, version=#{version}..." }
+          if path = Steep::PathHelper.to_pathname(request[:params][:textDocument][:uri])
+            path = project.relative_path(path)
+            version = request[:params][:textDocument][:version]
+            Steep.logger.info { "Updating source: path=#{path}, version=#{version}..." }
 
-          changes[path] ||= []
-          request[:params][:contentChanges].each do |change|
-            changes[path] << Services::ContentChange.new(
-              range: change[:range]&.yield_self {|range|
-                [
-                  range[:start].yield_self {|pos| Services::ContentChange::Position.new(line: pos[:line] + 1, column: pos[:character]) },
-                  range[:end].yield_self {|pos| Services::ContentChange::Position.new(line: pos[:line] + 1, column: pos[:character]) }
-                ]
-              },
-              text: change[:text]
-            )
+            changes[path] ||= []
+            request[:params][:contentChanges].each do |change|
+              changes[path] << Services::ContentChange.new(
+                range: change[:range]&.yield_self {|range|
+                  [
+                    range[:start].yield_self {|pos| Services::ContentChange::Position.new(line: pos[:line] + 1, column: pos[:character]) },
+                    range[:end].yield_self {|pos| Services::ContentChange::Position.new(line: pos[:line] + 1, column: pos[:character]) }
+                  ]
+                },
+                text: change[:text]
+              )
+            end
           end
         end
       end

data/lib/steep/server/interaction_worker.rb

@@ -361,6 +361,26 @@ module Steep
               new_text: item.identifier.to_s
             )
           )
+        when Services::CompletionProvider::TypeNameItem
+          kind =
+            case
+            when item.absolute_type_name.class?
+              LSP::Constant::CompletionItemKind::CLASS
+            when item.absolute_type_name.interface?
+              LSP::Constant::CompletionItemKind::INTERFACE
+            when item.absolute_type_name.alias?
+              LSP::Constant::CompletionItemKind::FIELD
+            end
+          LSP::Interface::CompletionItem.new(
+            label: item.relative_type_name.to_s,
+            kind: kind,
+            label_details: nil,
+            documentation: LSPFormatter.markup_content { LSPFormatter.format_completion_docs(item) },
+            text_edit: LSP::Interface::TextEdit.new(
+              range: range,
+              new_text: item.relative_type_name.to_s
+            )
+          )
         end
       end
 

data/lib/steep/server/lsp_formatter.rb

@@ -231,6 +231,25 @@ module Steep
           format_method_item_doc(item.method_types, method_names, comments)
         when Services::CompletionProvider::GeneratedMethodNameItem
           format_method_item_doc(item.method_types, [], {}, "🤖 Generated method for receiver type")
+        when Services::CompletionProvider::TypeNameItem
+          io = StringIO.new
+
+          io.puts <<~MD
+            ```rbs
+            #{declaration_summary(item.decl)}
+            ```
+          MD
+
+          unless item.comments.empty?
+            io.puts "----"
+            io.puts format_comments(
+              item.comments.map {|comment|
+                [item.absolute_type_name.relative!.to_s, comment] #: [String, RBS::AST::Comment?]
+              }
+            )
+          end
+
+          io.string
         end
       end
 
@@ -296,7 +315,7 @@ module Steep
 
         io = StringIO.new
         if header
-          io.puts "### 📚 #{header}"
+          io.puts "### 📚 #{header.gsub("_", "\\_")}"
           io.puts
         end
         io.puts comment.string.rstrip.gsub(/^[ \t]*<!--(?~-->)-->\n/, "").gsub(/\A([ \t]*\n)+/, "")