steep 0.39.0 → 0.40.0

data/smoke/diagnostics/unexpected_block_given.rb

@@ -0,0 +1 @@
+[1].at(1) { 123 }

data/smoke/diagnostics/unexpected_dynamic_method.rb

@@ -0,0 +1,3 @@
+class UnexpectedDynamicMethod
+  # @dynamic foo, bar
+end

data/smoke/diagnostics/unexpected_jump.rb

@@ -0,0 +1,4 @@
+break
+
+next
+

data/smoke/diagnostics/unexpected_jump_value.rb

@@ -0,0 +1,3 @@
+while true
+  break 10
+end

data/smoke/diagnostics/unexpected_keyword.rb

@@ -0,0 +1 @@
+UnexpectedKeyword.new.foo(foo: 123, bar: :bar)

data/smoke/diagnostics/unexpected_splat.rb

@@ -0,0 +1 @@
+{ foo: :bar, **123 }

data/smoke/diagnostics/unexpected_yield.rb

@@ -0,0 +1,6 @@
+class UnexpectedYield
+  # @type method foo: () -> void
+  def foo
+    yield
+  end
+end

data/smoke/diagnostics/unknown_constant_assigned.rb

@@ -0,0 +1,7 @@
+class UnknownConstantAssigned
+  FOO = 123
+
+  FOO::BAR = 123
+
+  ::FOO = :foo
+end

data/smoke/diagnostics/unresolved_overloading.rb

@@ -0,0 +1 @@
+1 + ""

data/smoke/diagnostics/unsatisfiable_constraint.rb

@@ -0,0 +1,7 @@
+
+test = UnsatisfiableConstraint.new
+
+test.foo([]) do |x|
+  # @type var x: String
+  x.foo()
+end

data/smoke/diagnostics/unsupported_syntax.rb

@@ -0,0 +1,2 @@
+class <<[1, ""].sample
+end

data/smoke/dstr/a.rb

@@ -2,5 +2,4 @@
 
 a = 0
 
-# !expects NoMethodError: type=::Integer, method=foo
 b = "Hello #{a.foo} world!"

data/smoke/dstr/test.yaml

@@ -0,0 +1,10 @@
+---
+test:
+  a.rb:
+    diagnostics:
+    - |
+      a.rb:5:15: [error] Type `::Integer` does not have method `foo`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └ b = "Hello #{a.foo} world!"
+                       ~~~

data/smoke/ensure/a.rb

@@ -1,22 +1,18 @@
 # @type var a: Integer
 # @type var b: Integer
 
-# !expects IncompatibleAssignment: lhs_type=::Integer, rhs_type=::String
 a = begin
       'foo'
     ensure
-      # !expects IncompatibleAssignment: lhs_type=::Integer, rhs_type=::Symbol
       b = :foo
       1
     end
 
 # @type method foo: (String) -> String
 
-# !expects MethodBodyTypeMismatch: method=foo, expected=::String, actual=::Integer
 def foo(a)
   10
 ensure
-  # !expects* UnresolvedOverloading: receiver=::Integer, method_name=+,
   1 + '1'
   a
 end

data/smoke/ensure/test.yaml

@@ -0,0 +1,47 @@
+---
+test:
+  a.rb:
+    diagnostics:
+    - |
+      a.rb:7:6: [error] Cannot assign a value of type `::Symbol` to a variable of type `::Integer`
+      │   ::Symbol <: ::Integer
+      │     ::Object <: ::Integer
+      │       ::BasicObject <: ::Integer
+      │
+      │ Diagnostic ID: Ruby::IncompatibleAssignment
+      │
+      └       b = :foo
+              ~~~~~~~~
+    - |
+      a.rb:4:0: [error] Cannot assign a value of type `::String` to a variable of type `::Integer`
+      │   ::String <: ::Integer
+      │     ::Object <: ::Integer
+      │       ::BasicObject <: ::Integer
+      │
+      │ Diagnostic ID: Ruby::IncompatibleAssignment
+      │
+      └ a = begin
+        ~~~~~~~~~
+    - |
+      a.rb:16:2: [error] Cannot find compatible overloading of method `+` of type `::Integer`
+      │ Method types:
+      │   def +: (::Integer) -> ::Integer
+      │        | (::Float) -> ::Float
+      │        | (::Rational) -> ::Rational
+      │        | (::Complex) -> ::Complex
+      │
+      │ Diagnostic ID: Ruby::UnresolvedOverloading
+      │
+      └   1 + '1'
+          ~~~~~~~
+    - |
+      a.rb:13: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(a)
+        ~~~~~~~~~~

