steep 1.4.0.dev.3 → 1.4.0.dev.4

data/lib/steep/type_construction.rb

@@ -1911,10 +1911,12 @@ module Steep
                 when_clause_constr = condition_constr
                 body_envs = [] #: Array[TypeInference::TypeEnv]
 
+                # @type var tests: Array[Parser::AST::Node]
+                # @type var body: Parser::AST::Node?
                 *tests, body = when_clause.children
 
                 tests.each do |test|
-                  test_type, condition_constr = condition_constr.synthesize(test, condition: true).to_ary
+                  test_type, condition_constr = condition_constr.synthesize(test, condition: true)
                   truthy_env, falsy_env = interpreter.eval(env: condition_constr.context.type_env, node: test)
 
                   condition_constr = condition_constr.update_type_env { falsy_env }
@@ -3181,46 +3183,65 @@ module Steep
       receiver_type = checker.factory.deep_expand_alias(recv_type)
       private = receiver.nil? || receiver.type == :self
 
-      type, constr = case receiver_type
-                     when nil
-                       raise
-
-                     when AST::Types::Any
-                       constr = constr.synthesize_children(node, skips: [receiver])
-                       constr.add_call(
-                         TypeInference::MethodCall::Untyped.new(
-                           node: node,
-                           context: context.call_context,
-                           method_name: method_name
-                         )
-                       )
+      type, constr =
+        case receiver_type
+        when nil
+          raise
 
-                     else
-                       if interface = calculate_interface(receiver_type, private: private)
-                         constr.type_send_interface(
-                           node,
-                           interface: interface,
-                           receiver: receiver,
-                           receiver_type: receiver_type,
-                           method_name: method_name,
-                           arguments: arguments,
-                           block_params: block_params,
-                           block_body: block_body,
-                           tapp: tapp
-                         )
-                       else
-                         constr = constr.synthesize_children(node, skips: [receiver])
-                         constr.add_call(
-                           TypeInference::MethodCall::NoMethodError.new(
-                             node: node,
-                             context: context.call_context,
-                             method_name: method_name,
-                             receiver_type: receiver_type,
-                             error: Diagnostic::Ruby::NoMethod.new(node: node, method: method_name, type: receiver_type)
-                           )
-                         )
-                       end
-                     end
+        when AST::Types::Any
+          case node.type
+          when :block, :numblock
+            # @type var node: Parser::AST::Node & Parser::AST::_BlockNode
+            block_annotations = source.annotations(block: node, factory: checker.factory, context: nesting)
+            block_params or raise
+
+            constr = constr.synthesize_children(node.children[0])
+
+            constr.type_block_without_hint(
+              node: node,
+              block_params: TypeInference::BlockParams.from_node(block_params, annotations: block_annotations),
+              block_annotations: block_annotations,
+              block_body: block_body
+            ) do |error|
+              constr.typing.errors << error
+            end
+          else
+            constr = constr.synthesize_children(node, skips: [receiver])
+          end
+
+          constr.add_call(
+            TypeInference::MethodCall::Untyped.new(
+              node: node,
+              context: context.call_context,
+              method_name: method_name
+            )
+          )
+        else
+          if interface = calculate_interface(receiver_type, private: private)
+            constr.type_send_interface(
+              node,
+              interface: interface,
+              receiver: receiver,
+              receiver_type: receiver_type,
+              method_name: method_name,
+              arguments: arguments,
+              block_params: block_params,
+              block_body: block_body,
+              tapp: tapp
+            )
+          else
+            constr = constr.synthesize_children(node, skips: [receiver])
+            constr.add_call(
+              TypeInference::MethodCall::NoMethodError.new(
+                node: node,
+                context: context.call_context,
+                method_name: method_name,
+                receiver_type: receiver_type,
+                error: Diagnostic::Ruby::NoMethod.new(node: node, method: method_name, type: receiver_type)
+              )
+            )
+          end
+        end
 
       Pair.new(type: type, constr: constr)
     end

data/lib/steep/type_inference/method_call.rb

@@ -1,6 +1,6 @@
 module Steep
   module TypeInference
