steep 1.4.0 → 1.5.0.pre.1

data/sig/steep/diagnostic/ruby.rbs

@@ -153,6 +153,36 @@ module Steep
         def header_line: () -> ::String
       end
 
+      # Setter method, which has a name ending with `=`, returns different type from the method type
+      #
+      # ```ruby
+      # class Foo
+      #   # Assume `name=` has method type of `(String) -> String`
+      #   def name=(value)
+      #     return if value.empty?
+      #     @value = value
+      #   end
+      # end
+      # ```
+      #
+      # This is a special diagnostic for setter methods because the return value is not used with ordinal call syntax.
+      #
+      class SetterReturnTypeMismatch < Base
+        attr_reader expected: AST::Types::t
+
+        attr_reader actual: AST::Types::t
+
+        attr_reader result: Subtyping::Result::Base
+
+        attr_reader method_name: Symbol
+
+        include ResultPrinter
+
+        def initialize: (node: Parser::AST::Node, method_name: Symbol, expected: AST::Types::t, actual: AST::Types::t, result: Subtyping::Result::Base) -> void
+
+        def header_line: () -> String
+      end
+
       class UnexpectedBlockGiven < Base
         attr_reader method_type: untyped
 
@@ -299,6 +329,36 @@ module Steep
         def header_line: () -> ::String
       end
 
+      # Setter method, which has a name ending with `=`, has different type from the method type
+      #
+      # ```ruby
+      # class Foo
+      #   # Assume `name=` has method type of `(String) -> String`
+      #   def name=(value)
+      #     @value = value
+      #     value.strip!
+      #   end
+      # end
+      # ```
+      #
+      # This is a special diagnostic for setter methods because the return value is not used with ordinal call syntax.
+      #
+      class SetterBodyTypeMismatch < Base
+        attr_reader expected: AST::Types::t
+
+        attr_reader actual: AST::Types::t
+
+        attr_reader result: Subtyping::Result::Base
+
+        attr_reader method_name: Symbol
+
+        include ResultPrinter
+
+        def initialize: (node: Parser::AST::Node & Parser::AST::_DefNode, expected: AST::Types::t, actual: AST::Types::t, result: Subtyping::Result::Base, method_name: Symbol) -> void
+
+        def header_line: () -> String
+      end
+
       class UnexpectedYield < Base
         def header_line: () -> "No block given for `yield`"
       end
@@ -415,12 +475,8 @@ module Steep
         def header_line: () -> ::String
       end
 
-      class ElseOnExhaustiveCase < Base
-        attr_reader type: untyped
-
-        def initialize: (node: untyped, type: untyped) -> void
-
-        def header_line: () -> "The branch is unreachable because the condition is exhaustive"
+      class UnreachableBranch < Base
+        def header_line: () -> String
       end
 
       class UnexpectedSplat < Base
@@ -530,6 +586,17 @@ module Steep
         def header_line: () -> String
       end
 
+      # Type hint is given to a proc/lambda but it was ignored
+      #
+      # 1. Because the hint is incompatible to `::Proc` type
+      # 2. More than one *proc type* is included in the hint
+      #
+      class ProcHintIgnored < Base
+        attr_reader hint_type: AST::Types::t
+
+        def initialize: (hint_type: AST::Types::t, node: Parser::AST::Node) -> void
+      end
+
       # Argument forwarding `...` cannot be done safely, because of
       #
       # 1. The arguments are incompatible, or
@@ -575,6 +642,9 @@ module Steep
 
       self.@lenient: template?
       def self.lenient: () -> template
+
+      self.@silent: template?
+      def self.silent: () -> template
     end
   end
 end

data/sig/steep/drivers/annotations.rbs

@@ -1,17 +1,17 @@
 module Steep
   module Drivers
     class Annotations
-      attr_reader command_line_patterns: untyped
+      attr_reader command_line_patterns: Array[String]
 
-      attr_reader stdout: untyped
+      attr_reader stdout: IO
 
