steep 1.1.1 → 1.2.0.pre.1

data/sig/steep/project/pattern.rbs

@@ -1,25 +1,25 @@
 module Steep
   class Project
     class Pattern
-      attr_reader patterns: untyped
+      attr_reader patterns: Array[String]
 
-      attr_reader ignores: untyped
+      attr_reader ignores: Array[String]
 
-      attr_reader prefixes: untyped
+      attr_reader prefixes: Array[String]
 
-      attr_reader ignore_prefixes: untyped
+      attr_reader ignore_prefixes: Array[String]
 
-      attr_reader ext: untyped
+      attr_reader ext: String
 
-      def initialize: (patterns: untyped, ext: untyped, ?ignores: untyped) -> void
+      def initialize: (patterns: Array[String], ext: String, ?ignores: Array[String]) -> void
 
-      def =~: (untyped path) -> untyped
+      def =~: (Pathname | String path) -> bool
 
-      def match?: (untyped path) -> untyped
+      def match?: (Pathname path) -> bool
 
-      def ignore?: (untyped path) -> untyped
+      def ignore?: (Pathname path) -> bool
 
-      def test_string: (untyped path, untyped patterns, untyped prefixes) -> untyped
+      def test_string: (Pathname path, Array[String] patterns, Array[String] prefixes) -> bool
     end
   end
 end

data/sig/steep/project/target.rbs

@@ -5,9 +5,9 @@ module Steep
 
       attr_reader options: untyped
 
-      attr_reader source_pattern: untyped
+      attr_reader source_pattern: Pattern
 
-      attr_reader signature_pattern: untyped
+      attr_reader signature_pattern: Pattern
 
       attr_reader code_diagnostics_config: untyped
 

data/sig/steep/project.rbs

@@ -1,19 +1,26 @@
 module Steep
   class Project
-    attr_reader targets: untyped
+    attr_reader targets: Array[Target]
 
-    attr_reader steepfile_path: untyped
+    attr_reader steepfile_path: Pathname
 
-    def initialize: (steepfile_path: untyped) -> void
+    def initialize: (steepfile_path: Pathname) -> void
 
-    def base_dir: () -> untyped
+    def base_dir: () -> Pathname
 
-    def relative_path: (untyped path) -> untyped
+    def relative_path: (Pathname path) -> Pathname
 
-    def absolute_path: (untyped path) -> untyped
+    def absolute_path: (Pathname path) -> Pathname
 
-    def target_for_source_path: (untyped path) -> untyped
+    def target_for_source_path: (Pathname path) -> Target?
 
-    def targets_for_path: (untyped path) -> (::Array[untyped | ::Array[untyped]] | ::Array[nil | untyped])
+    # Returns target or array of targets that *can* contain given path
+    #
+    # * `Target` will return if `path` is a source code
+    # * `Array[Target]` will return if `path` is a signature
+    #
+    # `path` can be non-existent file.
+    #
+    def targets_for_path: (Pathname path) -> (Target | Array[Target] | nil)
   end
 end

data/sig/steep/server/base_worker.rbs

@@ -0,0 +1,49 @@
+module Steep
+  module Server
+    class BaseWorker
+      interface _Queue[A]
+        def pop: () -> A?
+
+        def <<: (A) -> A
+
+        def close: () -> void
+      end
+
+      LSP: untyped
+
+      @skip_jobs_after_shutdown: bool
+
+      @skip_job: bool
+
+      @shutdown: bool
+
+      attr_reader project: Project
+
+      attr_reader reader: LanguageServer::Protocol::Transport::Io::Reader
+
+      attr_reader writer: LanguageServer::Protocol::Transport::Io::Writer
+
+      attr_reader queue: _Queue[untyped]
+
+      class ShutdownJob
+        attr_reader id: String
+
+        def initialize: (id: String) -> void
+      end
+
+      def initialize: (project: Project, reader: LanguageServer::Protocol::Transport::Io::Reader, writer: LanguageServer::Protocol::Transport::Io::Writer) -> void
+
+      def skip_jobs_after_shutdown!: (?bool flag) -> void
+
+      def skip_jobs_after_shutdown?: () -> bool
+
+      def skip_job?: () -> bool
+
+      def handle_request: (untyped request) -> void
+
+      def handle_job: (untyped job) -> void
+
+      def run: () -> void
+    end
+  end
+end

