steep 1.7.0.dev.3 → 1.7.0.dev.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c30f769d118a31c069ae146f976dc3df96b71acfa50659e6f03b00bdc1624da7
-  data.tar.gz: '064953d68e749654f069f2ea215746366a58506406ec5977826f5cf73552f779'
+  metadata.gz: 17795ed14e183d6e8858e6ea8f57f71dbd3cdced0e4d9cf7e43c646188e486cd
+  data.tar.gz: 7005e9d96f44f23a47f1844597b86fd3d774f000b1de5cf100d235e68c56a0b5
 SHA512:
-  metadata.gz: 4ce31d8368b84b72284eb331606a6f1c15b3843a2c13a01770bcac35c4f9fa35ab5a62617a4d13c913c482b1775fc043265a8fbdb5a58e7598e9ad92a2246fda
-  data.tar.gz: 206491dcd015533b092afe61277f48e28e288693c9ffadaa85aa855b0616ab9f64ba7001b297a7387432fec3492aed55f16ac5ebba3b379cb7bf79575249700c
+  metadata.gz: e178baa7a185edaafb359032266bfa7f29d082c9da30ca418e5ef4030b5723423f3f36ba4165a640d996e252bb91883dcfe55b1f750f51c3153452b368e5a9ee
+  data.tar.gz: 8919d4c047097e7e7fd63ecba71ae96f412a56588c7b6ff1d381838d2d935d2ba7dc382ca83fe5b679f35ebbe298460e80e87047c88b6ebcc5e3e6ef258e2535

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    steep (1.7.0.dev.3)
+    steep (1.7.0.dev.4)
       activesupport (>= 5.1)
       concurrent-ruby (>= 1.1.10)
       csv (>= 3.0.9)
@@ -12,7 +12,7 @@ PATH
       logger (>= 1.3.0)
       parser (>= 3.1)
       rainbow (>= 2.2.2, < 4.0)
-      rbs (>= 3.1.0)
+      rbs (>= 3.5.0.pre)
       securerandom (>= 0.1)
       strscan (>= 1.0.0)
       terminal-table (>= 2, < 4)
@@ -33,23 +33,23 @@ GEM
       tzinfo (~> 2.0)
     ast (2.4.2)
     base64 (0.2.0)
-    bigdecimal (3.1.7)
+    bigdecimal (3.1.8)
     concurrent-ruby (1.2.3)
     connection_pool (2.4.1)
     csv (3.3.0)
-    debug (1.9.1)
+    debug (1.9.2)
       irb (~> 1.10)
       reline (>= 0.3.8)
     drb (2.2.1)
     ffi (1.16.3)
     fileutils (1.7.2)
-    i18n (1.14.4)
+    i18n (1.14.5)
       concurrent-ruby (~> 1.0)
     io-console (0.7.2)
-    irb (1.12.0)
-      rdoc
+    irb (1.13.1)
+      rdoc (>= 4.0.0)
       reline (>= 0.4.2)
-    json (2.7.1)
+    json (2.7.2)
     language_server-protocol (3.17.0.3)
     listen (3.9.0)
       rb-fsevent (~> 0.10, >= 0.10.3)
@@ -61,22 +61,22 @@ GEM
     minitest-slow_test (0.2.0)
       minitest (>= 5.0)
     mutex_m (0.2.0)
-    parser (3.3.0.5)
+    parser (3.3.1.0)
       ast (~> 2.4.1)
       racc
     psych (5.1.2)
       stringio
     racc (1.7.3)
     rainbow (3.1.1)
-    rake (13.1.0)
+    rake (13.2.1)
     rb-fsevent (0.11.2)
     rb-inotify (0.10.1)
       ffi (~> 1.0)
-    rbs (3.4.4)
+    rbs (3.5.0.pre.2)
       abbrev
     rdoc (6.6.3.1)
       psych (>= 4.0.0)
-    reline (0.4.3)
+    reline (0.5.6)
       io-console (~> 0.5)
     securerandom (0.3.1)
     stackprof (0.2.26)

data/doc/narrowing.md