-      attr_reader stderr: untyped
+      attr_reader stderr: IO
 
       include Utils::DriverHelper
 
-      def initialize: (stdout: untyped, stderr: untyped) -> void
+      def initialize: (stdout: IO, stderr: IO) -> void
 
-      def run: () -> 0
+      def run: () -> Integer
     end
   end
 end

data/sig/steep/drivers/check.rbs

@@ -3,31 +3,31 @@ module Steep
     class Check
       module LSP = LanguageServer::Protocol
 
-      attr_reader stdout: untyped
+      attr_reader stdout: IO
 
-      attr_reader stderr: untyped
+      attr_reader stderr: IO
 
-      attr_reader command_line_patterns: untyped
+      attr_reader command_line_patterns: Array[String]
 
-      attr_accessor with_expectations_path: untyped
+      attr_accessor with_expectations_path: Pathname?
 
-      attr_accessor save_expectations_path: untyped
+      attr_accessor save_expectations_path: Pathname?
 
-      attr_accessor severity_level: untyped
+      attr_accessor severity_level: Diagnostic::LSPFormatter::severity
 
       attr_reader jobs_option: Utils::JobsOption
 
       include Utils::DriverHelper
 
-      def initialize: (stdout: untyped, stderr: untyped) -> void
+      def initialize: (stdout: IO, stderr: IO) -> void
 
-      def run: () -> untyped
+      def run: () -> Integer
 
-      def print_expectations: (project: untyped, all_files: untyped, expectations_path: untyped, notifications: untyped) -> untyped
+      def print_expectations: (project: Project, all_files: Array[Pathname], expectations_path: Pathname, notifications: Array[untyped]) -> Integer
 
-      def save_expectations: (project: untyped, all_files: untyped, expectations_path: untyped, notifications: untyped) -> 0
+      def save_expectations: (project: Project, all_files: Array[Pathname], expectations_path: Pathname, notifications: Array[untyped]) -> Integer
 
-      def print_result: (project: untyped, notifications: untyped) -> (0 | 1)
+      def print_result: (project: Project, notifications: Array[untyped]) -> Integer
     end
   end
 end

data/sig/steep/drivers/diagnostic_printer.rbs

@@ -3,23 +3,23 @@ module Steep
     class DiagnosticPrinter
       module LSP = LanguageServer::Protocol
 
-      attr_reader stdout: untyped
+      attr_reader stdout: IO
 
-      attr_reader buffer: untyped
+      attr_reader buffer: RBS::Buffer
 
-      def initialize: (stdout: untyped, buffer: untyped) -> void
+      def initialize: (stdout: IO, buffer: RBS::Buffer) -> void
 
-      def path: () -> untyped
+      def path: () -> Pathname
 
-      def color_severity: (untyped string, severity: untyped) -> untyped
+      def color_severity: (String string, severity: String) -> String
 
-      def severity_message: (untyped severity) -> untyped
+      def severity_message: (String) -> String
 
-      def location: (untyped diagnostic) -> untyped
+      def location: (untyped diagnostic) -> String
 
-      def print: (untyped diagnostic, ?prefix: ::String, ?source: bool) -> untyped
+      def print: (Hash[Symbol, untyped] diagnostic, ?prefix: ::String, ?source: bool) -> void
 
-      def print_source_line: (untyped diagnostic, ?prefix: ::String) -> untyped
+      def print_source_line: (untyped diagnostic, ?prefix: ::String) -> void
     end
   end
 end

data/sig/steep/drivers/init.rbs

@@ -1,19 +1,19 @@
 module Steep
   module Drivers
     class Init
-      attr_reader stdout: untyped
+      attr_reader stdout: IO
 
-      attr_reader stderr: untyped
+      attr_reader stderr: IO
 
-      attr_accessor force_write: untyped
+      attr_accessor force_write: bool
 
       include Utils::DriverHelper
 