-    class MethodCall
+    module MethodCall
       class MethodDecl
         attr_reader :method_name
         attr_reader :method_def

data/lib/steep/type_inference/send_args.rb

@@ -569,7 +569,7 @@ module Steep
 
       def each
         if block_given?
-          errors = []
+          errors = [] #: Array[PositionalArgs::error_arg | KeywordArgs::error_arg]
 
           last_positional_args = positional_arg
 
@@ -619,12 +619,12 @@ module Steep
           end
 
           if fag = forwarded_args_node
-            params = Interface::Function::Params.new(
+            forward_params = Interface::Function::Params.new(
               positional_params: last_positional_args.positional_params,
               keyword_params: keyword_params
             )
 
-            forwarded_args = ForwardedArgs.new(node: fag, params: params)
+            forwarded_args = ForwardedArgs.new(node: fag, params: forward_params)
           else
             keyword_args.tap do |args|
               while (a, args = args.next)

data/lib/steep/type_inference/type_env.rb

@@ -242,12 +242,14 @@ module Steep
 
         common_pure_nodes = envs
           .map {|env| Set.new(env.pure_method_calls.each_key) }
-          .inject(Set.new(pure_method_calls.each_key)) {|s1, s2| s1.intersection(s2) }
+          .inject {|s1, s2| s1.intersection(s2) } || Set[]
 
         pure_call_updates = common_pure_nodes.each_with_object({}) do |node, hash|
           pairs = envs.map {|env| env.pure_method_calls[node] }
-          refined_type = AST::Types::Union.build(types: pairs.map {|pair| pair[1] || pair[0].return_type })
-          call, _ = (pure_method_calls[node] or raise)
+          refined_type = AST::Types::Union.build(types: pairs.map {|call, type| type || call.return_type })
+
+          # Any *pure_method_call* can be used because it's *pure*
+          (call, _ = envs[0].pure_method_calls[node]) or raise
 
           hash[node] = [call, refined_type]
         end

data/lib/steep/version.rb

@@ -1,3 +1,3 @@
 module Steep
-  VERSION = "1.4.0.dev.3"
+  VERSION = "1.4.0.dev.4"
 end

data/lib/steep.rb

@@ -107,6 +107,7 @@ require "steep/services/hover_provider/ruby"
 require "steep/services/hover_provider/rbs"
 require "steep/services/type_name_completion"
 require "steep/services/completion_provider"
+require "steep/services/signature_help_provider"
 require "steep/services/stats_calculator"
 require "steep/services/file_loader"
 require "steep/services/goto_service"

data/sample/Steepfile

@@ -5,6 +5,8 @@ target :lib do
 
   check "lib"                       # Directory name
 
+  library "rbs"
+
   # configure_code_diagnostics(D::Ruby.strict)       # `strict` diagnostics setting
   # configure_code_diagnostics(D::Ruby.lenient)      # `lenient` diagnostics setting
   # configure_code_diagnostics do |hash|             # You can setup everything yourself

data/sig/shims/language-server_protocol.rbs

@@ -27,6 +27,271 @@ module LanguageServer
 
         HINT: String
       end
+
+      module CompletionItemKind
+        type t = Integer
+
+        TEXT: Integer
+        METHOD: Integer
+        FUNCTION: Integer
+        CONSTRUCTOR: Integer
+        FIELD: Integer
+        VARIABLE: Integer
+        CLASS: Integer
+        INTERFACE: Integer
+        MODULE: Integer
+        PROPERTY: Integer
+        UNIT: Integer
+        VALUE: Integer
+        ENUM: Integer
+        KEYWORD: Integer
+        SNIPPET: Integer
+        COLOR: Integer
+        FILE: Integer
+        REFERENCE: Integer
+        FOLDER: Integer
+        ENUMMEMBER: Integer
+        CONSTANT: Integer
+        STRUCT: Integer
+        EVENT: Integer
+        OPERATOR: Integer
+        TYPEPARAMETER: Integer
+      end
+
+      module CompletionItemTag
+        type t = Integer
+
+        Deprecated: Integer
+      end
+
+      module InsertTextFormat
+        type t = Integer
+
+        PLAIN_TEXT: Integer
+
+        SNIPPET: Integer
+      end
+
+      module InsertTextMode
+        type t = Integer
+
+        AS_IS: Integer
+
+        ADJUST_INDENTATION: Integer
+      end
+
+      module MarkupKind
+        type t = "plaintext" | "markdown"
+
+        PLAINTEXT: "plaintext"
+
+        MARKDOWN: "markdown"
+      end
+    end
+
+    module Interface
+      interface _Base
+        def attributes: () -> Hash[Symbol, untyped]
+
+        alias to_hash attributes
+
+        def to_json: () -> String
+      end
+
+      class Position
+        include _Base
+
+        # 0-origin line number
+        attr_reader line: Integer
+
+        # 0-origin character position (== cursor position)
+        attr_reader character: Integer
+
+        def initialize: (line: Integer, character: Integer) -> void
+                      | (Hash[Symbol, untyped]) -> void
+      end
+
+      class Range
+        include _Base
+
+        attr_reader start: Position
+
+        attr_reader end: Position
+
+        def initialize: (start: Position, end: Position) -> void
+                      | (Hash[Symbol, untyped]) -> void
+      end
+
+      class MarkupContent
+        include _Base
+
+        attr_reader kind: Constant::MarkupKind::t
+
+        attr_reader value: String
+
+        def initialize: (kind: Constant::MarkupKind::t, value: String) -> void
+      end
+
+      class TextEdit
+        include _Base
+
+        attr_reader range: Range
+
+        attr_reader new_text: String
+
+        def initialize: (range: Range, new_text: String) -> void
+      end
+
+      class InsertReplaceEdit
+        include _Base
+
+        attr_reader new_text: String
+
+        attr_reader insert: Range
+
+        attr_reader replace: Range
+
+        def initialize: (new_text: String, insert: Range, replace: Range) -> void
+      end
+
+      class Command
+        include _Base
+
+        attr_reader title: String
+
+        attr_reader command: String
+
+        attr_reader arguments: Array[untyped]?
+
+        def initialize: (title: String, command: String, ?arguments: Array[untyped]?) -> void
+      end
+
+      class Hover
+        include _Base
+
+        attr_reader contents: MarkupContent
+
+        attr_reader range: Range
+
+        def initialize: (contents: MarkupContent, range: Range) -> void
+      end
+
+      class CompletionList
+        include _Base
+
+        attr_reader is_incomplete: bool
+
+        attr_reader items: Array[CompletionItem]
+
+        def initialize: (items: Array[CompletionItem], is_incomplete: bool) -> void
+      end
+
+      class CompletionItem
+        include _Base
+
+        attr_reader label: String
+
+        attr_reader label_details: CompletionItemLabelDetails?
+
+        attr_reader kind: Constant::CompletionItemKind::t?
+
+        attr_reader tags: Array[Constant::CompletionItemTag::t]?
+
+        attr_reader detail: String?
+
+        attr_reader documentation: MarkupContent?
+
+        attr_reader preselect: bool?
+
+        attr_reader sort_text: String?
+
+        attr_reader filter_text: String?
+
+        attr_reader insert_text: String?
+
+        attr_reader insert_text_format: Constant::InsertTextFormat::t?
+
+        attr_reader insert_text_mode: Constant::InsertTextMode::t?
+
+        attr_reader text_edit: TextEdit | InsertReplaceEdit | nil
+
+        attr_reader text_edit_text: String?
+
+        attr_reader additional_text_edits: Array[TextEdit]?
+
+        attr_reader commit_characters: Array[String]?
+
+        attr_reader command: Command?
+
+        attr_reader data: untyped?
+
+        def initialize:(
+          label: String,
+          ?label_details: CompletionItemLabelDetails?,
+          ?kind: Constant::CompletionItemKind::t?,
+          ?tags: Array[Constant::CompletionItemTag::t]?,
+          ?detail: String?,
+          ?documentation: MarkupContent?,
+          ?preselect: bool?,
+          ?sort_text: String?,
+          ?filter_text: String?,
+          ?insert_text: String?,
+          ?insert_text_format: Constant::InsertTextFormat::t?,
+          ?insert_text_mode: Constant::InsertTextMode::t?,
+          ?text_edit: TextEdit | InsertReplaceEdit | nil,
+          ?text_edit_text: String?,
+          ?additional_text_edits: Array[TextEdit]?,
+          ?commit_characters: Array[String]?,
+          ?command: Command?,
+          ?data: untyped?
+        ) -> void
+      end
+
+      class CompletionItemLabelDetails
+        include _Base
+
+        attr_reader detail: String?
+
+        attr_reader description: String?
+
+        def initialize: (?detail: String?, ?description: String?) -> void
+      end
+
+      class SignatureInformation
+        include _Base
+
+        attr_reader label: String
+
+        attr_reader documentation: MarkupContent?
+
+        attr_reader parameters: Array[ParameterInformation]?
+
+        attr_reader active_parameter: Integer?
+
+        def initialize: (label: String, ?documentation: MarkupContent?, ?parameters: Array[ParameterInformation]?, ?active_parameter: Integer?) -> void
+      end
+
+      class ParameterInformation
+        include _Base
+
+        attr_reader label: String | [Integer, Integer]
+
+        attr_reader documentation: MarkupContent?
+
+        def initialize: (label: String | [Integer, Integer], ?documentation: MarkupContent) -> void
+      end
+
+      class SignatureHelp
+        include _Base
+
+        attr_reader signatures: Array[SignatureInformation]
+
+        attr_reader active_signature: Integer?
+
+        attr_reader active_parameter: Integer?
+
+        def initialize: (signatures: Array[SignatureInformation], ?active_signature: Integer?, ?active_parameter: Integer?) -> void
+      end
     end
   end
 end

data/sig/shims/parser.rbs

@@ -43,4 +43,7 @@ module Parser
       def value: (untyped) -> untyped
     end
   end
+
+  class SyntaxError < StandardError
+  end
 end

data/sig/steep/method_name.rbs

@@ -6,6 +6,8 @@ module Steep
     attr_reader method_name: Symbol
 
     def initialize: (type_name: RBS::TypeName, method_name: Symbol) -> void
+
+    def relative: () -> InstanceMethodName
   end
 
   class SingletonMethodName
@@ -13,6 +15,8 @@ module Steep
     attr_reader method_name: Symbol
 
     def initialize: (type_name: RBS::TypeName, method_name: Symbol) -> void
+
+    def relative: () -> SingletonMethodName
   end
 
   class ::Object
@@ -20,7 +24,7 @@ module Steep
     #
     # * `ClassName#method_name` syntax returns an `InstanceMethodName` object
     # * `ClassName.method_name` syntax returns a `SingletonMethodName` object
-    # 
+    #
     def MethodName: (String string) -> (InstanceMethodName | SingletonMethodName)
   end
 end

data/sig/steep/server/interaction_worker.rbs

@@ -36,7 +36,19 @@ module Steep
         def initialize: (id: String, path: Pathname, line: Integer, column: Integer, trigger: String) -> void
       end
 
-      type job = ApplyChangeJob | HoverJob | CompletionJob
+      class SignatureHelpJob
+        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
+
+      type job = ApplyChangeJob | HoverJob | CompletionJob | SignatureHelpJob
 
       module LSP = LanguageServer::Protocol
 
@@ -50,21 +62,15 @@ module Steep
 
       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 process_hover: (HoverJob job) -> LanguageServer::Protocol::Interface::Hover?
 
-      def format_comments: (Array[RBS::AST::Comment] comments) -> untyped?
+      def process_completion: (CompletionJob job) -> LanguageServer::Protocol::Interface::CompletionList?
 
-      def format_completion_item: (CompletionProvider::item item) -> untyped
+      def process_signature_help: (SignatureHelpJob) -> LanguageServer::Protocol::Interface::SignatureHelp?
 
-      def method_type_to_snippet: (RBS::MethodType method_type) -> ::String
+      def format_completion_item_for_rbs: (Services::SignatureService, RBS::TypeName, CompletionJob job, String complete_text, Integer prefix_size) -> LanguageServer::Protocol::Interface::CompletionItem
 
-      def params_to_snippet: (RBS::Types::Function fun) -> String
+      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