@@ -65,7 +65,7 @@ It immediately type checks the left hand side, but with *conditional mode*. Cond
 x && y
 ```
 
-Going down again, it gets a typing `x: String?` and `y: String?. It runs a type narrowing, to obtain a result both of `x` and `y` are `String` for truthy result, both of `x` and `y` are `String?` for falsy result. The two environments should be propagated to the upper node, because the parent node is also `&&` which is a subject of type narrowing. So, it returns an `ENV` type, `String?` for original type, `{ x: String, y: String }` for truthy result, and `{ x: String?, y: String? }` for falsy result.
+Going down again, it gets a typing `x: String?` and `y: String?`. It runs a type narrowing, to obtain a result both of `x` and `y` are `String` for truthy result, both of `x` and `y` are `String?` for falsy result. The two environments should be propagated to the upper node, because the parent node is also `&&` which is a subject of type narrowing. So, it returns an `ENV` type, `String?` for original type, `{ x: String, y: String }` for truthy result, and `{ x: String?, y: String? }` for falsy result.
 
 Going up to the outer `&&` expression. The left hand side has `ENV` type, and then the right hand side is type checked based on the truthy environment (because of the semantics of `&&` expression.) Both `x` and `y` are `String` and it type checks. The type of the whole expression union of `String` and the falsy part of the original type -- `nil`.
 ## Union type partition

data/doc/shape.md

@@ -0,0 +1,176 @@
+# Shapes
+
+A *shape* is a data structure, which contains the set of available methods and their types, which is associated with a type. Steep uses shapes to type check method calls -- it calculates the shape of the type of the receiver, checks if the called method is defined on the shape and the arguments are compatible with the method, and calculates the return type.
+
+Assume an interface `_Foo` is defined as follows:
+
+```rbs
+interface _Foo
+  def foo: () -> String
+
+  def bar: () -> self
+end
+```
+
+The shape of `_Foo` will be the following:
+
+```
+Shape (_Foo) {
+  foo: () -> String,
+  bar: () -> _Foo
+}
+```
+
+Note that the `self` type in the example is resolved to `_Foo` during shape calculation.
+
+The shape calculation of an object is straightforward. Calculate a `RBS::Definition` of a class singleton/instance, or an interface, and translate the data structure to a `Shape` object. But there are a few things to consider.
+## Tuple, record, and proc types
+The shape of tuple, record, or proc types are based on their base types -- Array, Hash, or Proc classes --, but with specialized method types.
+
+```
+Shape ([Integer, String]) {
+  []: (0) -> Integer
+    | (1) -> String
+    | (Integer) -> (Integer | String)
+  ...
+}
+```
+
+The specialization is implemented as a part of shape calculation.
+## Special methods
+Steep recognizes some special methods for type narrowing, including `#is_a?`, `#===`, `#nil?`, ... These methods are defined with normal RBS syntax, but the method types in shapes are transformed to types using logic types.
+
+The shape calculation inserts the specialized methods with these special methods.
+## `self` types
+There are two cases of `self` types to consider during shape calculation.
+
+1. `self` types included in the shape of a type
+2. `self` types included in given types
+### 1. `self` types included in the shape of a type
+`self` types may be included in a class or interface definition.
+
+```rbs
+interface _Foo
+  def itself: () -> self
+end
+```
+
+The `self` types included in the shape of `_Foo` type should be resolved to `_Foo` type.
+
+```
+Shape (_Foo) {
+  itself: () -> _Foo
+}
+```
+### 2. `self` types included in given types
+Unlike `self` types included in definitions, `self` types in given types should be preserved.
+
+```rbs
+interface _Foo[A]
+  def get: () -> A
+end
+```
+
+The shape of `_Foo[self]` has `self` type as its type argument, and we want the `self` type preserved after the shape calculation.
+
+```
+Shape (_Foo[self]) {
+  get: () -> self
+}
+```
+
+We often use `self` types as the return type of a method.
+
+```rbs
+class Foo
+  def foo: () -> self
+end
+```
+
+So, the implementation of `foo` might use `self` node to return `self` type.
+
+```rb
+class Foo
+  def foo
+    # @type var foo: _Foo[self]
+    foo = ...
+    foo.get
+  end
+end
+```
+
+We want the type of `foo.get` to be `self`, not `Foo`, to avoid a type error being detected.
+## Shape of `self` types
+We also want `self` type if `self` is the type of the shape.
+
+```rb
+class Foo
+  def foo
+    self.itself
+  end
+end
+```
+
+This is a straightforward case, because the type of `self` is `self` itself. Calculate the shape of it, but keep the `self` types in the shape.
+
+```
+Shape (self) {
+  itself: () -> self
+}
+```
+
+If `self` is a union type, or something built with a type constructor, the shape calculation gets complicated.
+
+```rbs
+class Foo
+  def foo: () -> Integer
+end
+
+class Bar
+  def foo: () -> self
+end
+```
+
+What is the expected shape of `self` where the type of `self` is `Foo | Bar`?
+
+The shape of a union type is straightforward. It calculates the shape of each type, and then it calculates a union of the shape.
+
+We do the same for the case with `self` types, but it results in slightly incorrect shapes.
+
+```
+Shape (Foo) {
+  foo: () -> Integer
+}
+
+Shape (Bar) {
+  foo: () -> self   # self is preserved, because the shape of `self` is being calculated
+}
+
+Shape (Foo | Bar) {
+  foo: () -> (Integer | self)
+}
+```
+
+So, the resulting type of `self.foo` where the type of `self` is `Foo | Bar`, would be `Integer | Foo | Bar`. But, actually, it won't be `Foo` because the `self` comes from `Bar`.
+
+This is an incorrect result, but Steep is doing this right now.
+## `class` and `instance` types
+The shape calculation provides limited support for `class` and `instance` types.
+
+1. `class`/`instance` types from the definition are resolved
+2. `class`/`instance` types in generics type arguments of interfaces/instances are preserved
+3. Shape of `class`/`instance` types are resolved to configuration's `class_type` and `instance_type`, and the translated types are used to calculate the shape
+
+It's different from `self` types except case #2. The relationship between `self`/`class`/`instance` is not trivial in Ruby. All of them might be resolved to any type, which means calculating one from another of them is simply impossible.
+## Public methods, private methods
+`Shape` objects have a flag of if the shape is for *public* method calls or *private* method calls. Private method call is a form of `foo()` or `self.foo()` -- when the receiver is omitted or `self`. Public method calls are anything else.
+
+The shape calculation starts with *private methods*, and the `Shape#public_shape` method returns another shape that only has *public* methods.
+
+> Note that the private shape calculation is required even on public method calls. This means a possible chance of future optimizations.
+## Lazy method type calculation
+We rarely need all of the methods available for an object. If we want to type check a method call, we only need the method type of that method. All other methods can be just ignored.
+
+*Lazy method type calculation* is introduced for that case. Instead of calculating the types of all of the methods, it registers a block that computes the method type.
+
+It is implemented in `Steep::Interface::Shape::Entry` and used to make the shape calculation of a union type faster.

