steep 0.39.0 → 0.40.0

data/smoke/method/b.rb

@@ -1,7 +1,6 @@
 class A
   # @implements X
 
-  # !expects MethodBodyTypeMismatch: method=foo, expected=(::Integer | ::String), actual=::Symbol
   def foo(x)
     :foobar
   end

data/smoke/method/test.yaml

@@ -0,0 +1,71 @@
+---
+test:
+  a.rb:
+    diagnostics:
+    - |
+      a.rb:6:2: [error] Cannot assign a value of type `::Integer` to a variable of type `::String`
+      │   ::Integer <: ::String
+      │     ::Numeric <: ::String
+      │       ::Object <: ::String
+      │         ::BasicObject <: ::String
+      │
+      │ Diagnostic ID: Ruby::IncompatibleAssignment
+      │
+      └   z = x
+          ~~~~~
+    - |
+      a.rb:8:2: [error] Cannot assign a value of type `::Integer` to a variable of type `::String`
+      │   ::Integer <: ::String
+      │     ::Numeric <: ::String
+      │       ::Object <: ::String
+      │         ::BasicObject <: ::String
+      │
+      │ Diagnostic ID: Ruby::IncompatibleAssignment
+      │
+      └   z = y
+          ~~~~~
+    - |
+      a.rb:3:0: [error] Cannot allow method body have type `::Integer` because declared as type `::String`
+      │   ::Integer <: ::String
+      │     ::Numeric <: ::String
+      │       ::Object <: ::String
+      │         ::BasicObject <: ::String
+      │
+      │ Diagnostic ID: Ruby::MethodBodyTypeMismatch
+      │
+      └ def foo(x, y:)
+        ~~~~~~~~~~~~~~
+    - |
+      a.rb:15:7: [error] Method parameters are incompatible with declaration `(::Integer) -> ::String`
+      │ Diagnostic ID: Ruby::MethodArityMismatch
+      │
+      └ def bar(x, y)
+               ~~~~~~
+    - |
+      a.rb:18:2: [error] Cannot assign a value of type `::Integer` to a variable of type `::String`
+      │   ::Integer <: ::String
+      │     ::Numeric <: ::String
+      │       ::Object <: ::String
+      │         ::BasicObject <: ::String
+      │
+      │ Diagnostic ID: Ruby::IncompatibleAssignment
+      │
+      └   z = x
+          ~~~~~
+  b.rb:
+    diagnostics:
+    - |
+      b.rb:4:2: [error] Cannot allow method body have type `::Symbol` because declared as type `(::Integer | ::String)`
+      │   ::Symbol <: (::Integer | ::String)
+      │     ::Symbol <: ::Integer
+      │       ::Object <: ::Integer
+      │         ::BasicObject <: ::Integer
+      │
+      │ Diagnostic ID: Ruby::MethodBodyTypeMismatch
+      │
+      └   def foo(x)
+          ~~~~~~~~~~
+  c.rb:
+    diagnostics: []
+  d.rb:
+    diagnostics: []

data/smoke/module/a.rb

@@ -10,10 +10,8 @@ module A
     end
 
     # @type var s: String
-    # !expects IncompatibleAssignment: lhs_type=::String, rhs_type=::Integer
     s = n
 
-    # !expects NoMethodError: type=(::Object & ::_Each2[::Integer, ::A] & ::A), method=foo
     foo()
 
     n

data/smoke/module/b.rb

@@ -1,5 +1,3 @@
-# ALLOW FAILURE
-
 # @type var klass: Class
 # @type var mod: Module
 

data/smoke/module/c.rb

@@ -18,6 +18,5 @@ module A
   # ok
   block_given?
 
-  # !expects NoMethodError: type=singleton(::A), method=no_such_method_in_module
   no_such_method_in_module
 end

data/smoke/module/d.rb

@@ -1,5 +1,4 @@
 # If there is a same name module definition, it automatically implements.
 
-# !expects MethodDefinitionMissing: module=::X, method=foo
 module X
 end

data/smoke/module/f.rb

