steep 1.4.0.dev.1 → 1.4.0.dev.3

data/sig/shims/parser/nodes.rbs

@@ -0,0 +1,37 @@
+module Parser
+  module AST
+    interface _BlockNode
+      def type: () -> :block
+
+      %a{pure} def loc: () -> (Source::Map & _BlockLocation)
+    end
+
+    interface _BlockLocation
+      %a{pure} def end: () -> Source::Range
+    end
+
+    interface _DefNode
+      def type: () -> :def
+
+      def children: () -> [Symbol, Node, Node?]
+
+      %a{pure} def loc: () -> (Source::Map & _DefLocation)
+    end
+
+    interface _DefLocation
+      %a{pure} def end: () -> Source::Range?
+    end
+
+    interface _CaseNode
+      def type: () -> :case
+
+      %a{pure} def loc: () -> (Source::Map & _CaseLocation)
+    end
+
+    interface _CaseLocation
+      %a{pure} def else: () -> Source::Range?
+
+      %a{pure} def end: () -> Source::Range
+    end
+  end
+end

data/sig/shims/parser.rbs

@@ -36,6 +36,7 @@ module Parser
       attr_accessor self.emit_lambda: bool
       attr_accessor self.emit_procarg0: bool
       attr_accessor self.emit_kwargs: bool
+      attr_accessor self.emit_forward_arg: bool
 
       def string_value: (untyped) -> untyped
 

data/sig/shims/string.rbs

@@ -0,0 +1,4 @@
+class String
+  def start_with?: (Regexp) -> bool
+                 | ...
+end

data/sig/steep/annotation_parser.rbs

@@ -19,7 +19,8 @@ module Steep
 
       attr_reader location: RBS::Location[untyped, untyped]
 
-      def initialize: (source: String, location: RBS::Location[untyped, untyped], ?exn: Exception?) -> void
+      def initialize: (source: String, location: RBS::Location[untyped, untyped], exn: Exception) -> void
+                    | (source: String, location: RBS::Location[untyped, untyped], message: String) -> void
     end
 
     TYPE: Regexp
@@ -30,7 +31,7 @@ module Steep
 
     TYPE_PARAMS: Regexp
 
-    def parse_type: (String) -> AST::Types::t
+    def parse_type: (MatchData, ?Symbol, location: RBS::Location[untyped, untyped]) -> AST::Types::t
 
     # ```
     # @type ${keyword} ${name}: ${type}

data/sig/steep/ast/annotation/collection.rbs

@@ -26,7 +26,7 @@ module Steep
 
         attr_reader module_type_annotation: untyped
 
-        attr_reader implement_module_annotation: untyped
+        attr_reader implement_module_annotation: Implements?
 
         attr_reader dynamic_annotations: untyped
 

data/sig/steep/ast/types/factory.rbs

@@ -1,3 +1,5 @@
+use RBS::TypeName, RBS::Resolver::TypeNameResolver
+
 module Steep
   module AST
     module Types
@@ -10,13 +12,13 @@ module Steep
 
         attr_reader type_interface_cache: untyped
 
-        @type_name_resolver: RBS::Resolver::TypeNameResolver?
+        @type_name_resolver: TypeNameResolver?
 
         def inspect: () -> String
 
         def initialize: (builder: RBS::DefinitionBuilder) -> void
 
-        def type_name_resolver: () -> RBS::Resolver::TypeNameResolver
+        def type_name_resolver: () -> TypeNameResolver
 
         def type: (RBS::Types::t `type`) -> t
 
@@ -40,7 +42,7 @@ module Steep
 
         def method_type_1: (Interface::MethodType method_type) -> RBS::MethodType
 
-        def unfold: (RBS::TypeName type_name, Array[t] args) -> t
+        def unfold: (TypeName type_name, Array[t] args) -> t
 
         # Unfold type alias one step, or returns itself
         #
@@ -51,7 +53,7 @@ module Steep
         # * Unions and intersections are expanded
         # * Returns `nil` if it is recursive
         #
-        def deep_expand_alias: (t `type`, ?recursive: Set[RBS::TypeName]) -> t?
+        def deep_expand_alias: (t `type`, ?recursive: Set[TypeName]) -> t?
 
         # Convert union types to array of types
         #