data/gemfile_steep/Gemfile.lock

@@ -14,16 +14,16 @@ GEM
       tzinfo (~> 2.0)
     ast (2.4.2)
     base64 (0.2.0)
-    bigdecimal (3.1.7)
+    bigdecimal (3.1.8)
     concurrent-ruby (1.2.3)
     connection_pool (2.4.1)
     csv (3.3.0)
     drb (2.2.1)
     ffi (1.16.3)
     fileutils (1.7.2)
-    i18n (1.14.4)
+    i18n (1.14.5)
       concurrent-ruby (~> 1.0)
-    json (2.7.1)
+    json (2.7.2)
     language_server-protocol (3.17.0.3)
     listen (3.9.0)
       rb-fsevent (~> 0.10, >= 0.10.3)
@@ -31,7 +31,7 @@ GEM
     logger (1.6.0)
     minitest (5.22.3)
     mutex_m (0.2.0)
-    parser (3.3.0.5)
+    parser (3.3.1.0)
       ast (~> 2.4.1)
       racc
     racc (1.7.3)
@@ -42,7 +42,7 @@ GEM
     rbs (3.4.4)
       abbrev
     securerandom (0.3.1)
-    steep (1.7.0.dev.2)
+    steep (1.7.0.dev.3)
       activesupport (>= 5.1)
       concurrent-ruby (>= 1.1.10)
       csv (>= 3.0.9)

data/lib/steep/ast/types/factory.rb

@@ -212,27 +212,36 @@ module Steep
           params = func.params
           return_type = func.return_type
 