@@ -1,5 +1,3 @@
-# !expects@+2 MethodDefinitionMissing: module=::Palette, method=self.nestopia_palette
-# !expects@+1 UnexpectedDynamicMethod: module=::Palette, method=nestopia_palette
 module Palette
   module_function
 

data/smoke/module/test.yaml

@@ -0,0 +1,51 @@
+---
+test:
+  a.rb:
+    diagnostics:
+    - |
+      a.rb:13:4: [error] Cannot assign a value of type `::Integer` to a variable of type `::String`
+      │   ::Integer <: ::String
+      │     ::Numeric <: ::String
+      │       ::Object <: ::String
+      │         ::BasicObject <: ::String
+      │
+      │ Diagnostic ID: Ruby::IncompatibleAssignment
+      │
+      └     s = n
+            ~~~~~
+    - |
+      a.rb:15:4: [error] Type `(::Object & ::_Each2[::Integer, ::A] & ::A)` does not have method `foo`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └     foo()
+            ~~~
+  c.rb:
+    diagnostics:
+    - |
+      c.rb:21:2: [error] Type `singleton(::A)` does not have method `no_such_method_in_module`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └   no_such_method_in_module
+          ~~~~~~~~~~~~~~~~~~~~~~~~
+  d.rb:
+    diagnostics:
+    - |
+      d.rb:3:7: [error] Cannot find implementation of method `::X#foo`
+      │ Diagnostic ID: Ruby::MethodDefinitionMissing
+      │
+      └ module X
+               ~
+  f.rb:
+    diagnostics:
+    - |
+      f.rb:1:7: [error] Cannot find implementation of method `::Palette.nestopia_palette`
+      │ Diagnostic ID: Ruby::MethodDefinitionMissing
+      │
+      └ module Palette
+               ~~~~~~~
+    - |
+      f.rb:1:7: [error] @dynamic annotation contains unknown method name `nestopia_palette`
+      │ Diagnostic ID: Ruby::UnexpectedDynamicMethod
+      │
+      └ module Palette
+               ~~~~~~~

data/smoke/regexp/a.rb

@@ -1,147 +1,109 @@
-# ALLOW FAILURE
-
 new_1 = Regexp.new("a")
-# !expects NoMethodError: type=::Regexp, method=foo
 new_1.foo
 
 new_2 = Regexp.new("a", true)
-# !expects NoMethodError: type=::Regexp, method=foo
 new_2.foo
 
 new_3 = Regexp.new("a", Regexp::EXTENDED | Regexp::IGNORECASE)
-# !expects NoMethodError: type=::Regexp, method=foo
 new_3.foo
 
 new_4 = Regexp.new(/a/)
-# !expects NoMethodError: type=::Regexp, method=foo
 new_4.foo
 
 compile_1 = Regexp.compile("a")
-# !expects NoMethodError: type=::Regexp, method=foo
 compile_1.foo
 
 compile_2 = Regexp.compile("a", true)
-# !expects NoMethodError: type=::Regexp, method=foo
 compile_2.foo
 
 compile_3 = Regexp.compile("a", Regexp::EXTENDED | Regexp::IGNORECASE)
-# !expects NoMethodError: type=::Regexp, method=foo
 compile_3.foo
 
 compile_4 = Regexp.compile(/a/)
-# !expects NoMethodError: type=::Regexp, method=foo
 compile_4.foo
 
 escape_1 = Regexp.escape("a")
-# !expects NoMethodError: type=::String, method=foo
 escape_1.foo
 
 last_match_1 = Regexp.last_match
-# !expects NoMethodError: type=(::MatchData | nil), method=foo
 last_match_1.foo
 
 last_match_2 = Regexp.last_match(1)
-# !expects NoMethodError: type=(::String | nil), method=foo
 last_match_2.foo
 
 quote_1 = Regexp.quote("a")
-# !expects NoMethodError: type=::String, method=foo
 quote_1.foo
 
 try_convert_1 = Regexp.try_convert(Object.new)
