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

data/lib/steep/type_inference/block_params.rb

@@ -328,6 +328,19 @@ module Steep
         end
       end
 
+      def each_single_param()
+        each do |param|
+          case param
+          when Param
+            yield param
+          when MultipleParam
+            param.each_param do |p|
+              yield p
+            end
+          end
+        end
+      end
+
       def self.from_multiple(node, annotations)
         # @type var params: Array[Param | MultipleParam]
         params = []

data/lib/steep/type_inference/context.rb

@@ -6,16 +6,16 @@ module Steep
         attr_reader :method
         attr_reader :method_type
         attr_reader :return_type
-        attr_reader :constructor
         attr_reader :super_method
+        attr_reader :forward_arg_type
 
-        def initialize(name:, method:, method_type:, return_type:, constructor:, super_method:)
+        def initialize(name:, method:, method_type:, return_type:, super_method:, forward_arg_type:)
           @name = name
           @method = method
           @return_type = return_type
           @method_type = method_type
-          @constructor = constructor
           @super_method = super_method
+          @forward_arg_type = forward_arg_type
         end
 
         def block_type

data/lib/steep/type_inference/method_params.rb

@@ -143,24 +143,34 @@ module Steep
       attr_reader :method_type
       attr_reader :params
       attr_reader :errors
+      attr_reader :forward_arg_type
 
-      def initialize(args:, method_type:)
+      def initialize(args:, method_type:, forward_arg_type:)
         @args = args
         @method_type = method_type
         @params = {}
         @errors = []
+        @forward_arg_type = forward_arg_type
       end
 
       def [](name)
         params[name] or raise "Unknown variable name: #{name}"
       end
 
+      def param?(name)
+        params.key?(name)
+      end
+
       def size
         params.size
       end
 
       def each_param(&block)
-        params.each_value(&block)
+        if block
+          params.each_value(&block)
+        else
+          params.each_value
+        end
       end
 
       def each
@@ -173,7 +183,12 @@ module Steep
         end
       end
 
+      def update(forward_arg_type: self.forward_arg_type)
+        MethodParams.new(args: args, method_type: method_type, forward_arg_type: forward_arg_type)
+      end
+
       def self.empty(node:)
+        # @type var args_node: ::Parser::AST::Node
         args_node =
           case node.type
           when :def
@@ -184,9 +199,10 @@ module Steep
             raise
           end
 
-        params = new(args: args_node.children, method_type: nil)
+        params = new(args: args_node.children, method_type: nil, forward_arg_type: nil)
 
         args_node.children.each do |arg|
+          # @type var arg: ::Parser::AST::Node
           case arg.type
           when :arg, :optarg
             name = arg.children[0]
@@ -210,6 +226,7 @@ module Steep
       end
 
       def self.build(node:, method_type:)
+        # @type var args_node: ::Parser::AST::Node
         args_node =
           case node.type
           when :def
@@ -219,17 +236,17 @@ module Steep
           else
             raise
           end
-        original = args_node.children
+        original = args_node.children #: Array[Parser::AST::Node]
         args = original.dup
 
-        instance = new(args: original, method_type: method_type)
+        instance = new(args: original, method_type: method_type, forward_arg_type: nil)
 
         positional_params = method_type.type.params.positional_params
 
         loop do
-          arg = args.first
+          arg = args.first or break
 
-          case arg&.type
+          case arg.type
           when :arg
             name = arg.children[0]
             param = positional_params&.head
@@ -300,9 +317,14 @@ module Steep
           args.shift
         end
 
-        if (arg = args.first)&.type == :restarg
+        if (arg = args.first) && arg.type == :forward_arg
+          forward_params = method_type.type.params.update(positional_params: positional_params)
+          return instance.update(forward_arg_type: [forward_params, method_type.block])
+        end
+
+        if (arg = args.first) && arg.type == :restarg
           name = arg.children[0]
-          rest_types = []
+          rest_types = [] #: Array[AST::Types::t]
           has_error = false
 
           loop do