-          RBS::Types::Function.new(
-            required_positionals: params.required.map {|type| RBS::Types::Function::Param.new(name: nil, type: type_1(type)) },
-            optional_positionals: params.optional.map {|type| RBS::Types::Function::Param.new(name: nil, type: type_1(type)) },
-            rest_positionals: params.rest&.yield_self {|type| RBS::Types::Function::Param.new(name: nil, type: type_1(type)) },
-            trailing_positionals: [],
-            required_keywords: params.required_keywords.transform_values {|type| RBS::Types::Function::Param.new(name: nil, type: type_1(type)) },
-            optional_keywords: params.optional_keywords.transform_values {|type| RBS::Types::Function::Param.new(name: nil, type: type_1(type)) },
-            rest_keywords: params.rest_keywords&.yield_self {|type| RBS::Types::Function::Param.new(name: nil, type: type_1(type)) },
-            return_type: type_1(return_type)
-          )
+          if params
+            RBS::Types::Function.new(
+              required_positionals: params.required.map {|type| RBS::Types::Function::Param.new(name: nil, type: type_1(type)) },
+              optional_positionals: params.optional.map {|type| RBS::Types::Function::Param.new(name: nil, type: type_1(type)) },
+              rest_positionals: params.rest&.yield_self {|type| RBS::Types::Function::Param.new(name: nil, type: type_1(type)) },
+              trailing_positionals: [],
+              required_keywords: params.required_keywords.transform_values {|type| RBS::Types::Function::Param.new(name: nil, type: type_1(type)) },
+              optional_keywords: params.optional_keywords.transform_values {|type| RBS::Types::Function::Param.new(name: nil, type: type_1(type)) },
+              rest_keywords: params.rest_keywords&.yield_self {|type| RBS::Types::Function::Param.new(name: nil, type: type_1(type)) },
+              return_type: type_1(return_type)
+            )
+          else
+            RBS::Types::UntypedFunction.new(return_type: type_1(return_type))
+          end
         end
 
         def params(type)
-          Interface::Function::Params.build(
-            required: type.required_positionals.map {|param| type(param.type) },
-            optional: type.optional_positionals.map {|param| type(param.type) },
-            rest: type.rest_positionals&.yield_self {|param| type(param.type) },
-            required_keywords: type.required_keywords.transform_values {|param| type(param.type) },
-            optional_keywords: type.optional_keywords.transform_values {|param| type(param.type) },
-            rest_keywords: type.rest_keywords&.yield_self {|param| type(param.type) }
-          )
+          case type
+          when RBS::Types::Function
+            Interface::Function::Params.build(
+              required: type.required_positionals.map {|param| type(param.type) },
+              optional: type.optional_positionals.map {|param| type(param.type) },
+              rest: type.rest_positionals&.yield_self {|param| type(param.type) },
+              required_keywords: type.required_keywords.transform_values {|param| type(param.type) },
+              optional_keywords: type.optional_keywords.transform_values {|param| type(param.type) },
+              rest_keywords: type.rest_keywords&.yield_self {|param| type(param.type) }
+            )
+          when RBS::Types::UntypedFunction
+            nil
+          end
         end
 
         def type_param(type_param)

data/lib/steep/ast/types/proc.rb

@@ -57,9 +57,11 @@ module Steep
         include Helper::ChildrenLevel
 
         def level
-          children = type.params.each_type.to_a + [type.return_type]
+          children = type.params&.each_type.to_a + [type.return_type]
           if block
-            children.push(*block.type.params.each_type.to_a)
+            if block.type.params
+              children.push(*block.type.params.each_type.to_a)
+            end
             children.push(block.type.return_type)
           end
           if self_type
@@ -83,13 +85,16 @@ module Steep
 
         def one_arg?
           params = type.params
-
-          params.required.size == 1 &&
-            params.optional.empty? &&
-            !params.rest &&
-            params.required_keywords.empty? &&
-            params.optional_keywords.empty? &&
-            !params.rest_keywords
+          if params
+            params.required.size == 1 &&
+              params.optional.empty? &&
+              !params.rest &&
+              params.required_keywords.empty? &&
+              params.optional_keywords.empty? &&
+              !params.rest_keywords
+          else
+            true
+          end
         end
 
         def back_type

data/lib/steep/interface/block.rb

@@ -82,7 +82,7 @@ module Steep
       def +(other)
         optional = self.optional? || other.optional?
         type = Function.new(
-          params: self.type.params + other.type.params,
+          params: self.type.params && other.type.params ? self.type.params + other.type.params : nil,
           return_type: AST::Types::Union.build(types: [self.type.return_type, other.type.return_type]),
           location: nil
         )

data/lib/steep/interface/builder.rb

@@ -62,6 +62,7 @@ module Steep
       def shape(type, config)
         Steep.logger.tagged "shape(#{type})" do
           if shape = raw_shape(type, config)