data/sig/steep/server/change_buffer.rbs

@@ -0,0 +1,32 @@
+module Steep
+  module Server
+    module ChangeBuffer : _WithProject
+      interface _WithProject
+        def project: () -> Project
+      end
+
+      type changes = Hash[Pathname, Array[Services::ContentChange]]
+
+      attr_reader mutex: Thread::Mutex
+
+      attr_reader buffered_changes: changes
+
+      # Yields `buffered_changes` to modify with synchronization
+      #
+      def push_buffer: [A] () { (changes) -> A } -> A
+
+      # Yields or returns a copy of `buffered_changes` after clearing `buffered_changes` content
+      #
+      def pop_buffer: [A] () { (changes) -> A } -> A
+                    | () -> changes
+
+      # Load files from `project` to `buffered_changes`
+      #
+      def load_files: (project: Project, commandline_args: Array[String]) -> void
+
+      # Load changes from a request with `DidChangeTextDocumentParams` into `buffered_changes`
+      #
+      def collect_changes: (untyped request) -> void
+    end
+  end
+end

data/sig/steep/server/interaction_worker.rbs

@@ -0,0 +1,41 @@
+module Steep
+  module Server
+    class InteractionWorker < BaseWorker
+      include ChangeBuffer
+
+      ApplyChangeJob: untyped
+
+      HoverJob: untyped
+
+      CompletionJob: untyped
+
+      LSP: untyped
+
+      attr_reader service: untyped
+
+      def initialize: (project: untyped, reader: untyped, writer: untyped, ?queue: untyped) -> void
+
+      def handle_job: (untyped job) -> untyped
+
+      def handle_request: (untyped request) -> untyped
+
+      def process_hover: (untyped job) -> untyped
+
+      def process_completion: (untyped job) -> untyped
+
+      def format_completion_item_for_rbs: (untyped sig_service, untyped type_name, untyped context, untyped job, untyped prefix) -> (nil | untyped)
+
+      def format_comment: (untyped comment) -> (untyped | nil)
+
+      def format_comments: (untyped comments) -> (untyped | nil)
+
+      def format_completion_item: (untyped item) -> untyped
+
+      def method_type_to_snippet: (untyped method_type) -> ::String
+
+      def params_to_snippet: (untyped fun) -> untyped
+
+      def relative_name_in_context: (untyped type_name, untyped context) -> untyped
+    end
+  end
+end

data/sig/steep/server/lsp_formatter.rbs

@@ -0,0 +1,29 @@
+module Steep
+  module Server
+    module LSPFormatter
+      include Services
+
+      class CommentBuilder
+        def initialize: () -> void
+
+        def self.build: () { (untyped) -> untyped } -> untyped
+
+        def to_s: () -> (untyped | nil)
+
+        def <<: (untyped string) -> (untyped | nil)
+
+        def push: () { (untyped) -> untyped } -> untyped
+      end
+
+      def self?.format_hover_content: (untyped content) -> untyped
+
+      def self?.to_list: (untyped collection) ?{ () -> untyped } -> untyped
+
+      def self?.name_and_args: (untyped name, untyped args) -> ::String
+
+      def self?.name_and_params: (untyped name, untyped params) -> ::String
+
+      def self?.declaration_summary: (untyped decl) -> untyped
+    end
+  end
+end

data/sig/steep/server/master.rbs