-      TEMPLATE: "# D = Steep::Diagnostic\n#\n# target :lib do\n#   signature \"sig\"\n#\n#   check \"lib\"                       # Directory name\n#   check \"Gemfile\"                   # File name\n#   check \"app/models/**/*.rb\"        # Glob\n#   # ignore \"lib/templates/*.rb\"\n#\n#   # library \"pathname\", \"set\"       # Standard libraries\n#   # library \"strong_json\"           # Gems\n#   \n#   # configure_code_diagnostics(D::Ruby.strict)       # `strict` diagnostics setting\n#   # configure_code_diagnostics(D::Ruby.lenient)      # `lenient` diagnostics setting\n#   # configure_code_diagnostics do |hash|             # You can setup everything yourself\n#   #   hash[D::Ruby::NoMethod] = :information\n#   # end\n# end\n\n# target :test do\n#   signature \"sig\", \"sig-private\"\n#\n#   check \"test\"\n#\n#   # library \"pathname\", \"set\"       # Standard libraries\n# end\n"
+      TEMPLATE: String
 
-      def initialize: (stdout: untyped, stderr: untyped) -> void
+      def initialize: (stdout: IO, stderr: IO) -> void
 
-      def run: () -> (1 | 0)
+      def run: () -> Integer
     end
   end
 end

data/sig/steep/drivers/print_project.rbs

@@ -1,15 +1,15 @@
 module Steep
   module Drivers
     class PrintProject
-      attr_reader stdout: untyped
+      attr_reader stdout: IO
 
-      attr_reader stderr: untyped
+      attr_reader stderr: IO
 
       include Utils::DriverHelper
 
-      def initialize: (stdout: untyped, stderr: untyped) -> void
+      def initialize: (stdout: IO, stderr: IO) -> void
 
-      def run: () -> 0
+      def run: () -> Integer
     end
   end
 end

data/sig/steep/drivers/utils/driver_helper.rbs

@@ -1,3 +1,5 @@
+use LanguageServer::Protocol::Transport::Io::*
+
 module Steep
   module Drivers
     module Utils
@@ -6,17 +8,17 @@ module Steep
 
         def load_config: (?path: Pathname) -> Project
 
-        def type_check: (Project project) -> void
-
         def request_id: () -> String
 
-        def wait_for_response_id: (reader: untyped, id: untyped, ?unknown_responses: ::Symbol) -> untyped
+        def wait_for_response_id: (reader: Reader, id: String, ?unknown_responses: unknown_message_action) -> untyped
+
+        def shutdown_exit: (writer: Writer, reader: Reader) -> void
 
-        def shutdown_exit: (writer: untyped, reader: untyped) -> untyped
+        type unknown_message_action = :ignore | :log | :raise
 
-        def wait_for_message: (reader: untyped, ?unknown_messages: ::Symbol) { (untyped) -> untyped } -> untyped
+        def wait_for_message: (reader: Reader, ?unknown_messages: unknown_message_action) { (untyped) -> bool } -> untyped
 
-        def keep_diagnostic?: (untyped diagnostic) -> bool
+        def keep_diagnostic?: (untyped diagnostic, severity_level: Diagnostic::LSPFormatter::severity) -> bool
       end
     end
   end

data/sig/steep/drivers/validate.rbs

@@ -1,15 +1,15 @@
 module Steep
   module Drivers
     class Validate
-      attr_reader stdout: untyped
+      attr_reader stdout: IO
 
-      attr_reader stderr: untyped
+      attr_reader stderr: IO
 
       include Utils::DriverHelper
 
-      def initialize: (stdout: untyped, stderr: untyped) -> void
+      def initialize: (stdout: IO, stderr: IO) -> void
 
-      def run: () -> untyped
+      def run: () -> Integer
     end
   end
 end

data/sig/steep/drivers/watch.rbs

@@ -9,7 +9,7 @@ module Steep
 
       attr_reader queue: Thread::Queue
 