-# !expects NoMethodError: type=(::Regexp | nil), method=foo
 try_convert_1.foo
 
 union_1 = Regexp.union
-# !expects NoMethodError: type=::Regexp, method=foo
 union_1.foo
 
 union_2 = Regexp.union("a")
-# !expects NoMethodError: type=::Regexp, method=foo
 union_2.foo
 
 union_3 = Regexp.union("a", "b")
-# !expects NoMethodError: type=::Regexp, method=foo
 union_3.foo
 
 union_4 = Regexp.union(["a", "b"])
-# !expects NoMethodError: type=::Regexp, method=foo
 union_4.foo
 
 union_5 = Regexp.union(/a/)
-# !expects NoMethodError: type=::Regexp, method=foo
 union_5.foo
 
 union_6 = Regexp.union(/a/, /b/)
-# !expects NoMethodError: type=::Regexp, method=foo
 union_6.foo
 
 union_7 = Regexp.union([/a/, /b/])
-# !expects NoMethodError: type=::Regexp, method=foo
 union_7.foo
 
 op_eqeqeq_1 = /a/ === "a"
-# !expects NoMethodError: type=bool, method=foo
 op_eqeqeq_1.foo
 
 op_match_1 = /a/ =~ "a"
-# !expects NoMethodError: type=::Integer, method=foo
 op_match_1.foo
 
 casefold_1 = /a/.casefold?
-# !expects NoMethodError: type=bool, method=foo
 casefold_1.foo
 
 encoding_1 = /a/.encoding
-# !expects NoMethodError: type=::Encoding, method=foo
 encoding_1.foo
 
 fixed_encoding_1 = /a/.fixed_encoding?
-# !expects NoMethodError: type=bool, method=foo
 fixed_encoding_1.foo
 
 match_1 = /a/.match("a")
-# !expects NoMethodError: type=(::MatchData | nil), method=foo
 match_1.foo
 
 match_2 = /a/.match("a", 0)
-# !expects NoMethodError: type=(::MatchData | nil), method=foo
 match_2.foo
 
 /a/.match("a") do |m|
-  # !expects NoMethodError: type=::MatchData, method=foo
   m.foo
 end
 
 /a/.match("a", 0) do |m|
-  # !expects NoMethodError: type=::MatchData, method=foo
   m.foo
 end
 
 match_q_1 = /a/.match?("a")
-# !expects NoMethodError: type=bool, method=foo
 match_q_1.foo
 
 match_q_2 = /a/.match?("a", 0)
-# !expects NoMethodError: type=bool, method=foo
 match_q_2.foo
 
 named_captures_1 = /(?<foo>.)/.named_captures
-# !expects NoMethodError: type=::Hash[::String, ::Array[::Integer]], method=foo
 named_captures_1.foo
 
 names_1 = /(?<foo>.)/.names
-# !expects NoMethodError: type=::Array[::String], method=foo
 names_1.foo
 
 options_1 = /a/ix.options
-# !expects NoMethodError: type=::Integer, method=foo
 options_1.foo
 
 source_1 = /a/ix.source
-# !expects NoMethodError: type=::String, method=foo
 source_1.foo
 
 op_unary_match_1 = ~ /a/
-# !expects NoMethodError: type=(::Integer | nil), method=foo
 op_unary_match_1.foo

data/smoke/regexp/b.rb

@@ -1,105 +1,79 @@
 /(?<foo>a)/.match("a") do |match|
   match_ref_1 = match[0]
-  # !expects NoMethodError: type=(::String | nil), method=foo
   match_ref_1.foo
 
   match_ref_2 = match["foo"]
-  # !expects NoMethodError: type=(::String | nil), method=foo
   match_ref_2.foo
 
   match_ref_3 = match[:foo]
-  # !expects NoMethodError: type=(::String | nil), method=foo
   match_ref_3.foo
 
   match_ref_4 = match[0, 1]
-  # !expects NoMethodError: type=::Array[(::String | nil)], method=foo
   match_ref_4.foo
 
   match_ref_5 = match[0..1]