@@ -0,0 +1,260 @@
+module Steep
+  module Server
+    class Master
+      LSP: singleton(LanguageServer::Protocol)
+
+      class TypeCheckRequest
+        attr_reader guid: String
+
+        attr_reader library_paths: Set[Pathname]
+
+        attr_reader signature_paths: Set[Pathname]
+
+        attr_reader code_paths: Set[Pathname]
+
+        attr_reader priority_paths: Set[Pathname]
+
+        attr_reader checked_paths: Set[Pathname]
+
+        def initialize: (guid: String) -> void
+
+        def uri: (Pathname path) -> URI::File
+
+        def as_json: (assignment: Services::PathAssignment) -> { guid: String, library_uris: Array[String], signature_uris: Array[String], code_uris: Array[String], priority_uris: Array[String] }
+
+        def total: () -> Integer
+
+        def percentage: () -> Integer
+
+        def all_paths: () -> Set[Pathname]
+
+        def checking_path?: (Pathname path) -> bool
+
+        def checked: (Pathname path) -> void
+
+        def finished?: () -> bool
+
+        def unchecked_paths: () -> Set[Pathname]
+
+        def unchecked_code_paths: () -> Set[Pathname]
+
+        def unchecked_library_paths: () -> Set[Pathname]
+
+        def unchecked_signature_paths: () -> Set[Pathname]
+      end
+
+      # TypeCheckController remembers changed files, keep track of open editors, and make a TypeCheckRequest that contains list of all files to be type checked
+      #
+      # ```rb
+      # controller = TypeCheckController.new(project: project)
+      #
+      # controller.push_changes(file_path)           # Remember that the path is changed
+      # controller.update_priority(open: file_path)  # Remember that an editor opens the path
+      # controller.make_request(...)                 # Make an instance of TypeCheckRequest that contains list of all paths to type check
+      # ```
+      class TypeCheckController
+        attr_reader project: Project
+
+        attr_reader priority_paths: Set[Pathname]
+
+        attr_reader changed_paths: Set[Pathname]
+
+        attr_reader target_paths: Array[TargetPaths]
+
+        class TargetPaths
+          attr_reader project: Project
+
+          attr_reader target: Project::Target
+
+          attr_reader code_paths: Set[Pathname]
+
+          attr_reader signature_paths: Set[Pathname]
+
+          attr_reader library_paths: Set[Pathname]
+
+          def initialize: (project: Project, target: Project::Target) -> void
+
+          def all_paths: () -> Set[Pathname]
+
+          def library_path?: (Pathname path) -> bool
+
+          def signature_path?: (Pathname path) -> bool
+
+          def code_path?: (Pathname path) -> bool
+
+          def add: (Pathname path) -> void
+
+          alias << add
+        end
+
+        def initialize: (project: Project) -> void
+
+        def load: (command_line_args: Array[String]) -> void
+
+        def push_changes: (Pathname path) -> void
+
+        def update_priority: (open: Pathname) -> void
+                           | (close: Pathname) -> void
+
+        def make_request: (?guid: String, ?last_request: TypeCheckRequest?, ?include_unchanged: bool) -> TypeCheckRequest?
+      end
+
+      type lsp_notification = { method: String, params: untyped }
+
+      type lsp_request = { id: String, method: String, params: untyped }
+
+      type lsp_response = { id: String, result: untyped }
+
+      type lsp_message = { method: String, id: String?, params: untyped?, result: untyped? }
+
+      class ResultHandler
+        attr_reader request: lsp_request
+
+        attr_reader completion_handler: (^(lsp_response) -> void)?
+
+        attr_reader response: lsp_response?
+
+        @completed: bool
+
+        def initialize: (request: untyped) -> void
+
+        def process_response: (lsp_response message) -> bool
+
+        def result: () -> untyped
+
+        def completed?: () -> bool
+
+        def on_completion: () ?{ (lsp_response) -> void } -> void
+      end
+
+      class GroupHandler
+        attr_reader request: lsp_request
+
+        attr_reader handlers: Hash[String, ResultHandler]
+
+        attr_reader completion_handler: (^(Array[ResultHandler]) -> void)?
+
+        def initialize: () -> void
+
+        def process_response: (lsp_response message) -> bool
+
+        def completed?: () -> bool
+
+        def <<: (ResultHandler handler) -> void
+
+        def on_completion: () { (Array[ResultHandler]) -> void } -> void
+      end
+
+      class ResultController
+        attr_reader handlers: Array[ResultHandler | GroupHandler]
+
+        def initialize: () -> void
+
+        def <<: (ResultHandler | GroupHandler handler) -> void
+
+        def request_group: () { (GroupHandler) -> void } -> GroupHandler
+
+        def process_response: (lsp_response message) -> bool
+      end
+
+      module MessageUtils : _WithMessage
+        interface _WithMessage
+          def message: () -> untyped
+        end
+
+        def request?: () -> bool
+
+        def notification?: () -> bool
+
+        def response?: () -> bool
+
+        %a{pure} def method: () -> String?
+
+        %a{pure} def id: () -> String?
+
+        %a{pure} def result: () -> untyped?
+
+        %a{pure} def params: () -> untyped?
+      end
+
+      class ReceiveMessageJob
+        attr_reader source: WorkerProcess | :client
+
+        attr_reader message: untyped
+
+        def initialize: (source: WorkerProcess | :client, message: untyped) -> void
+
+        include MessageUtils
+      end
+
+      class SendMessageJob
+        attr_reader dest: WorkerProcess | :client
+
+        attr_reader message: untyped
+
+        def initialize: (dest: WorkerProcess | :client, message: untyped) -> void
+
+        def self.to_worker: (WorkerProcess, message: untyped) -> SendMessageJob
+
+        def self.to_client: (message: untyped) -> SendMessageJob
+
+        include MessageUtils
+      end
+
+      attr_reader project: Project
+
+      attr_reader reader: LanguageServer::Protocol::Transport::Io::Reader
+
+      attr_reader writer: LanguageServer::Protocol::Transport::Io::Writer
+
+      attr_reader commandline_args: Array[String]
+
+      attr_reader interaction_worker: WorkerProcess?
+
+      attr_reader typecheck_workers: Array[WorkerProcess]
+
+      attr_reader job_queue: Thread::Queue
+
+      attr_reader current_type_check_request: TypeCheckRequest?
+
+      attr_reader controller: TypeCheckController
+
+      attr_reader result_controller: ResultController
+
+      attr_reader initialize_params: untyped
+
+      attr_accessor typecheck_automatically: bool
+
+      def initialize: (project: Project, reader: untyped, writer: untyped, interaction_worker: WorkerProcess?, typecheck_workers: Array[WorkerProcess], ?queue: Thread::Queue) -> void
+
+      def start: () -> void
+
+      def each_worker: () { (WorkerProcess) -> void } -> void
+                     | () -> Enumerator[WorkerProcess, void]
+
+      def pathname: (String uri) -> Pathname?
+
+      def work_done_progress_supported?: () -> bool
+
+      def process_message_from_client: (untyped message) -> void
+
+      def process_message_from_worker: (untyped message, worker: WorkerProcess) -> void
+
+      def start_type_check: (TypeCheckRequest request, last_request: TypeCheckRequest?, start_progress: bool) -> void
+
+      def on_type_check_update: (guid: String, path: Pathname) -> void
+
+      def broadcast_notification: (lsp_notification message) -> void
+
+      def send_notification: (lsp_notification message, worker: WorkerProcess) -> void
+
+      def fresh_request_id: () -> String
+
+      def send_request: (method: String, worker: WorkerProcess, ?id: String, ?params: untyped?) ?{ (ResultHandler) -> void } -> ResultHandler
+
+      def group_request: () { (GroupHandler) -> void } -> GroupHandler
+
+      def kill: () -> void
+    end
+  end
+end