-      attr_accessor severity_level: Symbol
+      attr_accessor severity_level: Diagnostic::LSPFormatter::severity
 
       attr_reader jobs_option: Utils::JobsOption
 

data/sig/steep/expectations.rbs

@@ -0,0 +1,72 @@
+module Steep
+  class Expectations
+    type status = :expected | :missing | :unexpected
+
+    class Diagnostic
+      module DiagnosticSeverity = LanguageServer::Protocol::Constant::DiagnosticSeverity
+
+      type position = { line: Integer, character: Integer }
+
+      attr_reader start_position: position
+
+      attr_reader end_position: position
+
+      attr_reader severity: Steep::Diagnostic::LSPFormatter::severity
+
+      attr_reader message: String
+
+      attr_reader code: String
+
+      def initialize: (start_position: position, end_position: position, severity: Steep::Diagnostic::LSPFormatter::severity, message: String, code: String) -> void
+
+      def self.from_hash: (untyped) -> instance
+
+      def self.from_lsp: (untyped) -> Diagnostic
+
+      def to_hash: () -> Hash[String, untyped]
+
+      def to_lsp: () -> Hash[Symbol, untyped]
+
+      def lsp_severity: () -> Integer
+
+      def sort_key: () -> Array[untyped]
+    end
+
+    class TestResult
+      attr_reader path: Pathname
+
+      attr_reader expectation: Array[Diagnostic]
+
+      attr_reader actual: Array[Diagnostic]
+
+      def initialize: (path: Pathname, expectation: Array[Diagnostic], actual: Array[Diagnostic]) -> void
+
+      def empty?: () -> bool
+
+      def satisfied?: () -> bool
+
+      def each_diagnostics: () { ([status, Diagnostic]) -> void } -> void
+                          | () -> Enumerator[[status, Diagnostic], void]
+
+      def expected_diagnostics: () -> Array[Diagnostic]
+
+      def unexpected_diagnostics: () -> Array[Diagnostic]
+
+      def missing_diagnostics: () -> Array[Diagnostic]
+    end
+
+    module LSP = LanguageServer::Protocol
+
+    attr_reader diagnostics: Hash[Pathname, Array[Diagnostic]]
+
+    def initialize: () -> void
+
+    def test: (path: Pathname, diagnostics: Array[Diagnostic]) -> TestResult
+
+    def self.empty: () -> instance
+
+    def to_yaml: () -> String
+
+    def self.load: (path: Pathname, content: String) -> instance
+  end
+end

data/sig/steep/index/signature_symbol_provider.rbs

@@ -1,29 +1,41 @@
+use LanguageServer::Protocol::Constant::SymbolKind
+
 module Steep
   module Index
     class SignatureSymbolProvider
       module LSP = LanguageServer::Protocol
 
-      SymbolInformation: untyped
+      class SymbolInformation
+        attr_reader name: String
+
+        attr_reader location: RBS::Location[untyped, untyped]
+
+        attr_reader container_name: String?
+
+        attr_reader kind: SymbolKind::t
+
+        def initialize: (name: String, location: RBS::Location[untyped, untyped], container_name: String?, kind: SymbolKind::t) -> void
+      end
 
-      attr_reader project: untyped
+      attr_reader project: Project
 
-      attr_reader indexes: untyped
+      attr_reader indexes: Array[RBSIndex]
 
-      attr_reader assignment: untyped
+      attr_reader assignment: Services::PathAssignment
 
-      def initialize: (project: untyped, assignment: untyped) -> void
+      def initialize: (project: Project, assignment: Services::PathAssignment) -> void
 
-      def self.test_type_name: (untyped query, untyped type_name) -> untyped
+      def self.test_type_name: (String query, RBS::TypeName type_name) -> bool
 
       alias self.test_const_name self.test_type_name
 
-      alias self.test_global_name self.test_type_name
+      def self.test_global_name: (String query, Symbol global_name) -> bool
 
-      def self.test_method_name: (untyped query, untyped method_name) -> untyped
+      def self.test_method_name: (String query, method_name) -> bool
 
