steep 1.4.0.dev.2 → 1.4.0.dev.4

data/sig/steep/server/interaction_worker.rbs

@@ -1,41 +1,76 @@
+use LanguageServer::Protocol::Transport::Io::*, Thread::Queue, RBS::AST::Comment
+use Steep::Services::CompletionProvider, Steep::Services::TypeNameCompletion
+use RBS::TypeName, RBS::Namespace
+
 module Steep
   module Server
     class InteractionWorker < BaseWorker
       include ChangeBuffer
 
-      ApplyChangeJob: untyped
+      class ApplyChangeJob
+      end
+
+      class HoverJob
+        attr_reader id: String
+
+        attr_reader path: Pathname
+
+        attr_reader line: Integer
+
+        attr_reader column: Integer
+
+        def initialize: (id: String, path: Pathname, line: Integer, column: Integer) -> void
+      end
+
+      class CompletionJob
+        attr_reader id: String
+
+        attr_reader path: Pathname
+
+        attr_reader line: Integer
+
+        attr_reader column: Integer
+
+        attr_reader trigger: String
+
+        def initialize: (id: String, path: Pathname, line: Integer, column: Integer, trigger: String) -> void
+      end
+
+      class SignatureHelpJob
+        attr_reader id: String
 
-      HoverJob: untyped
+        attr_reader path: Pathname
 
-      CompletionJob: untyped
+        attr_reader line: Integer
 
-      LSP: untyped
+        attr_reader column: Integer
 
-      attr_reader service: untyped
+        def initialize: (id: String, path: Pathname, line: Integer, column: Integer) -> void
+      end
 
-      def initialize: (project: untyped, reader: untyped, writer: untyped, ?queue: untyped) -> void
+      type job = ApplyChangeJob | HoverJob | CompletionJob | SignatureHelpJob
 
-      def handle_job: (untyped job) -> untyped
+      module LSP = LanguageServer::Protocol
 
-      def handle_request: (untyped request) -> untyped
+      attr_reader service: Services::TypeCheckService
 
-      def process_hover: (untyped job) -> untyped
+      def initialize: (project: Project, reader: Reader, writer: Writer, ?queue: Queue) -> void
 
-      def process_completion: (untyped job) -> untyped
+      def handle_job: (job) -> void
 
-      def format_completion_item_for_rbs: (Services::SignatureService sig_service, untyped type_name, untyped context, untyped job, untyped prefix) -> (nil | untyped)
+      type lsp_request = { id: String, method: String, params: untyped }
 
-      def format_comment: (untyped comment) -> (untyped | nil)
+      def handle_request: (lsp_request) -> void
 
-      def format_comments: (Array[RBS::AST::Comment] comments) -> untyped?
+      def process_hover: (HoverJob job) -> LanguageServer::Protocol::Interface::Hover?
 
-      def format_completion_item: (untyped item) -> untyped
+      def process_completion: (CompletionJob job) -> LanguageServer::Protocol::Interface::CompletionList?
 
-      def method_type_to_snippet: (untyped method_type) -> ::String
+      def process_signature_help: (SignatureHelpJob) -> LanguageServer::Protocol::Interface::SignatureHelp?
 
-      def params_to_snippet: (untyped fun) -> untyped
+      def format_completion_item_for_rbs: (Services::SignatureService, RBS::TypeName, CompletionJob job, String complete_text, Integer prefix_size) -> LanguageServer::Protocol::Interface::CompletionItem
 
-      def relative_name_in_context: (untyped type_name, untyped context) -> untyped
+      def format_completion_item: (CompletionProvider::item item) -> LanguageServer::Protocol::Interface::CompletionItem
     end
   end
 end

data/sig/steep/server/lsp_formatter.rbs

@@ -1,38 +1,63 @@
+use RBS::TypeName
+
 module Steep
   module Server
+    # LSPFormatter translates hover content and completion item to markdown string
+    #
+    # The class has four main methods:
+    #
+    # * `markup_content` translates a string to `MarkupContent` object
+    # * `format_hover_content` translates a hover content to Markdown string
+    # * `format_completion_docs` translates a completion item to a documentation
+    # * `format_rbs_competion_docs` generates docs for completion item of RBS
+    #
     module LSPFormatter
       include Services
 