data/sig/steep/server/type_check_worker.rbs

@@ -0,0 +1,135 @@
+module Steep
+  module Server
+    # TypeCheckWorker provides two features:
+    #
+    # 1. Type check and validate source code invoked by `$/typecheck/start` notification
+    # 2. Language related features: `workspace/symbol`, `textDocument/definition`, `textDocument/implementation`, and `steep/stats` command
+    #
+    # `$/typecheck/start` notification is delivered to `#enqueue_typecheck_jobs` command that creates *jobs*.
+    #
+    # * `StartTypeCheckJob` applies the pending changes
+    # * `ValidateAppSignatureJob` validates an *application* RBS file
+    # * `ValidateLibrarySignatureJob` validates a *library* RBS file
+    # * `TypeCheckCodeJob` type checks a ruby code
+    #
+    class TypeCheckWorker < BaseWorker
+      attr_reader project: Project
+
+      attr_reader assignment: Services::PathAssignment
+
+      attr_reader service: Services::TypeCheckService
+
+      attr_reader commandline_args: Array[String]
+
+      attr_reader current_type_check_guid: String?
+
+      class WorkspaceSymbolJob
+        attr_reader id: String
+
+        attr_reader query: String
+
+        def initialize: (id: String, query: String) -> void
+      end
+
+      class StatsJob
+        attr_reader id: String
+
+        def initialize: (id: String) -> void
+      end
+
+      class StartTypeCheckJob
+        attr_reader guid: String
+
+        attr_reader changes: ChangeBuffer::changes
+
+        def initialize: (guid: String, changes: ChangeBuffer::changes) -> void
+      end
+
+      class TypeCheckCodeJob
+        attr_reader guid: String
+
+        attr_reader path: Pathname
+
+        def initialize: (guid: String, path: Pathname) -> void
+      end
+
+      class ValidateAppSignatureJob
+        attr_reader guid: String
+
+        attr_reader path: Pathname
+
+        def initialize: (guid: String, path: Pathname) -> void
+      end
+
+      class ValidateLibrarySignatureJob
+        attr_reader guid: String
+
+        attr_reader path: Pathname
+
+        def initialize: (guid: String, path: Pathname) -> void
+      end
+
+      class GotoJob
+        type kind = :implementation | :definition
+
+        attr_reader id: String
+
+        attr_reader kind: kind
+
+        type params = Hash[Symbol, untyped]
+
+        attr_reader params: params
+
+        def initialize: (id: String, params: params, kind: kind) -> void
+
+        def self.implementation: (id: String, params: params) -> GotoJob
+
+        def self.definition: (id: String, params: params) -> GotoJob
+
+        def implementation?: () -> bool
+
+        def definition?: () -> bool
+      end
+
+      include ChangeBuffer
+
+      def initialize: (
+        project: Project,
+        reader: LanguageServer::Protocol::Transport::Io::Reader,
+        writer: LanguageServer::Protocol::Transport::Io::Writer,
+        assignment: Services::PathAssignment,
+        commandline_args: Array[String]
+      ) -> void
+
+      def handle_request: (untyped request) -> void
+
+      type type_check_start_params = {
+        guid: String,
+        priority_uris: Array[String],
+        library_uris: Array[String],
+        signature_uris: Array[String],
+        code_uris: Array[String]
+      }
+
+      def enqueue_typecheck_jobs: (type_check_start_params) -> void
+
+      type job = WorkspaceSymbolJob
+               | StartTypeCheckJob
+               | TypeCheckCodeJob
+               | ValidateAppSignatureJob
+               | ValidateLibrarySignatureJob
+               | GotoJob
+               | StatsJob
+
+      def handle_job: (job) -> void
+
+      def typecheck_progress: (guid: String, path: Pathname) -> void
+
+      def workspace_symbol_result: (untyped query) -> untyped
+
+      def stats_result: () -> untyped
+
+      def goto: (GotoJob job) -> Array[untyped]
+    end
+  end
+end