-      def assigned?: (untyped path) -> untyped
+      def assigned?: (Pathname) -> bool
 
-      def query_symbol: (untyped query) -> untyped
+      def query_symbol: (String query) -> Array[SymbolInformation]
     end
   end
 end

data/sig/steep/interface/block.rbs

@@ -25,6 +25,8 @@ module Steep
 
       def subst: (Substitution s) -> Block
 
+      @fvs: Set[Symbol]
+
       def free_variables: () -> Set[Symbol]
 
       def to_s: () -> ::String

data/sig/steep/interface/function.rbs

@@ -140,7 +140,7 @@ module Steep
 
         def optional: () -> Array[AST::Types::t]
 
-        def rest: () -> AST::Types::t?
+        %a{pure} def rest: () -> AST::Types::t?
 
         attr_reader positional_params: PositionalParams?
 
@@ -166,7 +166,7 @@ module Steep
 
         def hash: () -> untyped
 
-        def flat_unnamed_params: () -> (untyped | ::Array[untyped])
+        def flat_unnamed_params: () -> Array[[:required | :optional, AST::Types::t]]
 
         def flat_keywords: () -> untyped
 

data/sig/steep/node_helper.rbs

@@ -1,3 +1,7 @@
+use Parser::AST::Node
+use Parser::AST::_Condition, Parser::AST::_Ternary, Parser::AST::_Keyword, Parser::AST::_RescueBody, Parser::AST::_Send
+use Parser::Source::Map
+
 module Steep
   module NodeHelper
     def each_child_node: (Parser::AST::Node) -> Enumerator[Parser::AST::Node, void]
@@ -9,5 +13,57 @@ module Steep
     # Returns true if given node is a syntactic-value node
     #
     def value_node?: (Parser::AST::Node) -> bool
+
+    type condition_loc = Map & _Condition
+
+    type ternary_loc = Map & _Ternary
+
+    def deconstruct_if_node: (Node) -> [Node, Node?, Node?, condition_loc | ternary_loc]?
+
+    def deconstruct_if_node!: (Node) -> [Node, Node?, Node?, condition_loc | ternary_loc]
+
+    def test_if_node: (Node) { (Node, Node?, Node?, condition_loc | ternary_loc) -> bool } -> bool
+
+    type keyword_loc = Map & Parser::AST::_Keyword
+
+    def deconstruct_whileish_node: (Node) -> [Node, Node?, keyword_loc]?
+
+    def deconstruct_whileish_node!: (Node) -> [Node, Node?, keyword_loc]
+
+    def test_whileish_node: (Node) { (Node, Node?, keyword_loc) -> bool } -> bool
+
+    def deconstruct_case_node: (Node) -> [Node?, Array[Node], Node?, condition_loc]?
+
+    def deconstruct_case_node!: (Node) -> [Node?, Array[Node], Node?, condition_loc]
+
+    def test_case_node: (Node) { (Node?, Array[Node], Node?, condition_loc) -> bool } -> bool
+
+    def deconstruct_when_node: (Node) -> [Array[Node], Node?, keyword_loc]?
+
+    def deconstruct_when_node!: (Node) -> [Array[Node], Node?, keyword_loc]
+
+    def test_when_node: (Node) { (Array[Node], Node?, keyword_loc) -> bool } -> bool
+
+    def deconstruct_rescue_node: (Node) -> [Node?, Array[Node], Node?, condition_loc]?
+
+    def deconstruct_rescue_node!: (Node) -> [Node?, Array[Node], Node?, condition_loc]
+
+    def test_rescue_node: (Node) { (Node?, Array[Node], Node?, condition_loc) -> bool } -> bool
+
+    type rescue_body_loc = Map & _RescueBody
+
+    def deconstruct_resbody_node: (Node) -> [Node?, Node?, Node?, rescue_body_loc]?
+
+    def deconstruct_resbody_node!: (Node) -> [Node?, Node?, Node?, rescue_body_loc]
+
+    def test_resbody_node: (Node) { (Node?, Node?, Node?, rescue_body_loc) -> bool } -> bool
+
+    type send_loc = Map & _Send
+
+    def deconstruct_send_node: (Node) -> [Node?, Symbol, Array[Node], send_loc]?
+
+    def deconstruct_send_node!: (Node) -> [Node?, Symbol, Array[Node], send_loc]
+
+    def test_send_node: (Node) { (Node?, Symbol, Array[Node], send_loc) -> bool } -> bool
   end
 end