@@ -325,7 +347,11 @@ module Steep
               break
             end
 
-            positional_params = positional_params.tail
+            if positional_params
+              positional_params = positional_params.tail
+            else
+              raise "Fatal error"
+            end
           end
 
           type = rest_types.empty? ? nil : AST::Types::Union.build(types: rest_types)
@@ -348,9 +374,9 @@ module Steep
         keywords = keyword_params.keywords
 
         loop do
-          arg = args.first
+          arg = args.first or break
 
-          case arg&.type
+          case arg.type
           when :kwarg
             name = arg.children[0]
 
@@ -421,9 +447,9 @@ module Steep
           args.shift
         end
 
-        if (arg = args.first)&.type == :kwrestarg
+        if (arg = args.first) && arg.type == :kwrestarg
           name = arg.children[0]
-          rest_types = []
+          rest_types = [] #: Array[AST::Types::t]
           has_error = false
 
           keywords.each do |keyword|
@@ -460,8 +486,8 @@ module Steep
           end
         end
 
-        if (arg = args.first)&.type == :blockarg
-          name = arg.children[0]
+        if (arg = args.first) && arg.type == :blockarg
+          name = arg.children[0] #: Symbol
 
           if method_type.block
             instance.params[name] = BlockParameter.new(

data/lib/steep/type_inference/send_args.rb

@@ -101,6 +101,9 @@ module Steep
 
         def next()
           case
+          when node && node.type == :forwarded_args
+            # If the node is a `:forwarded_args`, abort
+            nil
           when !node && param.is_a?(Interface::Function::Params::PositionalParams::Required)
             [
               MissingArg.new(params: positional_params),
@@ -410,8 +413,8 @@ module Steep
             when type = keyword_type(key)
               consumed_keys << key
               types << type
-            when rest_type
-              types << rest_type
+            when type = rest_type()
+              types << type
             else
               unexpected_keyword = key
             end
@@ -483,6 +486,15 @@ module Steep
         end
       end
 
+      class ForwardedArgs
+        attr_reader :node, :params
+
+        def initialize(node:, params:)
+          @node = node
+          @params = params
+        end
+      end
+
       attr_reader :node
       attr_reader :arguments
       attr_reader :type
@@ -499,6 +511,8 @@ module Steep
           type.type.params
         when AST::Types::Proc
           type.type.params
+        else
+          raise
         end
       end
 
@@ -526,14 +540,20 @@ module Steep
       end
 
       def positional_arg
-        args = if keyword_params.empty?
-                 arguments.take_while {|node| node.type != :block_pass }
-               else
-                 arguments.take_while {|node| node.type != :kwargs && node.type != :block_pass }
-               end
+        args =
+          if keyword_params.empty?
+            arguments.take_while {|node| node.type != :block_pass }
+          else
+            arguments.take_while {|node| node.type != :kwargs && node.type != :block_pass }
+          end
+
         PositionalArgs.new(args: args, index: 0, positional_params: positional_params)
       end
 
+      def forwarded_args_node
+        arguments.find {|node| node.type == :forwarded_args }
+      end
+
       def keyword_args
         KeywordArgs.new(
           kwarg_nodes: kwargs_node&.children || [],
@@ -551,6 +571,8 @@ module Steep
         if block_given?
           errors = []
 
+          last_positional_args = positional_arg
+
           positional_arg.tap do |args|
             while (value, args = args.next())
               yield value
@@ -591,66 +613,73 @@ module Steep
               when PositionalArgs::UnexpectedArg, PositionalArgs::MissingArg
                 errors << value
               end
+
+              last_positional_args = args
             end
           end
 
-          keyword_args.tap do |args|
-            while (a, args = args.next)
-              case a
-              when KeywordArgs::MissingKeyword
-                errors << a
-              when KeywordArgs::UnexpectedKeyword
-                errors << a
-              end
-
-              yield a
-
-              case a
-              when KeywordArgs::SplatArg
-                case type = a.type
-                when nil
-                  raise
-                when AST::Types::Record
-                  # @type var keys: Array[Symbol]
-                  keys = _ = type.elements.keys
-                  ts, args = args.consume_keys(keys, node: a.node)
+          if fag = forwarded_args_node
+            params = Interface::Function::Params.new(
+              positional_params: last_positional_args.positional_params,
+              keyword_params: keyword_params
+            )
 
-                  case ts
-                  when KeywordArgs::UnexpectedKeyword
-                    yield ts
-                    errors << ts
-                  when Array
-                    record = AST::Types::Record.new(elements: Hash[keys.zip(ts)])
-                    yield KeywordArgs::ArgTypePairs.new(pairs: [[a.node, record]])
-                  end
-                else
-                  args = args.update(index: args.index + 1)
+            forwarded_args = ForwardedArgs.new(node: fag, params: params)
+          else
+            keyword_args.tap do |args|
+              while (a, args = args.next)
+                case a
+                when KeywordArgs::MissingKeyword
+                  errors << a
+                when KeywordArgs::UnexpectedKeyword
+                  errors << a
+                end
 
-                  if args.rest_type
-                    type = AST::Builtin::Hash.instance_type(AST::Builtin::Symbol.instance_type, args.possible_value_type)
-                    yield KeywordArgs::ArgTypePairs.new(pairs: [[a.node, type]])
+                yield a
+
+                case a
+                when KeywordArgs::SplatArg
+                  case type = a.type
+                  when nil
+                    raise
+                  when AST::Types::Record
+                    # @type var keys: Array[Symbol]
+                    keys = _ = type.elements.keys
+                    ts, args = args.consume_keys(keys, node: a.node)
+
+                    case ts
+                    when KeywordArgs::UnexpectedKeyword
+                      yield ts
+                      errors << ts
+                    when Array
+                      pairs = keys.zip(ts) #: Array[[Symbol, AST::Types::t]]
+                      record = AST::Types::Record.new(elements: Hash[pairs])
+                      yield KeywordArgs::ArgTypePairs.new(pairs: [[a.node, record]])
+                    end
                   else
-                    yield KeywordArgs::UnexpectedKeyword.new(keyword: nil, node: a.node)
+                    args = args.update(index: args.index + 1)
+
+                    if args.rest_type
+                      type = AST::Builtin::Hash.instance_type(AST::Builtin::Symbol.instance_type, args.possible_value_type)
+                      yield KeywordArgs::ArgTypePairs.new(pairs: [[a.node, type]])
+                    else
+                      yield KeywordArgs::UnexpectedKeyword.new(keyword: nil, node: a.node)
+                    end
                   end
                 end
               end
             end
           end
 
-          # pass = block_pass_arg
-          # if pass.node
-          #   yield pass
-          # end
-
-          diagnostics = []
+          diagnostics = [] #: Array[Diagnostic::Ruby::Base]
 
-          missing_keywords = []
+          missing_keywords = [] #: Array[Symbol]
           errors.each do |error|
             case error
             when KeywordArgs::UnexpectedKeyword
               diagnostics << Diagnostic::Ruby::UnexpectedKeywordArgument.new(node: error.node, params: params)
             when KeywordArgs::MissingKeyword
-              missing_keywords.push(*error.keywords)
+              missing_keywords.push(*error.keywords.to_a)
             when PositionalArgs::UnexpectedArg
               diagnostics << Diagnostic::Ruby::UnexpectedPositionalArgument.new(node: error.node, params: params)
             when PositionalArgs::MissingArg
@@ -662,7 +691,7 @@ module Steep
             diagnostics << Diagnostic::Ruby::InsufficientKeywordArguments.new(node: node, params: params, missing_keywords: missing_keywords)
           end
 
-          diagnostics
+          [forwarded_args, diagnostics]
         else
           enum_for :each
         end

data/lib/steep/type_inference/type_env.rb

@@ -308,7 +308,13 @@ module Steep
       end
 
       def local_variable_name?(name)
-        name.start_with?(/[a-z_]/) && name != :_ && name != :__skip__ && name != :__any__
+        # Ruby constants start with Uppercase_Letter or Titlecase_Letter in the unicode property.
+        # If name start with `@`, it is instance variable or class instance variable.
+        # If name start with `$`, it is global variable.
+        return false if name.start_with?(/[\p{Uppercase_Letter}\p{Titlecase_Letter}@$]/)
+        return false if TypeConstruction::SPECIAL_LVAR_NAMES.include?(name)
+
+        true
       end
 
       def local_variable_name!(name)

data/lib/steep/version.rb

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

data/lib/steep.rb

@@ -105,6 +105,7 @@ require "steep/services/type_check_service"
 require "steep/services/hover_provider/singleton_methods"
 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/stats_calculator"
 require "steep/services/file_loader"

data/rbs_collection.steep.lock.yaml

@@ -15,14 +15,6 @@ gems:
     revision: c42c09528dd99252db98f0744181a6de54ec2f55
     remote: https://github.com/ruby/gem_rbs_collection.git
     repo_dir: gems
-- name: ast
-  version: '2.4'
-  source:
-    type: git
-    name: ruby/gem_rbs_collection
-    revision: c42c09528dd99252db98f0744181a6de54ec2f55
-    remote: https://github.com/ruby/gem_rbs_collection.git
-    repo_dir: gems
 - name: concurrent-ruby
   version: '1.1'
   source:
@@ -39,10 +31,6 @@ gems:
   version: '0'
   source:
     type: stdlib
-- name: dbm
-  version: '0'
-  source:
-    type: stdlib
 - name: fileutils
   version: '0'
   source:
@@ -87,18 +75,6 @@ gems:
   version: '0'
   source:
     type: stdlib
-- name: optparse
-  version: '0'
-  source:
-    type: stdlib
-- name: parallel
-  version: '1.20'
-  source:
-    type: git
-    name: ruby/gem_rbs_collection
-    revision: c42c09528dd99252db98f0744181a6de54ec2f55
-    remote: https://github.com/ruby/gem_rbs_collection.git
-    repo_dir: gems
 - name: pathname
   version: '0'
   source:
@@ -115,10 +91,6 @@ gems:
   version: '0'
   source:
     type: stdlib
-- name: set
-  version: '0'
-  source:
-    type: stdlib
 - name: singleton
   version: '0'
   source:

data/rbs_collection.steep.yaml

@@ -9,14 +9,15 @@ sources:
 path: .gem_rbs_collection
 
 gems:
-  # Skip loading rbs gem's RBS.
-  # It's unnecessary if you don't use rbs as a library.
-  - name: steep
-    ignore: true
-  - name: set
-  - name: rbs
-    ignore: true
   - name: with_steep_types
     ignore: true
-  - name: dbm
-  - name: optparse
+  - name: activesupport
+  - name: rainbow
+  - name: listen
+  - name: json
+  - name: logger
+  - name: fileutils
+  - name: strscan
+  - name: csv
+  - name: pathname
+  - name: securerandom

data/sample/lib/conference.rb

@@ -20,3 +20,15 @@ Konference.new()
 # @type var foo: Konference
 
 foo = Conference.new
+
+class Conference12
+  class Integer
+
+  end
+end
+
+class HogeHoge
+  def foo(...)
+    bar(self, ...).to_s
+  end
+end

data/sample/sig/conference.rbs

@@ -35,3 +35,8 @@ type foo = [Conference, Konference]
 
 type b = ::Foo::OBH
 
+class HogeHoge
+  def foo: (Integer, bar: String) -> String
+
+  def bar: (Object, Integer, bar: String, ?baz: Integer) { () -> Integer } -> Integer
+end

data/sig/shims/language-server_protocol.rbs

@@ -16,5 +16,17 @@ module LanguageServer
         end
       end
     end
+
+    module Constant
+      module DiagnosticSeverity
+        ERROR: String
+
+        WARNING: String
+
+        INFORMATION: String
+
+        HINT: String
+      end
+    end
   end
 end

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/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,17 +61,17 @@ 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?
 

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?]