@@ -59,21 +61,23 @@ module Steep
 
         def unwrap_optional: (Types::t `type`) -> [Types::t, Types::t]
 
-        def module_name?: (RBS::TypeName type_name) -> bool
+        def module_name?: (TypeName type_name) -> bool
 
-        def class_name?: (RBS::TypeName type_name) -> bool
+        def class_name?: (TypeName type_name) -> bool
 
         def env: () -> RBS::Environment
 
         def absolute_type: (t `type`, context: RBS::Resolver::context) -> t
 
-        def absolute_type_name: (RBS::TypeName type_name, context: RBS::Resolver::context) -> RBS::TypeName?
+        def absolute_type_name: (TypeName type_name, context: RBS::Resolver::context) -> TypeName?
 
-        def instance_type: (RBS::TypeName type_name, ?args: Array[t]?, ?location: untyped?) -> t
+        def instance_type: (TypeName type_name, ?args: Array[t]?, ?location: untyped?) -> t
 
         def try_singleton_type: (t) -> t?
 
         def try_instance_type: (t) -> t?
+
+        def normalize_type: (t) -> t
       end
     end
   end

data/sig/steep/ast/types/name.rbs

@@ -16,6 +16,8 @@ module Steep
           def subst: (Steep::Interface::Substitution s) -> self
 
           def level: () -> Array[Integer]
+
+          def map_type: () { (t) -> t } -> self
         end
 
         class Applying < Base
@@ -45,6 +47,8 @@ module Steep
           include Helper::ChildrenLevel
 
           def level: () -> Array[Integer]
+
+          def map_type: () { (t) -> t } -> self
         end
 
         class Singleton < Base

data/sig/steep/diagnostic/lsp_formatter.rbs

@@ -1,7 +1,7 @@
 module Steep
   module Diagnostic
     class LSPFormatter
-      LSP: singleton(LanguageServer::Protocol)
+      module LSP = LanguageServer::Protocol
 
       type config = Hash[singleton(Diagnostic::Ruby::Base) | singleton(Diagnostic::Signature::Base), severity?]
 

data/sig/steep/diagnostic/ruby.rbs

@@ -24,9 +24,15 @@ module Steep
       end
 
       module ResultPrinter : _DiagnosticWithResult
-        def relation_message: (untyped relation) -> untyped
+        def relation_message: (Subtyping::Relation[untyped] relation) -> String?
 
-        def detail_lines: () -> untyped
+        def detail_lines: () -> String?
+      end
+
+      module ResultPrinter2 : _DiagnosticWithResult
+        def result_line: (Subtyping::Result::t result) -> String?
+
+        def detail_lines: () -> String?
       end
 
       class IncompatibleAssignment < Base
@@ -524,6 +530,36 @@ module Steep
         def header_line: () -> String
       end
 
+      # Argument forwarding `...` cannot be done safely, because of
+      #
+      # 1. The arguments are incompatible, or
+      # 2. The blocks are incompatible
+      #
+      class IncompatibleArgumentForwarding < Base
+        attr_reader method_name: Symbol
+
+        attr_reader params_pair: [Interface::Function::Params, Interface::Function::Params]?
+
+        attr_reader block_pair: [Interface::Block?, Interface::Block?]?
+
+        attr_reader result: Subtyping::Result::Base
+
+        include ResultPrinter2
+
+        # One of `params_pair:` or `block_pair:` is specified where the first object is of the source method (`#foo`) and the second value is of the target method (`#bar`)
+        #
+        # ```ruby
+        # def foo(...)
+        #   bar(...)
+        # end
+        # ```
+        #
+        def initialize: (node: Parser::AST::Node, method_name: Symbol, params_pair: [Interface::Function::Params, Interface::Function::Params], result: Subtyping::Result::Base) -> void
+                      | (node: Parser::AST::Node, method_name: Symbol, block_pair: [Interface::Block?, Interface::Block?], result: Subtyping::Result::Base) -> void
+
+        def header_line: () -> String
+      end
+
       ALL: Array[singleton(Base)]
 
       type template = Hash[singleton(Base), LSPFormatter::severity]

data/sig/steep/diagnostic/signature.rbs