data/sig/steep/path_helper.rbs

@@ -10,6 +10,6 @@ module Steep
 
     # Receives a Pathname and returns a *file* URI
     #
-    def self?.to_uri: (Pathname path, ?dosish: bool) -> URI::File
+    def self?.to_uri: (Pathname | String path, ?dosish: bool) -> URI::File
   end
 end

data/sig/steep/project/options.rbs

@@ -19,7 +19,7 @@ module Steep
 
       attr_accessor paths: PathOptions
 
-      attr_accessor collection_lock: RBS::Collection::Config::Lockfile
+      attr_accessor collection_lock: RBS::Collection::Config::Lockfile?
 
       def initialize: () -> void
     end

data/sig/steep/range_extension.rbs

@@ -1,7 +1,7 @@
 class RBS::Location[in RK, in OK]
-  def as_lsp_range: () -> { start: { line: Integer, character: Integer }, end: { line: Integer, character: Integer } }
+  def as_lsp_range: () -> LanguageServer::Protocol::Interface::Range::json
 end
 
 class Parser::Source::Range
-  def as_lsp_range: () -> { start: { line: Integer, character: Integer }, end: { line: Integer, character: Integer } }
+  def as_lsp_range: () -> LanguageServer::Protocol::Interface::Range::json
 end

data/sig/steep/server/master.rbs

@@ -227,8 +227,24 @@ module Steep
 
       def initialize: (project: Project, reader: untyped, writer: untyped, interaction_worker: WorkerProcess?, typecheck_workers: Array[WorkerProcess], ?queue: Thread::Queue) -> void
 
+      # Start the Steep language server
+      #
+      # Returns after the language server shutdown.
+      # The shutdown process starts by `exit` message.
+      #
+      # Raises an exception if the worker processes doesn't shutdown properly, like being `#kill`-ed.
+      # Exiting the process is assumed in the case of error.
+      # The only one cleanup it does is stopping the worker processes, by `SIGKILL`.
+      #
       def start: () -> void
 
+      # Stops the language server workers by sending SIGTERM
+      #
+      # This skips the normal shutdown process defined in LSP.
+      # The `#start` call will result in an exception.
+      #
+      def kill: () -> void
+
       def each_worker: () { (WorkerProcess) -> void } -> void
                      | () -> Enumerator[WorkerProcess, void]
 
@@ -253,8 +269,6 @@ module Steep
       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

@@ -72,7 +72,7 @@ module Steep
       end
 
       class GotoJob
-        type kind = :implementation | :definition
+        type kind = :implementation | :definition | :type_definition
 
         attr_reader id: String
 
@@ -88,9 +88,13 @@ module Steep
 
         def self.definition: (id: String, params: params) -> GotoJob
 
+        def self.type_definition: (id: String, params: params) -> GotoJob
+
         def implementation?: () -> bool
 
         def definition?: () -> bool
+
+        def type_definition?: () -> bool
       end
 
       include ChangeBuffer

data/sig/steep/server/worker_process.rbs

@@ -87,7 +87,11 @@ module Steep
 
       def read: () { (untyped) -> void } -> void
 
-      def kill: () -> void
+      # Stop the process by sending SIGTERM and wait for the process exit
+      #
+      # Send `SIGKILL` and returns immediately if `force:` is `true`.
+      #
+      def kill: (?force: bool) -> void
     end
   end
 end