Type failure against an intersection type on **kwargs

[lloeki]

Reproduction:

# Steepfile
target :lib do
  check '.'
  signature '.'
end

# kwargs.rbs
class C
  def foo: (a: ::String, ?b: ::String?, **::Hash[::Symbol, ::String] others) -> void
  def bar: (kwargs: ::Hash[::Symbol, ::String]) -> void
end

# kwargs.rb
class C
  def foo(a:, b: nil, **others)
    p a
    p b
    p others
  end

  def bar(kwargs:)
    a = kwargs.delete(:a)

    raise ArgumentError, ':a cannot be nil' if a.nil?

    foo(a: a, **kwargs)
  end
end

C.new.bar(kwargs: { a: '1', b: '2', c: '3' })

kwargs.rb:13:16: [error] Cannot pass a value of type `::Hash[::Symbol, ::String]` as an argument of type `::Hash[::Symbol, ((::String | nil) & ::String & ::Hash[::Symbol, ::String])]`
│   ::Hash[::Symbol, ::String] <: ::Hash[::Symbol, ((::String | nil) & ::String & ::Hash[::Symbol, ::String])]
│     ::String <: ((::String | nil) & ::String & ::Hash[::Symbol, ::String])
│       ::String <: ::Hash[::Symbol, ::String]
│         ::Object <: ::Hash[::Symbol, ::String]
│           ::BasicObject <: ::Hash[::Symbol, ::String]
│
│ Diagnostic ID: Ruby::ArgumentTypeMismatch
│
└     foo(a: a, **kwargs)
                  ~~~~~~

I can't quite wrap my head around (::String | nil) & ::String & ::Hash[::Symbol, ::String] which seems to come from steep and seems to mean that it should be all of these types at once, but it can't be a String and a Hash at the same time, ever?

[lloeki]

The way I understand this (which may be completely incorrect), steep synthesises the following kwargs type:

::Hash[::Symbol, ((::String | nil) & ::String & ::Hash[::Symbol, ::String])]

where:

• ::Hash[::Symbol, ...] comes from it being keyword arguments
• (::String | nil) comes from ?b: ::String?
• ::String comes from a: ::String
• ::Hash[::Symbol, ::String] comes from **::Hash[::Symbol, ::String] others

But presumably since **others is a ** kwarg catch all, it should not sit at the same level as :a and :b, and instead should be union'd with the parent ::Hash[::Symbol, ...]:

::Hash[::Symbol, ((::String | nil) & ::String)] | ::Hash[::Symbol, ::String]

Also, unless I'm mistaken about the meaning of &, (::String | nil) & ::String should be (::String | nil) | ::String since a given kwargs value could be any of these, not all at the same time.

So it would become:

::Hash[::Symbol, ((::String | nil) | ::String) | ::Hash[::Symbol, ::String])]

Which can be reduced into:

::Hash[::Symbol, ::String | nil)]

Which should ultimately accept the ::Hash[::Symbol, ::String] value.

[lloeki]

Oh, wait, foo signature is wrong, it should be:

  def foo: (a: ::String, ?b: ::String?, **::String others) -> void

I seem to have missed that **::String others meaning that others will be a ::Hash[::Symbol, ::String]. I was mistakenly expecting syntax to be as exposed in this proposal.

And with that change steep check passes. Sorry for the noise!