data/smoke/enumerator/a.rb

@@ -2,18 +2,12 @@
 
 a = [1]
 
-# !expects IncompatibleAssignment: lhs_type=::Hash[::Symbol, ::String], rhs_type=::String
 hash = a.each.with_object("") do |x, y|
-  # !expects IncompatibleAssignment: lhs_type=::Hash[::Symbol, ::String], rhs_type=::Integer
   hash = x
-  # !expects IncompatibleAssignment: lhs_type=::Hash[::Symbol, ::String], rhs_type=::String
   hash = y
 end
 
-# !expects IncompatibleAssignment: lhs_type=::Hash[::Symbol, ::String], rhs_type=::Array[::Integer]
 hash = a.each.with_index do |x, y|
-  # !expects IncompatibleAssignment: lhs_type=::Hash[::Symbol, ::String], rhs_type=::Integer
   hash = x
-  # !expects IncompatibleAssignment: lhs_type=::Hash[::Symbol, ::String], rhs_type=::Integer
   hash = y
 end

data/smoke/enumerator/b.rb

@@ -3,20 +3,17 @@
 
 a = [1]
 
-# !expects* UnresolvedOverloading:
 b = a.each.with_object([]) do |i, xs|
   # @type var xs: String
   xs << i.to_s
 end
 
-# !expects IncompatibleAssignment: lhs_type=::Array[::Integer], rhs_type=::Array[::String]
 c = a.each.with_object([]) do |i, xs|
   # @type var xs: Array[String]
   xs << i.to_s
 end
 
 # @type var d: String
-# !expects IncompatibleAssignment: lhs_type=::String, rhs_type=::Array[untyped]
 d = a.each.with_object([]) do |i, xs|
   xs << i.to_s
 end

data/smoke/enumerator/test.yaml

@@ -0,0 +1,100 @@
+---
+test:
+  a.rb:
+    diagnostics:
+    - |
+      a.rb:6:2: [error] Cannot assign a value of type `::Integer` to a variable of type `::Hash[::Symbol, ::String]`
+      │   ::Integer <: ::Hash[::Symbol, ::String]
+      │     ::Numeric <: ::Hash[::Symbol, ::String]
+      │       ::Object <: ::Hash[::Symbol, ::String]
+      │         ::BasicObject <: ::Hash[::Symbol, ::String]
+      │
+      │ Diagnostic ID: Ruby::IncompatibleAssignment
+      │
+      └   hash = x
+          ~~~~~~~~
+    - |
+      a.rb:7:2: [error] Cannot assign a value of type `::String` to a variable of type `::Hash[::Symbol, ::String]`
+      │   ::String <: ::Hash[::Symbol, ::String]
+      │     ::Object <: ::Hash[::Symbol, ::String]
+      │       ::BasicObject <: ::Hash[::Symbol, ::String]
+      │
+      │ Diagnostic ID: Ruby::IncompatibleAssignment
+      │
+      └   hash = y
+          ~~~~~~~~
+    - |
+      a.rb:5:0: [error] Cannot assign a value of type `::String` to a variable of type `::Hash[::Symbol, ::String]`
+      │   ::String <: ::Hash[::Symbol, ::String]
+      │     ::Object <: ::Hash[::Symbol, ::String]
+      │       ::BasicObject <: ::Hash[::Symbol, ::String]
+      │
+      │ Diagnostic ID: Ruby::IncompatibleAssignment
+      │
+      └ hash = a.each.with_object("") do |x, y|
+        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    - |
+      a.rb:11:2: [error] Cannot assign a value of type `::Integer` to a variable of type `::Hash[::Symbol, ::String]`
+      │   ::Integer <: ::Hash[::Symbol, ::String]
+      │     ::Numeric <: ::Hash[::Symbol, ::String]
+      │       ::Object <: ::Hash[::Symbol, ::String]
+      │         ::BasicObject <: ::Hash[::Symbol, ::String]
+      │
+      │ Diagnostic ID: Ruby::IncompatibleAssignment
+      │
+      └   hash = x
+          ~~~~~~~~
+    - |
+      a.rb:12:2: [error] Cannot assign a value of type `::Integer` to a variable of type `::Hash[::Symbol, ::String]`
+      │   ::Integer <: ::Hash[::Symbol, ::String]
+      │     ::Numeric <: ::Hash[::Symbol, ::String]
+      │       ::Object <: ::Hash[::Symbol, ::String]
+      │         ::BasicObject <: ::Hash[::Symbol, ::String]
+      │
+      │ Diagnostic ID: Ruby::IncompatibleAssignment
+      │
+      └   hash = y
+          ~~~~~~~~
+    - |
+      a.rb:10:0: [error] Cannot assign a value of type `::Array[::Integer]` to a variable of type `::Hash[::Symbol, ::String]`
+      │   ::Array[::Integer] <: ::Hash[::Symbol, ::String]
+      │     ::Object <: ::Hash[::Symbol, ::String]
+      │       ::BasicObject <: ::Hash[::Symbol, ::String]
+      │
+      │ Diagnostic ID: Ruby::IncompatibleAssignment
+      │
+      └ hash = a.each.with_index do |x, y|
+        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  b.rb:
+    diagnostics:
+    - |
+      b.rb:6:4: [error] Cannot find compatible overloading of method `with_object` of type `::Enumerator[::Integer, ::Array[::Integer]]`
+      │ Method types:
+      │   def with_object: [U] (U) { (::Integer, U) -> untyped } -> U
+      │                  | [U] (U) -> ::Enumerator[[::Integer, U], ::Array[::Integer]]
+      │
+      │ Diagnostic ID: Ruby::UnresolvedOverloading
+      │
+      └ b = a.each.with_object([]) do |i, xs|
+            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    - |
+      b.rb:11:0: [error] Cannot assign a value of type `::Array[::String]` to a variable of type `::Array[::Integer]`
+      │   ::Array[::String] <: ::Array[::Integer]
+      │     ::String <: ::Integer
+      │       ::Object <: ::Integer
+      │         ::BasicObject <: ::Integer
+      │
+      │ Diagnostic ID: Ruby::IncompatibleAssignment
+      │
+      └ c = a.each.with_object([]) do |i, xs|
+        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    - |
+      b.rb:17:0: [error] Cannot assign a value of type `::Array[untyped]` to a variable of type `::String`
+      │   ::Array[untyped] <: ::String
+      │     ::Object <: ::String
+      │       ::BasicObject <: ::String
+      │
+      │ Diagnostic ID: Ruby::IncompatibleAssignment
+      │
+      └ d = a.each.with_object([]) do |i, xs|
+        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