-  # !expects NoMethodError: type=::Array[(::String | nil)], method=foo
   match_ref_5.foo
 
   begin_1 = match.begin(0)
-  # !expects NoMethodError: type=(::Integer | nil), method=foo
   begin_1.foo
 
   begin_2 = match.begin("foo")
-  # !expects NoMethodError: type=(::Integer | nil), method=foo
   begin_2.foo
 
   begin_3 = match.begin(:foo)
-  # !expects NoMethodError: type=(::Integer | nil), method=foo
   begin_3.foo
 
   captures_1 = match.captures
-  # !expects NoMethodError: type=::Array[(::String | nil)], method=foo
   captures_1.foo
 
   end_1 = match.end(0)
-  # !expects NoMethodError: type=(::Integer | nil), method=foo
   end_1.foo
 
   end_2 = match.end("foo")
-  # !expects NoMethodError: type=(::Integer | nil), method=foo
   end_2.foo
 
   end_3 = match.end(:foo)
-  # !expects NoMethodError: type=(::Integer | nil), method=foo
   end_3.foo
 
   length_1 = match.length
-  # !expects NoMethodError: type=::Integer, method=foo
   length_1.foo
 
   named_captures_1 = match.named_captures
-  # !expects NoMethodError: type=::Hash[::String, (::String | nil)], method=foo
   named_captures_1.foo
 
   names_1 = match.names
-  # !expects NoMethodError: type=::Array[::String], method=foo
   names_1.foo
 
   offset_1 = match.offset(0)
-  # !expects NoMethodError: type=([::Integer, ::Integer] | [nil, nil]), method=foo
   offset_1.foo
 
   offset_2 = match.offset("foo")
-  # !expects NoMethodError: type=([::Integer, ::Integer] | [nil, nil]), method=foo
   offset_2.foo
 
   offset_3 = match.offset(:foo)
-  # !expects NoMethodError: type=([::Integer, ::Integer] | [nil, nil]), method=foo
   offset_3.foo
 
   post_match_1 = match.post_match
-  # !expects NoMethodError: type=::String, method=foo
   post_match_1.foo
 
   pre_match_1 = match.pre_match
-  # !expects NoMethodError: type=::String, method=foo
   pre_match_1.foo
 
   regexp_1 = match.regexp
-  # !expects NoMethodError: type=::Regexp, method=foo
   regexp_1.foo
 
   size_1 = match.size
-  # !expects NoMethodError: type=::Integer, method=foo
   size_1.foo
 
   string_1 = match.string
-  # !expects NoMethodError: type=::String, method=foo
   string_1.foo
 
   to_a_1 = match.to_a
-  # !expects NoMethodError: type=::Array[(::String | nil)], method=foo
   to_a_1.foo
 
   values_at_1 = match.values_at
-  # !expects NoMethodError: type=::Array[(::String | nil)], method=foo
   values_at_1.foo
 
   values_at_2 = match.values_at(0, "foo", :foo)
-  # !expects NoMethodError: type=::Array[(::String | nil)], method=foo
   values_at_2.foo
 end

data/smoke/regexp/test.yaml