+            # Optimization that skips unnecesary substittuion
             if type.free_variables.include?(AST::Types::Self.instance)
               shape
             else

data/lib/steep/interface/function.rb

@@ -1008,7 +1008,7 @@ module Steep
       def free_variables
         @fvs ||= Set[].tap do |fvs|
           # @type var fvs: Set[AST::Types::variable]
-          fvs.merge(params.free_variables)
+          fvs.merge(params.free_variables) if params
           fvs.merge(return_type.free_variables)
         end
       end
@@ -1016,7 +1016,7 @@ module Steep
       def subst(s)
         return self if s.empty?
 
-        ps = params.subst(s)
+        ps = params.subst(s) if params
         ret = return_type.subst(s)
 
         if ps == params && ret == return_type
@@ -1032,7 +1032,7 @@ module Steep
 
       def each_type(&block)
         if block
-          params.each_type(&block)
+          params&.each_type(&block)
           yield return_type
         else
           enum_for :each_type
@@ -1043,7 +1043,7 @@ module Steep
 
       def map_type(&block)
         Function.new(
-          params: params.map_type(&block),
+          params: params&.map_type(&block),
           return_type: yield(return_type),
           location: location
         )
@@ -1058,11 +1058,19 @@ module Steep
       end
 
       def to_s
-        "#{params} -> #{return_type}"
+        if params
+          "#{params} -> #{return_type}"
+        else
+          "(?) -> #{return_type}"
+        end
       end
 
       def closed?
-        params.closed? && return_type.free_variables.empty?
+        if params
+          params.closed? && return_type.free_variables.empty?
+        else
+          return_type.free_variables.empty?
+        end
       end
     end
   end

data/lib/steep/interface/method_type.rb

@@ -61,7 +61,7 @@ module Steep
           type.each_type(&block)
           if block()
             yield(block().self_type) if block().self_type
-            block().type.params.each_type(&block)
+            block().type.params&.each_type(&block)
             yield(block().type.return_type)
           end
         else