-      class CommentBuilder
-        @array: Array[String]
+      module LSP = LanguageServer::Protocol
+
+      # Translate given String to MarkupContent
+      #
+      def self?.markup_content: (String?) -> LanguageServer::Protocol::Interface::MarkupContent?
+                              | () { () -> String? } -> LanguageServer::Protocol::Interface::MarkupContent?
 
-        def initialize: () -> void
+      # Translates a hover content to String
+      #
+      def self?.format_hover_content: (Services::HoverProvider::Ruby::content | Services::HoverProvider::RBS::content) -> String
 
-        def self.build: () { (CommentBuilder) -> void } -> String
+      # Translates a completion item to String
+      def self?.format_completion_docs: (Services::CompletionProvider::item) -> String
 
-        def to_s: () -> String
+      # Translates a completion item for RBS to String
+      def self?.format_rbs_completion_docs: (TypeName, summarizable_decl, Array[RBS::AST::Comment]) -> String
 
-        def <<: (String? string) -> void
+      def self?.format_comment: (RBS::AST::Comment?, ?header: String?) -> String?
+                              | (RBS::AST::Comment?, ?header: String?) { (String) -> void } -> void
 
-        def push: () { (String) -> void } -> void
-      end
+      def self?.format_comments: (Array[[String, RBS::AST::Comment?]]) -> String
 
-      def self?.format_hover_content: (Services::HoverProvider::Ruby::content | Services::HoverProvider::RBS::content) -> untyped
+      def self?.local_variable: (Symbol, AST::Types::t) -> String
 
-      def self?.to_list: [A < Object] (Enumerable[A] collection) ?{ (A) -> String } -> String
+      def self?.instance_variable: (Symbol, AST::Types::t) -> String
 
-      def self?.name_and_args: (untyped name, untyped args) -> ::String
+      # Renders type application
+      def self?.name_and_args: (TypeName name, Array[RBS::Types::t] args) -> String
 
-      def self?.name_and_params: (untyped name, untyped params) -> ::String
+      # Renders generic type definition
+      def self?.name_and_params: (TypeName name, Array[RBS::AST::TypeParam] params) -> String
 
-      type summarizable_decl = ::RBS::AST::Declarations::Class
-                             | ::RBS::AST::Declarations::Module
-                             | ::RBS::AST::Declarations::Interface
-                             | ::RBS::AST::Declarations::TypeAlias
-                             | ::RBS::AST::Declarations::ClassAlias
-                             | ::RBS::AST::Declarations::ModuleAlias
+      type summarizable_decl = RBS::AST::Declarations::Class
+                             | RBS::AST::Declarations::Module
+                             | RBS::AST::Declarations::Interface
+                             | RBS::AST::Declarations::TypeAlias
+                             | RBS::AST::Declarations::ClassAlias
+                             | RBS::AST::Declarations::ModuleAlias
+                             | RBS::AST::Declarations::Global
+                             | RBS::AST::Declarations::Constant
 
       def self?.declaration_summary: (summarizable_decl) -> String
+
+      def self?.format_method_item_doc: (Array[_ToS], Array[method_name], Hash[method_name, RBS::AST::Comment?], ?String footer) -> String
     end
   end
 end

data/sig/steep/server/master.rbs

@@ -1,7 +1,7 @@
 module Steep
   module Server
     class Master
-      LSP: singleton(LanguageServer::Protocol)
+      module LSP = LanguageServer::Protocol
 
       class TypeCheckRequest
         attr_reader guid: String

data/sig/steep/server/type_check_worker.rbs

@@ -1,3 +1,5 @@
+use Steep::Services::*, LanguageServer::Protocol as LSP
+
 module Steep
   module Server
     # TypeCheckWorker provides two features:
@@ -15,9 +17,9 @@ module Steep
     class TypeCheckWorker < BaseWorker
       attr_reader project: Project
 
-      attr_reader assignment: Services::PathAssignment
+      attr_reader assignment: PathAssignment
 
-      attr_reader service: Services::TypeCheckService
+      attr_reader service: TypeCheckService
 
       attr_reader commandline_args: Array[String]
 