@@ -146,23 +146,11 @@ module Steep
       class ModuleSelfTypeError < Base
         attr_reader name: RBS::TypeName
 
-        attr_reader ancestor: RBS::DefinitionBuilder::AncestorBuilder::OneAncestors
+        attr_reader ancestor: RBS::Definition::Ancestor::Instance
 
         attr_reader relation: Subtyping::Relation[AST::Types::t]
 
-        def initialize: (name: RBS::TypeName, ancestor: RBS::DefinitionBuilder::AncestorBuilder::OneAncestors, relation: Subtyping::Relation[AST::Types::t], location: location?) -> void
-
-        def header_line: () -> String
-      end
-
-      class ClassVariableDuplicationError < Base
-        attr_reader class_name: RBS::TypeName
-
-        attr_reader other_class_name: RBS::TypeName
-
-        attr_reader variable_name: Symbol
-
-        def initialize: (class_name: RBS::TypeName, other_class_name: RBS::TypeName, variable_name: Symbol, location: RBS::Location[untyped, untyped]) -> void
+        def initialize: (name: RBS::TypeName, ancestor: RBS::Definition::Ancestor::Instance, relation: Subtyping::Relation[AST::Types::t], location: location?) -> void
 
         def header_line: () -> String
       end
@@ -242,6 +230,22 @@ module Steep
         def header_line: () -> String
       end
 
+      class InconsistentClassModuleAliasError < Base
+        attr_reader decl: RBS::AST::Declarations::ModuleAlias | RBS::AST::Declarations::ClassAlias
+
+        def initialize: (decl: RBS::AST::Declarations::ModuleAlias | RBS::AST::Declarations::ClassAlias) -> void
+
+        def header_line: () -> String
+      end
+
+      class CyclicClassAliasDefinitionError < Base
+        attr_reader decl: RBS::AST::Declarations::ModuleAlias | RBS::AST::Declarations::ClassAlias
+
+        def initialize: (decl: RBS::AST::Declarations::ModuleAlias | RBS::AST::Declarations::ClassAlias) -> void
+
+        def header_line: () -> String
+      end
+
       def self.from_rbs_error: (RBS::BaseError error, factory: AST::Types::Factory) -> Base
     end
   end

data/sig/steep/drivers/check.rbs

@@ -1,7 +1,7 @@
 module Steep
   module Drivers
     class Check
-      LSP: untyped
+      module LSP = LanguageServer::Protocol
 
       attr_reader stdout: untyped
 

data/sig/steep/drivers/checkfile.rbs

@@ -1,7 +1,7 @@
 module Steep
   module Drivers
     class Checkfile
-      LSP: singleton(LanguageServer::Protocol)
+      module LSP = LanguageServer::Protocol
 
       attr_reader stdout: IO
 

data/sig/steep/drivers/diagnostic_printer.rbs

@@ -1,7 +1,7 @@
 module Steep
   module Drivers
     class DiagnosticPrinter
-      LSP: untyped
+      module LSP = LanguageServer::Protocol
 
       attr_reader stdout: untyped
 

data/sig/steep/drivers/watch.rbs

@@ -15,7 +15,7 @@ module Steep
 
       include Utils::DriverHelper
 
-      LSP: singleton(LanguageServer::Protocol)
+      module LSP = LanguageServer::Protocol
 
       def initialize: (stdout: IO, stderr: IO) -> void
 

data/sig/steep/index/rbs_index.rbs

@@ -7,7 +7,9 @@ module Steep
         type decl = RBS::AST::Declarations::Class
                   | RBS::AST::Declarations::Module
                   | RBS::AST::Declarations::Interface
-                  | RBS::AST::Declarations::Alias
+                  | RBS::AST::Declarations::TypeAlias
+                  | RBS::AST::Declarations::ClassAlias
+                  | RBS::AST::Declarations::ModuleAlias
 
         type ref = RBS::AST::Members::MethodDefinition
                  | RBS::AST::Members::AttrWriter
@@ -22,7 +24,9 @@ module Steep
                  | RBS::AST::Declarations::Class
                  | RBS::AST::Declarations::Constant
                  | RBS::AST::Declarations::Global