data/smoke/extension/a.rb

@@ -5,7 +5,6 @@ foo = (_ = nil)
 foo.try do |x|
   # @type var string: String
 
-  # !expects IncompatibleAssignment: lhs_type=::String, rhs_type=::Foo
   string = x
 end
 

data/smoke/extension/b.rb

@@ -4,9 +4,7 @@ foo = (_ = nil)
 # @type var integer: Integer
 
 # Foo#f returns String because overridden
-# !expects IncompatibleAssignment: lhs_type=::Integer, rhs_type=::String
 integer = foo.f()
 
 # String#f returns Object because Object(X)#f is used
-# !expects IncompatibleAssignment: lhs_type=::Integer, rhs_type=::Object
 integer = "".f()

data/smoke/extension/c.rb

@@ -3,7 +3,6 @@ class Foo
 
   def f()
     # @type var string: String
-    # !expects IncompatibleAssignment: lhs_type=::String, rhs_type=::Object
     string = super()
     string
   end

data/smoke/extension/test.yaml

@@ -0,0 +1,50 @@
+---
+test:
+  a.rb:
+    diagnostics:
+    - |
+      a.rb:8:2: [error] Cannot assign a value of type `::Foo` to a variable of type `::String`
+      │   ::Foo <: ::String
+      │     ::Object <: ::String
+      │       ::BasicObject <: ::String
+      │
+      │ Diagnostic ID: Ruby::IncompatibleAssignment
+      │
+      └   string = x
+          ~~~~~~~~~~
+  b.rb:
+    diagnostics:
+    - |
+      b.rb:7:0: [error] Cannot assign a value of type `::String` to a variable of type `::Integer`
+      │   ::String <: ::Integer
+      │     ::Object <: ::Integer
+      │       ::BasicObject <: ::Integer
+      │
+      │ Diagnostic ID: Ruby::IncompatibleAssignment
+      │
+      └ integer = foo.f()
+        ~~~~~~~~~~~~~~~~~
+    - |
+      b.rb:10:0: [error] Cannot assign a value of type `::Object` to a variable of type `::Integer`
+      │   ::Object <: ::Integer
+      │     ::BasicObject <: ::Integer
+      │
+      │ Diagnostic ID: Ruby::IncompatibleAssignment
+      │
+      └ integer = "".f()
+        ~~~~~~~~~~~~~~~~
+  c.rb:
+    diagnostics:
+    - |
+      c.rb:6:4: [error] Cannot assign a value of type `::Object` to a variable of type `::String`
+      │   ::Object <: ::String
+      │     ::BasicObject <: ::String
+      │
+      │ Diagnostic ID: Ruby::IncompatibleAssignment
+      │
+      └     string = super()
+            ~~~~~~~~~~~~~~~~
+  d.rb:
+    diagnostics: []
+  e.rb:
+    diagnostics: []