@@ -0,0 +1,372 @@
+---
+test:
+  a.rb:
+    diagnostics:
+    - |
+      a.rb:2:6: [error] Type `::Regexp` does not have method `foo`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └ new_1.foo
+              ~~~
+    - |
+      a.rb:5:6: [error] Type `::Regexp` does not have method `foo`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └ new_2.foo
+              ~~~
+    - |
+      a.rb:8:6: [error] Type `::Regexp` does not have method `foo`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └ new_3.foo
+              ~~~
+    - |
+      a.rb:11:6: [error] Type `::Regexp` does not have method `foo`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └ new_4.foo
+              ~~~
+    - |
+      a.rb:14:10: [error] Type `::Regexp` does not have method `foo`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └ compile_1.foo
+                  ~~~
+    - |
+      a.rb:17:10: [error] Type `::Regexp` does not have method `foo`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └ compile_2.foo
+                  ~~~
+    - |
+      a.rb:20:10: [error] Type `::Regexp` does not have method `foo`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └ compile_3.foo
+                  ~~~
+    - |
+      a.rb:23:10: [error] Type `::Regexp` does not have method `foo`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └ compile_4.foo
+                  ~~~
+    - |
+      a.rb:26:9: [error] Type `::String` does not have method `foo`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └ escape_1.foo
+                 ~~~
+    - |
+      a.rb:29:13: [error] Type `(::MatchData | nil)` does not have method `foo`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └ last_match_1.foo
+                     ~~~
+    - |
+      a.rb:32:13: [error] Type `(::String | nil)` does not have method `foo`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └ last_match_2.foo
+                     ~~~
+    - |
+      a.rb:35:8: [error] Type `::String` does not have method `foo`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └ quote_1.foo
+                ~~~
+    - |
+      a.rb:38:14: [error] Type `(::Regexp | nil)` does not have method `foo`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └ try_convert_1.foo
+                      ~~~
+    - |
+      a.rb:41:8: [error] Type `::Regexp` does not have method `foo`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └ union_1.foo
+                ~~~
+    - |
+      a.rb:44:8: [error] Type `::Regexp` does not have method `foo`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └ union_2.foo
+                ~~~
+    - |
+      a.rb:47:8: [error] Type `::Regexp` does not have method `foo`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └ union_3.foo
+                ~~~
+    - |
+      a.rb:50:8: [error] Type `::Regexp` does not have method `foo`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └ union_4.foo
+                ~~~
+    - |
+      a.rb:53:8: [error] Type `::Regexp` does not have method `foo`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └ union_5.foo
+                ~~~
+    - |
+      a.rb:56:8: [error] Type `::Regexp` does not have method `foo`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └ union_6.foo
+                ~~~
+    - |
+      a.rb:59:8: [error] Type `::Regexp` does not have method `foo`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └ union_7.foo
+                ~~~
+    - |
+      a.rb:62:12: [error] Type `bool` does not have method `foo`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └ op_eqeqeq_1.foo
+                    ~~~
+    - |
+      a.rb:68:11: [error] Type `bool` does not have method `foo`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └ casefold_1.foo
+                   ~~~
+    - |
+      a.rb:71:11: [error] Type `::Encoding` does not have method `foo`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └ encoding_1.foo
+                   ~~~
+    - |
+      a.rb:74:17: [error] Type `bool` does not have method `foo`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └ fixed_encoding_1.foo
+                         ~~~
+    - |
+      a.rb:77:8: [error] Type `(::MatchData | nil)` does not have method `foo`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └ match_1.foo
+                ~~~
+    - |
+      a.rb:80:8: [error] Type `(::MatchData | nil)` does not have method `foo`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └ match_2.foo
+                ~~~
+    - |
+      a.rb:83:4: [error] Type `::MatchData` does not have method `foo`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └   m.foo
+            ~~~
+    - |
+      a.rb:87:4: [error] Type `::MatchData` does not have method `foo`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └   m.foo
+            ~~~
+    - |
+      a.rb:91:10: [error] Type `bool` does not have method `foo`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └ match_q_1.foo
+                  ~~~
+    - |
+      a.rb:94:10: [error] Type `bool` does not have method `foo`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └ match_q_2.foo
+                  ~~~
+    - |
+      a.rb:97:17: [error] Type `::Hash[::String, ::Array[::Integer]]` does not have method `foo`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └ named_captures_1.foo
+                         ~~~
+    - |
+      a.rb:100:8: [error] Type `::Array[::String]` does not have method `foo`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └ names_1.foo
+                ~~~
+    - |
+      a.rb:103:10: [error] Type `::Integer` does not have method `foo`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └ options_1.foo
+                  ~~~
+    - |
+      a.rb:106:9: [error] Type `::String` does not have method `foo`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └ source_1.foo
+                 ~~~
+    - |
+      a.rb:109:17: [error] Type `(::Integer | nil)` does not have method `foo`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └ op_unary_match_1.foo
+                         ~~~
+  b.rb:
+    diagnostics:
+    - |
+      b.rb:3:14: [error] Type `(::String | nil)` does not have method `foo`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └   match_ref_1.foo
+                      ~~~
+    - |
+      b.rb:6:14: [error] Type `(::String | nil)` does not have method `foo`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └   match_ref_2.foo
+                      ~~~
+    - |
+      b.rb:9:14: [error] Type `(::String | nil)` does not have method `foo`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └   match_ref_3.foo
+                      ~~~
+    - |
+      b.rb:12:14: [error] Type `::Array[(::String | nil)]` does not have method `foo`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └   match_ref_4.foo
+                      ~~~
+    - |
+      b.rb:15:14: [error] Type `::Array[(::String | nil)]` does not have method `foo`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └   match_ref_5.foo
+                      ~~~
+    - |
+      b.rb:18:10: [error] Type `(::Integer | nil)` does not have method `foo`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └   begin_1.foo
+                  ~~~
+    - |
+      b.rb:21:10: [error] Type `(::Integer | nil)` does not have method `foo`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └   begin_2.foo
+                  ~~~
+    - |
+      b.rb:24:10: [error] Type `(::Integer | nil)` does not have method `foo`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └   begin_3.foo
+                  ~~~
+    - |
+      b.rb:27:13: [error] Type `::Array[(::String | nil)]` does not have method `foo`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └   captures_1.foo
+                     ~~~
+    - |
+      b.rb:30:8: [error] Type `(::Integer | nil)` does not have method `foo`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └   end_1.foo
+                ~~~
+    - |
+      b.rb:33:8: [error] Type `(::Integer | nil)` does not have method `foo`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └   end_2.foo
+                ~~~
+    - |
+      b.rb:36:8: [error] Type `(::Integer | nil)` does not have method `foo`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └   end_3.foo
+                ~~~
+    - |
+      b.rb:39:11: [error] Type `::Integer` does not have method `foo`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └   length_1.foo
+                   ~~~
+    - |
+      b.rb:42:19: [error] Type `::Hash[::String, (::String | nil)]` does not have method `foo`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └   named_captures_1.foo
+                           ~~~
+    - |
+      b.rb:45:10: [error] Type `::Array[::String]` does not have method `foo`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └   names_1.foo
+                  ~~~
+    - |
+      b.rb:48:11: [error] Type `([::Integer, ::Integer] | [nil, nil])` does not have method `foo`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └   offset_1.foo
+                   ~~~
+    - |
+      b.rb:51:11: [error] Type `([::Integer, ::Integer] | [nil, nil])` does not have method `foo`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └   offset_2.foo
+                   ~~~
+    - |
+      b.rb:54:11: [error] Type `([::Integer, ::Integer] | [nil, nil])` does not have method `foo`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └   offset_3.foo
+                   ~~~
+    - |
+      b.rb:57:15: [error] Type `::String` does not have method `foo`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └   post_match_1.foo
+                       ~~~
+    - |
+      b.rb:60:14: [error] Type `::String` does not have method `foo`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └   pre_match_1.foo
+                      ~~~
+    - |
+      b.rb:63:11: [error] Type `::Regexp` does not have method `foo`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └   regexp_1.foo
+                   ~~~
+    - |
+      b.rb:66:9: [error] Type `::Integer` does not have method `foo`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └   size_1.foo
+                 ~~~
+    - |
+      b.rb:69:11: [error] Type `::String` does not have method `foo`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └   string_1.foo
+                   ~~~
+    - |
+      b.rb:72:9: [error] Type `::Array[(::String | nil)]` does not have method `foo`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └   to_a_1.foo
+                 ~~~
+    - |
+      b.rb:75:14: [error] Type `::Array[(::String | nil)]` does not have method `foo`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └   values_at_1.foo
+                      ~~~
+    - |
+      b.rb:78:14: [error] Type `::Array[(::String | nil)]` does not have method `foo`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └   values_at_2.foo
+                      ~~~