steep 1.4.0.dev.2 → 1.4.0.dev.4

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_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/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 || [],
@@ -549,7 +569,9 @@ module Steep
 
       def each
         if block_given?
-          errors = []
+          errors = [] #: Array[PositionalArgs::error_arg | KeywordArgs::error_arg]
+
+          last_positional_args = positional_arg
 
           positional_arg.tap do |args|
             while (value, args = args.next())
@@ -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
+            forward_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: forward_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

@@ -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
@@ -308,7 +310,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.4"
 end

data/lib/steep.rb

@@ -105,7 +105,9 @@ 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/signature_help_provider"
 require "steep/services/stats_calculator"
 require "steep/services/file_loader"
 require "steep/services/goto_service"

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/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/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