data/smoke/hash/b.rb

@@ -3,5 +3,4 @@
 x = { foo: "foo" }
 x = { foo: nil }
 
-# !expects IncompatibleAssignment: lhs_type=::Hash[::Symbol, (::String | nil)], rhs_type=::Hash[::Symbol, ::Integer]
 x = { foo: 3 }

data/smoke/hash/c.rb

@@ -2,14 +2,11 @@
 params = _ = nil
 
 id = params[:id]
-# !expects NoMethodError: type=::Integer, method=abcdefg
 id.abcdefg
 
 name = params[:name]
-# !expects NoMethodError: type=::String, method=abcdefg
 name.abcdefg
 
-# !expects NoMethodError: type=(::Integer | ::String), method=abcdefg
 params[(_=nil) ? :id : :name].abcdefg
 
 # @type var controller: Controller

data/smoke/hash/d.rb

@@ -2,5 +2,4 @@
 
 params = { id: 30, name: "Matz" }
 
-# !expects IncompatibleAssignment: lhs_type={ :id => ::Integer, :name => ::String }, rhs_type={ :email => ::String, :id => ::String, :name => ::String }
 params = { id: "30", name: "foo", email: "matsumoto@soutaro.com" }

data/smoke/hash/e.rb

@@ -1,2 +1 @@
-# !expects NoMethodError: type=::Integer, method=fffffffffffff
 Foo.new.get({ foo: 3 }).fffffffffffff

data/smoke/hash/test.yaml

@@ -0,0 +1,62 @@
+---
+test:
+  a.rb:
+    diagnostics: []
+  b.rb:
+    diagnostics:
+    - |
+      b.rb:6:0: [error] Cannot assign a value of type `::Hash[::Symbol, ::Integer]` to a variable of type `::Hash[::Symbol, (::String | nil)]`
+      │   ::Hash[::Symbol, ::Integer] <: ::Hash[::Symbol, (::String | nil)]
+      │     ::Integer <: (::String | nil)
+      │       ::Integer <: ::String
+      │         ::Numeric <: ::String
+      │           ::Object <: ::String
+      │             ::BasicObject <: ::String
+      │
+      │ Diagnostic ID: Ruby::IncompatibleAssignment
+      │
+      └ x = { foo: 3 }
+        ~~~~~~~~~~~~~~
+  c.rb:
+    diagnostics:
+    - |
+      c.rb:5:3: [error] Type `::Integer` does not have method `abcdefg`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └ id.abcdefg
+           ~~~~~~~
+    - |
+      c.rb:8:5: [error] Type `::String` does not have method `abcdefg`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └ name.abcdefg
+             ~~~~~~~
+    - |
+      c.rb:10:30: [error] Type `(::Integer | ::String)` does not have method `abcdefg`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └ params[(_=nil) ? :id : :name].abcdefg
+                                      ~~~~~~~
+  d.rb:
+    diagnostics:
+    - |
+      d.rb:5:0: [error] Cannot assign a value of type `{ :email => ::String, :id => ::String, :name => ::String }` to a variable of type `{ :id => ::Integer, :name => ::String }`
+      │   { :email => ::String, :id => ::String, :name => ::String } <: { :id => ::Integer, :name => ::String }
+      │     ::String <: ::Integer
+      │       ::Object <: ::Integer
+      │         ::BasicObject <: ::Integer
+      │
+      │ Diagnostic ID: Ruby::IncompatibleAssignment
+      │
+      └ params = { id: "30", name: "foo", email: "matsumoto@soutaro.com" }
+        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  e.rb:
+    diagnostics:
+    - |
+      e.rb:1:24: [error] Type `::Integer` does not have method `fffffffffffff`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └ Foo.new.get({ foo: 3 }).fffffffffffff
+                                ~~~~~~~~~~~~~
+  f.rb:
+    diagnostics: []