steep 1.4.0.dev.2 → 1.4.0.dev.3

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

@@ -77,6 +77,8 @@ module Steep
         def inherited?: () -> bool
       end
 
+      type item = InstanceVariableItem | LocalVariableItem | ConstantItem | MethodNameItem
+
       attr_reader source_text: String
 
       attr_reader path: Pathname

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