steep-relaxed 1.9.3.3

data/lib/steep/server/lsp_formatter.rb

@@ -0,0 +1,455 @@
+module Steep
+  module Server
+    module LSPFormatter
+      include Services
+
+      LSP = LanguageServer::Protocol
+
+      module_function
+
+      def markup_content(string = nil, &block)
+        if block
+          string = yield()
+        end
+
+        if string
+          LSP::Interface::MarkupContent.new(kind: LSP::Constant::MarkupKind::MARKDOWN, value: string)
+        end
+      end
+
+      def format_hover_content(content)
+        case content
+        when HoverProvider::Ruby::VariableContent
+          local_variable(content.name, content.type)
+
+        when HoverProvider::Ruby::MethodCallContent
+          io = StringIO.new
+          call = content.method_call
+
+          case call
+          when TypeInference::MethodCall::Typed
+            io.puts <<~MD
+              ```rbs
+              #{call.actual_method_type.type.return_type}
+              ```
+
+              ----
+            MD
+
+            method_decls = call.method_decls.sort_by {|decl| decl.method_name.to_s }
+            method_types = method_decls.map(&:method_type)
+
+            if call.is_a?(TypeInference::MethodCall::Special)
+              method_types = [
+                call.actual_method_type.with(
+                  type: call.actual_method_type.type.with(return_type: call.return_type)
+                )
+              ]
+
+              header = <<~MD
+                **💡 Custom typing rule applies**
+
+                ----
+              MD
+            end
+          when TypeInference::MethodCall::Error
+            method_decls = call.method_decls.sort_by {|decl| decl.method_name.to_s }
+            method_types = method_decls.map {|decl| decl.method_type }
+
+            header = <<~MD
+              **🚨 No compatible method type found**
+
+              ----
+            MD
+          end
+
+          method_names = method_decls.map {|decl| decl.method_name.relative }
+          docs = method_decls.map {|decl| [decl.method_name, decl.method_def.comment] }.to_h
+
+          if header
+            io.puts header
+          end
+
+          io.puts(
+            format_method_item_doc(method_types, method_names, docs)
+          )
+
+          io.string
+
+        when HoverProvider::Ruby::DefinitionContent
+          io = StringIO.new
+
+          method_name =
+            if content.method_name.is_a?(SingletonMethodName)
+              "self.#{content.method_name.method_name}"
+            else
+              content.method_name.method_name
+            end
+
+          prefix_size = "def ".size + method_name.size
+          method_types = content.definition.method_types
+
+          io.puts <<~MD
+            ```rbs
+            def #{method_name}: #{method_types.join("\n" + " "*prefix_size + "| ") }
+            ```
+
+            ----
+          MD
+
+          if content.definition.method_types.size > 1
+            io.puts "**Internal method type**"
+            io.puts <<~MD
+              ```rbs
+              #{content.method_type}
+              ```
+
+              ----
+            MD
+          end
+
+          io.puts format_comments(
+            content.definition.comments.map {|comment|
+              [content.method_name.relative.to_s, comment] #: [String, RBS::AST::Comment?]
+            }
+          )
+
+          io.string
+        when HoverProvider::Ruby::ConstantContent
+          io = StringIO.new
+
+          decl_summary =
+            case
+            when decl = content.class_decl
+              declaration_summary(decl.primary.decl)
+            when decl = content.constant_decl
+              declaration_summary(decl.decl)
+            when decl = content.class_alias
+              declaration_summary(decl.decl)
+            end
+
+          io.puts <<~MD
+            ```rbs
+            #{decl_summary}
+            ```
+          MD
+
+          comments = content.comments.map {|comment|
+            [content.full_name.relative!.to_s, comment] #: [String, RBS::AST::Comment?]
+          }
+
+          unless comments.all?(&:nil?)
+            io.puts "----"
+            io.puts format_comments(comments)
+          end
+
+          io.string
+        when HoverProvider::Ruby::TypeContent
+          <<~MD
+            ```rbs
+            #{content.type}
+            ```
+          MD
+
+        when HoverProvider::Ruby::TypeAssertionContent
+          <<~MD
+            ```rbs
+            #{content.asserted_type}
+            ```
+
+            ↑ Converted from `#{content.original_type.to_s}`
+          MD
+
+        when HoverProvider::RBS::TypeAliasContent, HoverProvider::RBS::InterfaceContent
+          io = StringIO.new()
+
+          io.puts <<~MD
+            ```rbs
+            #{declaration_summary(content.decl)}
+            ```
+          MD
+
+          if comment = content.decl.comment
+            io.puts
+            io.puts "----"
+
+            io.puts format_comment(comment, header: content.decl.name.relative!.to_s)
+          end
+
+          io.string
+
+        when HoverProvider::RBS::ClassContent
+          io = StringIO.new
+
+          io << <<~MD
+          ```rbs
+          #{declaration_summary(content.decl)}
+          ```
+          MD
+
+          if content.decl.comment
+            io.puts "----"
+
+            class_name =
+              case content.decl
+              when RBS::AST::Declarations::ModuleAlias, RBS::AST::Declarations::ClassAlias
+                content.decl.new_name
+              when RBS::AST::Declarations::Class, RBS::AST::Declarations::Module
+                content.decl.name
+              else
+                raise
+              end
+
+            io << format_comments([[class_name.relative!.to_s, content.decl.comment]])
+          end
+
+          io.string
+        else
+          raise content.class.to_s
+        end
+      end
+
+      def format_completion_docs(item)
+        case item
+        when Services::CompletionProvider::LocalVariableItem
+          local_variable(item.identifier, item.type)
+        when Services::CompletionProvider::ConstantItem
+          io = StringIO.new
+
+          io.puts <<~MD
+            ```rbs
+            #{declaration_summary(item.decl)}
+            ```
+          MD
+
+          unless item.comments.all?(&:nil?)
+            io.puts "----"
+            io.puts format_comments(
+              item.comments.map {|comment|
+                [item.full_name.relative!.to_s, comment] #: [String, RBS::AST::Comment?]
+              }
+            )
+          end
+
+          io.string
+        when Services::CompletionProvider::InstanceVariableItem
+          instance_variable(item.identifier, item.type)
+        when Services::CompletionProvider::SimpleMethodNameItem
+          format_method_item_doc(item.method_types, [], { item.method_name => item.method_member.comment })
+        when Services::CompletionProvider::ComplexMethodNameItem
+          method_names = item.method_names.map(&:relative).uniq
+          comments = item.method_definitions.transform_values {|member| member.comment }
+          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
+        when Services::CompletionProvider::KeywordArgumentItem
+          <<~MD
+            **Keyword argument**: `#{item.identifier}`
+          MD
+        else
+          raise
+        end
+      end
+
+      def format_rbs_completion_docs(type_name, decl, comments)
+        io = StringIO.new
+
+        io.puts <<~MD
+        ```rbs
+        #{declaration_summary(decl)}
+        ```
+        MD
+
+        unless comments.empty?
+          io.puts
+          io.puts "----"
+
+          io.puts format_comments(
+            comments.map {|comment|
+              [type_name.relative!.to_s, comment] #: [String, RBS::AST::Comment?]
+            }
+          )
+        end
+
+        io.string
+      end
+
+      def format_comments(comments)
+        io = StringIO.new
+
+        with_docs = [] #: Array[[String, RBS::AST::Comment]]
+        without_docs = [] #: Array[String]
+
+        comments.each do |title, comment|
+          if comment
+            with_docs << [title, comment]
+          else
+            without_docs << title
+          end
+        end
+
+        unless with_docs.empty?
+          with_docs.each do |title, comment|
+            io.puts format_comment(comment, header: title)
+            io.puts
+          end
+
+          unless without_docs.empty?
+            io.puts
+            io.puts "----"
+            if without_docs.size == 1
+              io.puts "🔍 One more definition without docs"
+            else
+              io.puts "🔍 #{without_docs.size} more definitions without docs"
+            end
+          end
+        end
+
+        io.string
+      end
+
+      def format_comment(comment, header: nil, &block)
+        return unless comment
+
+        io = StringIO.new
+        if header
+          io.puts "### 📚 #{header.gsub("_", "\\_")}"
+          io.puts
+        end
+        io.puts comment.string.rstrip.gsub(/^[ \t]*<!--(?~-->)-->\n/, "").gsub(/\A([ \t]*\n)+/, "")
+
+        if block
+          yield io.string
+        else
+          io.string
+        end
+      end
+
+      def local_variable(name, type)
+        <<~MD
+          **Local variable** `#{name}: #{type}`
+        MD
+      end
+
+      def instance_variable(name, type)
+        <<~MD
+          **Instance variable** `#{name}: #{type}`
+        MD
+      end
+
+      def name_and_params(name, params)
+        if params.empty?
+          "#{name}"
+        else
+          ps = params.each.map do |param|
+            s = +""
+            if param.unchecked?
+              s << "unchecked "
+            end
+            case param.variance
+            when :invariant
+              # nop
+            when :covariant
+              s << "out "
+            when :contravariant
+              s << "in "
+            end
+            s << param.name.to_s
+
+            if param.upper_bound_type
+              s << " < #{param.upper_bound_type.to_s}"
+            end
+
+            s
+          end
+
+          "#{name}[#{ps.join(", ")}]"
+        end
+      end
+
+      def name_and_args(name, args)
+        if args.empty?
+          "#{name}"
+        else
+          "#{name}[#{args.map(&:to_s).join(", ")}]"
+        end
+      end
+
+      def declaration_summary(decl)
+        # Note that all names in the declarations is absolute
+        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.relative!, decl.type_params)}#{super_class}"
+        when RBS::AST::Declarations::Module
+          self_type = unless decl.self_types.empty?
+                        " : #{decl.self_types.map {|s| name_and_args(s.name, s.args) }.join(", ")}"
+                      end
+          "module #{name_and_params(decl.name.relative!, decl.type_params)}#{self_type}"
+        when RBS::AST::Declarations::TypeAlias
+          "type #{name_and_params(decl.name.relative!, decl.type_params)} = #{decl.type}"
+        when RBS::AST::Declarations::Interface
+          "interface #{name_and_params(decl.name.relative!, decl.type_params)}"
+        when RBS::AST::Declarations::ClassAlias
+          "class #{decl.new_name.relative!} = #{decl.old_name}"
+        when RBS::AST::Declarations::ModuleAlias
+          "module #{decl.new_name.relative!} = #{decl.old_name}"
+        when RBS::AST::Declarations::Global
+          "#{decl.name}: #{decl.type}"
+        when RBS::AST::Declarations::Constant
+          "#{decl.name.relative!}: #{decl.type}"
+        end
+      end
+
+      def format_method_item_doc(method_types, method_names, comments, footer = "")
+        io = StringIO.new
+
+        io.puts "**Method type**:"
+        io.puts "```rbs"
+        if method_types.size == 1
+          io.puts method_types[0].to_s
+        else
+          io.puts "  #{method_types.join("\n| ")}"
+        end
+        io.puts "```"
+
+        if method_names.size > 1
+          io.puts "**Possible methods**: #{method_names.map {|type| "`#{type.to_s}`" }.join(", ")}"
+          io.puts
+        end
+
+        unless comments.each_value.all?(&:nil?)
+          io.puts "----"
+          io.puts format_comments(comments.transform_keys {|name| name.relative.to_s }.entries)
+        end
+
+        unless footer.empty?
+          io.puts footer.rstrip
+        end
+
+        io.string
+      end
+    end
+  end
+end