data/sig/steep/server/worker_process.rbs

@@ -0,0 +1,29 @@
+module Steep
+  module Server
+    class WorkerProcess
+      attr_reader reader: untyped
+
+      attr_reader writer: untyped
+
+      attr_reader stderr: untyped
+
+      attr_reader name: untyped
+
+      attr_reader wait_thread: untyped
+
+      attr_reader index: untyped
+
+      def initialize: (reader: untyped, writer: untyped, stderr: untyped, wait_thread: untyped, name: untyped, ?index: untyped?) -> void
+
+      def self.spawn_worker: (untyped `type`, name: untyped, steepfile: untyped, ?steep_command: ::String, ?options: untyped, ?delay_shutdown: bool, ?index: untyped?) -> untyped
+
+      def self.spawn_typecheck_workers: (steepfile: untyped, args: untyped, ?steep_command: ::String, ?count: untyped, ?delay_shutdown: bool) -> untyped
+
+      def <<: (untyped message) -> untyped
+
+      def read: () ?{ () -> untyped } -> untyped
+
+      def kill: () -> untyped
+    end
+  end
+end

data/sig/steep/services/completion_provider.rbs

@@ -71,15 +71,15 @@ module Steep
         def inherited?: () -> bool
       end
 
-      attr_reader source_text: untyped
+      attr_reader source_text: String
 
-      attr_reader path: untyped
+      attr_reader path: Pathname
 
-      attr_reader subtyping: untyped
+      attr_reader subtyping: Subtyping::Check
 
-      attr_reader modified_text: untyped
+      attr_reader modified_text: String
 
-      attr_reader source: untyped
+      attr_reader source: Source
 
       attr_reader typing: Typing