-                 | RBS::AST::Declarations::Alias
+                 | RBS::AST::Declarations::TypeAlias
+                 | RBS::AST::Declarations::ClassAlias
+                 | RBS::AST::Declarations::ModuleAlias
 
         attr_reader declarations: Set[decl]
 

data/sig/steep/index/signature_symbol_provider.rbs

@@ -1,7 +1,7 @@
 module Steep
   module Index
     class SignatureSymbolProvider
-      LSP: untyped
+      module LSP = LanguageServer::Protocol
 
       SymbolInformation: untyped
 

data/sig/steep/interface/block.rbs

@@ -32,6 +32,8 @@ module Steep
       def map_type: () { (AST::Types::t) -> AST::Types::t } -> Block
 
       def +: (Block other) -> Block
+
+      def to_proc_type: () -> AST::Types::t
     end
   end
 end

data/sig/steep/interface/builder.rbs

@@ -1,3 +1,5 @@
+use RBS::TypeName
+
 module Steep
   module Interface
     class Builder
@@ -85,11 +87,11 @@ module Steep
       attr_reader cache: Hash[cache_key, Shape?]
 
       # No type application (if generic), no self-instance-module resolution
-      attr_reader raw_instance_object_shape_cache: Hash[[RBS::TypeName, bool], Shape]
+      attr_reader raw_instance_object_shape_cache: Hash[[TypeName, bool], Shape]
 
-      attr_reader raw_singleton_object_shape_cache: Hash[[RBS::TypeName, bool], Shape]
+      attr_reader raw_singleton_object_shape_cache: Hash[[TypeName, bool], Shape]
 
-      attr_reader raw_interface_object_shape_cache: Hash[[RBS::TypeName, bool], Shape]
+      attr_reader raw_interface_object_shape_cache: Hash[[TypeName, bool], Shape]
 
       def initialize: (AST::Types::Factory) -> void
 

data/sig/steep/interface/method_type.rbs

@@ -1,3 +1,5 @@
+use Steep::TypeInference::MethodCall::MethodDecl
+
 module Steep
   module Interface
     class MethodType
@@ -7,11 +9,11 @@ module Steep
 
       attr_reader block: Block?
 
-      attr_reader method_decls: Set[TypeInference::MethodCall::MethodDecl]
+      attr_reader method_decls: Set[MethodDecl]
 
       @fvs: Set[Symbol]
 
-      def initialize: (type_params: Array[TypeParam], type: Function, block: Block?, method_decls: Set[TypeInference::MethodCall::MethodDecl]) -> void
+      def initialize: (type_params: Array[TypeParam], type: Function, block: Block?, method_decls: Set[MethodDecl]) -> void
 
       def ==: (untyped other) -> bool
 
@@ -28,7 +30,7 @@ module Steep
 
       def instantiate: (Substitution s) -> MethodType
 
-      def with: (?type_params: Array[TypeParam], ?type: Function, ?block: Block?, ?method_decls: Set[TypeInference::MethodCall::MethodDecl]) -> MethodType
+      def with: (?type_params: Array[TypeParam], ?type: Function, ?block: Block?, ?method_decls: Set[MethodDecl]) -> MethodType
 
       def to_s: () -> ::String
 

data/sig/steep/module_helper.rbs

@@ -1,7 +1,16 @@
 module Steep
   module ModuleHelper
+    # Translate a *const* node to a type name if possible
+    #
+    # ```ruby
+    # Foo::Bar     # => `Foo::Bar`
+    # foo::Bar     # => nil
+    # ```
+    #
     def module_name_from_node: (Parser::AST::Node? parent_node, Symbol constant_name) -> RBS::TypeName?
 
+    # Translate a *const* node to a namespace if possible
+    # 
     def namespace_from_node: (Parser::AST::Node? node) -> RBS::Namespace?
   end
 end

data/sig/steep/path_helper.rbs

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

data/sig/steep/project/target.rbs

@@ -1,9 +1,9 @@
 module Steep
   class Project
     class Target
-      attr_reader name: untyped
+      attr_reader name: Symbol
 
-      attr_reader options: untyped
+      attr_reader options: Options
 
       attr_reader source_pattern: Pattern
 