@@ -95,9 +97,9 @@ module Steep
 
       def initialize: (
         project: Project,
-        reader: LanguageServer::Protocol::Transport::Io::Reader,
-        writer: LanguageServer::Protocol::Transport::Io::Writer,
-        assignment: Services::PathAssignment,
+        reader: LSP::Transport::Io::Reader,
+        writer: LSP::Transport::Io::Writer,
+        assignment: PathAssignment,
         commandline_args: Array[String]
       ) -> void
 

data/sig/steep/server/worker_process.rbs

@@ -1,3 +1,5 @@
+use LanguageServer::Protocol as LSP
+
 module Steep
   module Server
     # WorkerProcess class represents a worker process
@@ -21,9 +23,9 @@ module Steep
         def pid: () -> Integer
       end
 
-      attr_reader reader: LanguageServer::Protocol::Transport::Io::Reader
+      attr_reader reader: LSP::Transport::Io::Reader
 
-      attr_reader writer: LanguageServer::Protocol::Transport::Io::Writer
+      attr_reader writer: LSP::Transport::Io::Writer
 
       attr_reader stderr: IO?
 
@@ -34,8 +36,8 @@ module Steep
       attr_reader index: Integer?
 
       def initialize: (
-        reader: LanguageServer::Protocol::Transport::Io::Reader,
-        writer: LanguageServer::Protocol::Transport::Io::Writer,
+        reader: LSP::Transport::Io::Reader,
+        writer: LSP::Transport::Io::Writer,
         stderr: IO?,
         wait_thread: Thread & _ProcessWaitThread,
         name: String,

data/sig/steep/services/completion_provider.rbs

@@ -1,6 +1,10 @@
+use RBS::Environment, RBS::TypeName
+use Steep::TypeInference::MethodCall
+
 module Steep
   module Services
     class CompletionProvider
+      # Cursor position
       class Position
         attr_reader line: Integer
 
@@ -40,7 +44,7 @@ module Steep
       end
 
       class ConstantItem
-        attr_reader env: RBS::Environment
+        attr_reader env: Environment
 
         attr_reader identifier: Symbol
 
@@ -48,35 +52,108 @@ module Steep
 
         attr_reader type: AST::Types::t
 
-        attr_reader full_name: RBS::TypeName
+        attr_reader full_name: TypeName
 
-        def initialize: (env: RBS::Environment, identifier: Symbol, range: Range, type: AST::Types::t, full_name: RBS::TypeName) -> void
+        def initialize: (env: Environment, identifier: Symbol, range: Range, type: AST::Types::t, full_name: TypeName) -> void
 
         def class?: () -> bool
 
         def module?: () -> bool
 
-        def comments: () -> Array[RBS::AST::Comment]
+        def comments: () -> Array[RBS::AST::Comment?]
+
+        type const_decl = RBS::AST::Declarations::Constant
+                        | RBS::AST::Declarations::Class
+                        | RBS::AST::Declarations::Module
+                        | RBS::AST::Declarations::ClassAlias
+                        | RBS::AST::Declarations::ModuleAlias
+
+        def decl: () -> const_decl
       end
 
-      class MethodNameItem
+      # Method name completion item with *simple* receiver type
+      #
+      # Instance type, Singleton type, Interface type is simple.
+      # The item may have multiple overloads, but must have single method definition source.
+      #
+      class SimpleMethodNameItem
         attr_reader identifier: Symbol
 
         attr_reader range: Range
 
-        attr_reader receiver_type: AST::Types::t
+        attr_reader receiver_type: AST::Types::Name::Instance | AST::Types::Name::Interface | AST::Types::Name::Singleton
 
-        attr_reader method_type: untyped
+        attr_reader method_types: Array[RBS::MethodType]
 
-        attr_reader method_decls: Array[TypeInference::MethodCall::MethodDecl]
+        attr_reader method_name: method_name
 
-        def initialize: (identifier: Symbol, range: Range, method_type: untyped, method_decls: Array[TypeInference::MethodCall::MethodDecl]) -> void
+        attr_reader method_member: RBS::Definition::Method::method_member
 
-        def comment: () -> RBS::AST::Comment?
+        def initialize: (
+          identifier: Symbol,
+          range: Range,
+          receiver_type: AST::Types::Name::Instance | AST::Types::Name::Interface | AST::Types::Name::Singleton,
+          method_name: method_name,
+          method_types: Array[RBS::MethodType],
+          method_member: RBS::Definition::Method::method_member
+        ) -> void
 
-        def inherited?: () -> bool
+        %a{pure} def comment: () -> RBS::AST::Comment?
       end
 
+      # Method name completion item with *complex* receiver type
+      #
+      # The item may have multiple overloads and multiple method declarations.
+      #
+      class ComplexMethodNameItem
+        attr_reader identifier: Symbol
+
+        attr_reader range: Range
+
+        attr_reader reeiver_type: AST::Types::t
+
+        attr_reader method_types: Array[RBS::MethodType]
+
+        attr_reader method_decls: Array[MethodCall::MethodDecl]
+
+        def initialize: (
+          identifier: Symbol,
+          range: Range,
+          method_types: Array[RBS::MethodType],
+          method_decls: Array[MethodCall::MethodDecl],
+          receiver_type: AST::Types::t
+        ) -> void
+
+        def method_names: () -> Array[method_name]
+
+        def method_definitions: () -> Hash[method_name, RBS::Definition::Method::method_member]
+
+        def defining_method_name: (TypeName, Symbol name, RBS::Definition::Method::method_member) -> method_name
+      end
+
+      # Method name completion item for generated methods, like `#first` in tuple types
+      #
+      # The generated methods doesn't have associated `MethodDecl`.
+      #
+      class GeneratedMethodNameItem
+        attr_reader identifier: Symbol
+
+        attr_reader range: Range
+
+        attr_reader reeiver_type: AST::Types::t
+
+        attr_reader method_types: Array[RBS::MethodType]
+
+        def initialize: (
+          identifier: Symbol,
+          range: Range,
+          receiver_type: AST::Types::t,
+          method_types: Array[RBS::MethodType]
+        ) -> void
+      end
+
+      type item = InstanceVariableItem | LocalVariableItem | ConstantItem | SimpleMethodNameItem | ComplexMethodNameItem | GeneratedMethodNameItem
+
       attr_reader source_text: String
 
       attr_reader path: Pathname
@@ -89,41 +166,42 @@ module Steep
 
       attr_reader typing: Typing
 
-      def initialize: (source_text: untyped, path: untyped, subtyping: untyped) -> void
+      def initialize: (source_text: String, path: Pathname, subtyping: Subtyping::Check) -> void
 
-      def type_check!: (untyped text, line: untyped, column: untyped) -> untyped
+      def type_check!: (String text, line: Integer, column: Integer) -> void
 
-      def env: () -> untyped
+      def env: () -> Environment
 
-      def run: (line: untyped, column: untyped) -> untyped
+      def run: (line: Integer, column: Integer) -> Array[item]
 
-      def range_from_loc: (untyped loc) -> untyped
+      def range_from_loc: (Parser::Source::Range loc) -> Range
 
-      def at_end?: (untyped pos, of: untyped) -> (untyped | nil)
+      def at_end?: (Position pos, of: Parser::Source::Map | Parser::Source::Range | nil) -> boolish
 
-      def range_for: (untyped position, ?prefix: ::String) -> untyped
+      def range_for: (Position position, ?prefix: ::String) -> Range
 
-      def items_for_trigger: (position: untyped) -> (::Array[untyped] | untyped)
+      def items_for_trigger: (position: Position) -> Array[item]
 
-      def items_for_dot: (position: Position) -> ::Array[MethodNameItem]
+      def items_for_dot: (position: Position) -> Array[item]
 
-      def items_for_colon2: (position: untyped) -> untyped
+      def items_for_colon2: (position: Position) -> Array[item]
 
-      def items_for_atmark: (position: untyped) -> (::Array[untyped] | untyped)
+      def items_for_atmark: (position: Position) -> Array[item]
 
-      def method_items_for_receiver_type: (untyped `type`, include_private: untyped, prefix: untyped, position: untyped, items: untyped) -> untyped
+      def method_items_for_receiver_type: (AST::Types::t, include_private: bool, prefix: String, position: Position, items: Array[item]) -> void
 
-      def word_name?: (String name) -> void
+      def word_name?: (String name) -> bool
 
-      def local_variable_items_for_context: (TypeInference::Context context, position: Position, prefix: String, items: Array[LocalVariableItem]) -> void
+      def local_variable_items_for_context: (TypeInference::Context context, position: Position, prefix: String, items: Array[item]) -> void
 
-      def constant_items_for_context: (TypeInference::Context context, position: Position, prefix: String, items: Array[ConstantItem], ?parent: Parser::AST::Node?) -> void
+      def constant_items_for_context: (TypeInference::Context context, position: Position, prefix: String, items: Array[item], ?parent: Parser::AST::Node?) -> void
 
-      def instance_variable_items_for_context: (TypeInference::Context context, position: Position, prefix: String, items: Array[InstanceVariableItem]) -> void
+      def instance_variable_items_for_context: (TypeInference::Context context, position: Position, prefix: String, items: Array[item]) -> void
 
-      def index_for: (untyped string, line: untyped, column: untyped) -> untyped
+      def index_for: (String, line: Integer, column: Integer) -> Integer
 
       def disallowed_method?: (Symbol name) -> bool
+
     end
   end
 end

data/sig/steep/services/hover_provider/rbs.rbs

@@ -1,31 +1,33 @@
+use RBS::Location, RBS::AST::Declarations, RBS::AST::Directives, RBS::TypeName, RBS::Environment
+
 module Steep
   module Services
     module HoverProvider
       class RBS
         class TypeAliasContent
-          attr_reader location: ::RBS::Location[untyped, untyped]
+          attr_reader location: Location[untyped, untyped]
 
-          attr_reader decl: ::RBS::AST::Declarations::TypeAlias
+          attr_reader decl: Declarations::TypeAlias
 
-          def initialize: (location: ::RBS::Location[untyped, untyped], decl: ::RBS::AST::Declarations::TypeAlias) -> void
+          def initialize: (location: Location[untyped, untyped], decl: Declarations::TypeAlias) -> void
         end
 
         class ClassContent
-          attr_reader location: ::RBS::Location[untyped, untyped]
+          attr_reader location: Location[untyped, untyped]
 
-          type decl = ::RBS::AST::Declarations::Class | ::RBS::AST::Declarations::Module | ::RBS::AST::Declarations::ClassAlias | ::RBS::AST::Declarations::ModuleAlias
+          type decl = Declarations::Class | Declarations::Module | Declarations::ClassAlias | Declarations::ModuleAlias
 
           attr_reader decl: decl
 
-          def initialize: (location: ::RBS::Location[untyped, untyped], decl: decl) -> void
+          def initialize: (location: Location[untyped, untyped], decl: decl) -> void
         end
 
         class InterfaceContent
-          attr_reader location: ::RBS::Location[untyped, untyped]
+          attr_reader location: Location[untyped, untyped]
 
-          attr_reader decl: ::RBS::AST::Declarations::Interface
+          attr_reader decl: Declarations::Interface
 
-          def initialize: (location: ::RBS::Location[untyped, untyped], decl: ::RBS::AST::Declarations::Interface) -> void
+          def initialize: (location: Location[untyped, untyped], decl: Declarations::Interface) -> void
         end
 
         type content = TypeAliasContent | ClassContent | InterfaceContent
@@ -37,6 +39,8 @@ module Steep
         def project: () -> Project
 
         def content_for: (target: Project::Target, path: Pathname, line: Integer, column: Integer) -> content?
+
+        def content_for_type_name: (TypeName, env: Environment, location: Location[untyped, untyped]) -> content?
       end
     end
   end

data/sig/steep/services/signature_help_provider.rbs

@@ -0,0 +1,39 @@
+use RBS::Environment
+
+module Steep
+  module Services
+    class SignatureHelpProvider
+      module MethodCall = TypeInference::MethodCall
+
+      class Item
+        attr_reader method_type: RBS::MethodType
+
+        attr_reader comment: RBS::AST::Comment?
+
+        def initialize: (RBS::MethodType, RBS::AST::Comment?) -> void
+      end
+
+      attr_reader source: Source
+
+      attr_reader path: Pathname
+
+      attr_reader subtyping: Subtyping::Check
+
+      attr_reader buffer: RBS::Buffer
+
+      def env: () -> Environment
+
+      def initialize: (source: Source, subtyping: Subtyping::Check) -> void
+
+      # 1-origin line, 0-origin column
+      #
+      def run: (line: Integer, column: Integer) -> [Array[Item], Integer?]?
+
+      private
+
+      def signature_help_for: (Parser::AST::Node, Typing) -> [Array[Item], Integer?]?
+
+      def type_check!: (line: Integer, column: Integer) -> Typing
+    end
+  end
+end

data/sig/steep/services/type_name_completion.rbs

@@ -0,0 +1,122 @@
+use RBS::TypeName, RBS::Namespace, RBS::Environment, RBS::Resolver, RBS::AST::Directives
+
+module Steep
+  module Services
+    class TypeNameCompletion
+      module Prefix
+        type t = nil # no prefix
+               | RawIdentPrefix
+               | NamespacedIdentPrefix
+               | NamespacePrefix
+
+        # Uident or Lident is given, but no `::` (==namespace)
+        #
+        # ```
+        # Str←     Uident
+        # c←       Lident
+        # ```
+        #
+        class RawIdentPrefix
+          attr_reader ident: String
+
+          # Returns true if the `ident` is a Ruby class name
+          #
+          def const_name?: () -> bool
+
+          def initialize: (String ident) -> void
+
+          def size: () -> Integer
+        end
+
+        # Uident or Lident following a namespace
+        #
+        # ```
+        # ::L←         Uident
+        # RBS::Enviro← Uident
+        # ```
+        #
+        class NamespacedIdentPrefix
+          attr_reader namespace: Namespace
+
+          attr_reader ident: String
+
+          def const_name?: () -> bool
+
+          def initialize: (Namespace, String ident, Integer size) -> void
+
+          def size: () -> Integer
+        end
+
+        # Namespace is given
+        #
+        # ```
+        # RBS::←
+        # ::←
+        # ```
+        class NamespacePrefix
+          attr_reader namespace: Namespace
+
+          def initialize: (Namespace, Integer size) -> void
+
+          def size: () -> Integer
+        end
+
+        # line number is 1 origin (Rubyish)
+        #
+        def self.parse: (RBS::Buffer input, line: Integer, column: Integer) -> t
+      end
+
+      class Item
+        # The text to be completed
+        #
+        attr_reader complete_text: String
+
+        # The prefix
+        attr_reader prefix: Prefix::t?
+
+        # Name of the type or constant
+        #
+        attr_reader full_name: TypeName
+
+        # The text to be inserted after the prefix
+        #
+        def insert_text: () -> String
+
+        def initialize: (prefix: Prefix::t?, full_name: TypeName, complete_text: String) -> void
+      end
+
+      attr_reader env: Environment
+
+      attr_reader context: Resolver::context
+
+      attr_reader type_name_resolver: Resolver::TypeNameResolver
+
+      attr_reader map: Environment::UseMap
+
+      def initialize: (env: Environment, context: Resolver::context, dirs: Array[Directives::t]) -> void
+
+      def complete_class_name: (RBS::Buffer input, line: Integer, column: Integer) -> Array[Item]
+
+      # Find type names from the context for RBS
+      #
+      # Doesn't take account of ancestors of the context.
+      #
+      def find_type_names: (Prefix::t) -> Array[TypeName]
+
+      # Returns a pair of
+      #
+      # * Absolute type name
+      # * Relative type name in given context if possible (or absolute name)
+      #
+      def resolve_name_in_context: (TypeName) -> [TypeName, TypeName]
+
+      def format_constant_name: (TypeName) -> String
+
+      def each_type_name: () { (TypeName) -> void } -> void
+                        | () -> Enumerator[TypeName, void]
+
+      def each_outer_module: (?Resolver::context) { (Namespace) -> void } -> Namespace
+                           | () -> Enumerator[Namespace, void]
+    end
+  end
+end