@@ -119,7 +119,7 @@ module Steep
         self.class.new(
           type_params: type_params,
           type: Function.new(
-            params: type.params.subst(s1) + other.type.params.subst(s2),
+            params: type.params && other.type.params ? type.params.subst(s1) + other.type.params.subst(s2) : nil,
             return_type: AST::Types::Union.build(
               types: [type.return_type.subst(s1), other.type.return_type.subst(s2)]
             ),
@@ -250,10 +250,13 @@ module Steep
                 nil
               end
 
-            # Return when the two block parameters are imcompatible.
-            return unless b.type.params & ob.type.params
-
-            block_params = b.type.params | ob.type.params or return
+            if b.type.params && ob.type.params
+              # Return when the two block parameters are imcompatible.
+              return unless b.type.params & ob.type.params
+              block_params = b.type.params | ob.type.params or return
+            else
+              block_params = b.type.params || ob.type.params
+            end
 
             block_return_type = AST::Types::Intersection.build(types: [b.type.return_type, ob.type.return_type])
             block_type = Function.new(params: block_params, return_type: block_return_type, location: nil)
@@ -285,7 +288,12 @@ module Steep
       def &(other)
         return self if self == other
 
-        params = self.type.params | other.type.params or return
+        if self.type.params && other.type.params
+          params = self.type.params | other.type.params or return
+        else
+          params = self.type.params || other.type.params
+        end
+        
         block =
           case
           when (b = self.block) && (ob = other.block)

data/lib/steep/project/pattern.rb

@@ -46,10 +46,9 @@ module Steep
 
       def test_string(path, patterns, prefixes)
         string = path.to_s
-        extension = path.extname
 
         patterns.any? {|pat| File.fnmatch(pat, string, File::FNM_PATHNAME) } ||
-          prefixes.any? {|prefix| string.start_with?(prefix) && extension == ext }
+          prefixes.any? {|prefix| File.fnmatch("#{prefix}**/*#{ext}", string, File::FNM_PATHNAME) }
       end
     end
   end

data/lib/steep/server/interaction_worker.rb

@@ -90,6 +90,12 @@ module Steep
           collect_changes(request)
           queue_job ApplyChangeJob.new
 
+        when "$/file/reset"
+          uri = request[:params][:uri]
+          text = request[:params][:content]
+          reset_change(uri: uri, text: text)
+          queue_job ApplyChangeJob.new
+
         when "textDocument/hover"
           id = request[:id]
 

data/lib/steep/server/lsp_formatter.rb

@@ -263,6 +263,8 @@ module Steep
           <<~MD
             **Keyword argument**: `#{item.identifier}`
           MD
+        else
+          raise
         end
       end
 

data/lib/steep/services/completion_provider.rb

@@ -740,7 +740,7 @@ module Steep
             if method = shape.methods[call.method_name]
               method.method_types.each.with_index do |method_type, i|
                 defn = method_type.method_decls.to_a[0]&.method_def
-                if defn
+                if defn && defn.type.type
                   range = range_for(position, prefix: prefix)
                   kwargs = argument_nodes.find { |arg| arg.type == :kwargs }&.children || []
                   used_kwargs = kwargs.filter_map { |arg| arg.type == :pair && arg.children.first.children.first }

data/lib/steep/services/file_loader.rb

@@ -12,30 +12,25 @@ module Steep
           pats = commandline_patterns.empty? ? pattern.patterns : commandline_patterns
 
           pats.each do |path|
-            absolute_path = base_dir + path
-
-            if absolute_path.file?
-              relative_path = absolute_path.relative_path_from(base_dir)
-              if pattern =~ relative_path
-                yield relative_path
-              end
-            else
-              files = if absolute_path.directory?
-                        Pathname.glob("#{absolute_path}/**/*#{pattern.ext}")
-                      else
-                        Pathname.glob(absolute_path.to_s)
-                      end
-
-              files.sort.each do |source_path|
-                if source_path.file?
-                  relative_path = source_path.relative_path_from(base_dir)
-                  unless pattern.ignore?(relative_path)
-                    yield relative_path
+            Pathname.glob((base_dir + path).to_s).each do |absolute_path|
+              if absolute_path.file?
+                relative_path = absolute_path.relative_path_from(base_dir)
+                if pattern =~ relative_path
+                  yield relative_path
+                end
+              else
+                files = Pathname.glob("#{absolute_path}/**/*#{pattern.ext}")
+
+                files.sort.each do |source_path|
+                  if source_path.file?
+                    relative_path = source_path.relative_path_from(base_dir)
+                    unless pattern.ignore?(relative_path)
+                      yield relative_path
+                    end
                   end
                 end
               end
             end
-
           end
         else
           enum_for :each_path_in_patterns, pattern, commandline_patterns

data/lib/steep/services/signature_help_provider.rb

@@ -7,15 +7,17 @@ module Steep
         # @implements Item
 
         def parameters
-          arguments = [] #: Array[String]
-          arguments.push(*method_type.type.required_positionals.map(&:to_s))
-          arguments.push(*method_type.type.optional_positionals.map {|p| "?#{p}"})
-          arguments.push("*#{self.method_type.type.rest_positionals}") if method_type.type.rest_positionals
-          arguments.push(*method_type.type.trailing_positionals.map(&:to_s))
-          arguments.push(*method_type.type.required_keywords.map {|name, param| "#{name}: #{param}" })
-          arguments.push(*method_type.type.optional_keywords.map {|name, param| "?#{name}: #{param}" })
-          arguments.push("**#{method_type.type.rest_keywords}") if method_type.type.rest_keywords
-          arguments
+          if method_type.type.is_a?(RBS::Types::Function)
+            arguments = [] #: Array[String]
+            arguments.push(*method_type.type.required_positionals.map(&:to_s))
+            arguments.push(*method_type.type.optional_positionals.map {|p| "?#{p}"})
+            arguments.push("*#{self.method_type.type.rest_positionals}") if method_type.type.rest_positionals
+            arguments.push(*method_type.type.trailing_positionals.map(&:to_s))
+            arguments.push(*method_type.type.required_keywords.map {|name, param| "#{name}: #{param}" })
+            arguments.push(*method_type.type.optional_keywords.map {|name, param| "?#{name}: #{param}" })
+            arguments.push("**#{method_type.type.rest_keywords}") if method_type.type.rest_keywords
+            arguments
+          end
         end
       end
 

data/lib/steep/signature/validator.rb

@@ -134,7 +134,7 @@ module Steep
       end
 
       def validate_type(type)
-        Steep.logger.debug "#{Location.to_string type.location}: Validating #{type}..."
+        Steep.logger.debug { "#{Location.to_string type.location}: Validating #{type}..." }
 
         validator.validate_type(type, context: nil)
         validate_type_application(type)