@@ -11,15 +11,15 @@ module Steep
 
       attr_reader code_diagnostics_config: untyped
 
-      def initialize: (name: untyped, options: untyped, source_pattern: untyped, signature_pattern: untyped, code_diagnostics_config: untyped) -> void
+      def initialize: (name: Symbol, options: Options, source_pattern: Pattern, signature_pattern: Pattern, code_diagnostics_config: untyped) -> void
 
-      def possible_source_file?: (untyped path) -> untyped
+      def possible_source_file?: (Pathname path) -> bool
 
-      def possible_signature_file?: (untyped path) -> untyped
+      def possible_signature_file?: (Pathname path) -> bool
 
-      def new_env_loader: (project: untyped) -> untyped
+      def new_env_loader: (project: Project) -> RBS::EnvironmentLoader
 
-      def self.construct_env_loader: (options: untyped, project: untyped) -> untyped
+      def self.construct_env_loader: (options: Options, project: Project) -> RBS::EnvironmentLoader
     end
   end
 end

data/sig/steep/server/base_worker.rbs

@@ -9,7 +9,7 @@ module Steep
         def close: () -> void
       end
 
-      LSP: untyped
+      module LSP = LanguageServer::Protocol
 
       @skip_jobs_after_shutdown: bool
 

data/sig/steep/server/interaction_worker.rbs

@@ -1,41 +1,70 @@
+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
 
-      HoverJob: untyped
+        def initialize: (id: String, path: Pathname, line: Integer, column: Integer, trigger: String) -> void
+      end
 
-      CompletionJob: untyped
+      type job = ApplyChangeJob | HoverJob | CompletionJob
 
-      LSP: untyped
+      module LSP = LanguageServer::Protocol
 
-      attr_reader service: untyped
+      attr_reader service: Services::TypeCheckService
 
-      def initialize: (project: untyped, reader: untyped, writer: untyped, ?queue: untyped) -> void
+      def initialize: (project: Project, reader: Reader, writer: Writer, ?queue: Queue) -> void
 
-      def handle_job: (untyped job) -> untyped
+      def handle_job: (job) -> void
 
-      def handle_request: (untyped request) -> untyped
+      type lsp_request = { id: String, method: String, params: untyped }
 
-      def process_hover: (untyped job) -> untyped
+      def handle_request: (lsp_request) -> void
 
-      def process_completion: (untyped job) -> untyped
+      def process_hover: (HoverJob job) -> untyped
 
-      def format_completion_item_for_rbs: (untyped sig_service, untyped type_name, untyped context, untyped job, untyped prefix) -> (nil | untyped)
+      def process_completion: (CompletionJob job) -> untyped
 
-      def format_comment: (untyped comment) -> (untyped | nil)
+      def format_completion_item_for_rbs: (Services::SignatureService, RBS::TypeName, CompletionJob job, String complete_text, Integer prefix_size) -> untyped
 
-      def format_comments: (untyped comments) -> (untyped | nil)
+      def format_comment: (Comment? comment) -> untyped?
 
-      def format_completion_item: (untyped item) -> untyped
+      def format_comments: (Array[RBS::AST::Comment] comments) -> untyped?
 
-      def method_type_to_snippet: (untyped method_type) -> ::String
+      def format_completion_item: (CompletionProvider::item item) -> untyped
 
-      def params_to_snippet: (untyped fun) -> untyped
+      def method_type_to_snippet: (RBS::MethodType method_type) -> ::String
 
-      def relative_name_in_context: (untyped type_name, untyped context) -> untyped
+      def params_to_snippet: (RBS::Types::Function fun) -> String
     end
   end
 end

data/sig/steep/server/lsp_formatter.rbs

@@ -28,8 +28,10 @@ module Steep
       type summarizable_decl = ::RBS::AST::Declarations::Class
                              | ::RBS::AST::Declarations::Module
                              | ::RBS::AST::Declarations::Interface
-                             | ::RBS::AST::Declarations::Alias
-                             
+                             | ::RBS::AST::Declarations::TypeAlias
+                             | ::RBS::AST::Declarations::ClassAlias
+                             | ::RBS::AST::Declarations::ModuleAlias
+
       def self?.declaration_summary: (summarizable_decl) -> String
     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,