steep 0.39.0 → 0.40.0

data/smoke/hello/hello.rb

@@ -6,8 +6,6 @@ y = (_ = nil)
 
 a = x.foo
 
-# !expects NoMethodError: type=::_Bar, method=foo
 b = y.foo
 
-# !expects IncompatibleAssignment: lhs_type=::_Foo, rhs_type=::_Bar
 x = y

data/smoke/hello/test.yaml

@@ -0,0 +1,18 @@
+---
+test:
+  hello.rb:
+    diagnostics:
+    - |
+      hello.rb:9:6: [error] Type `::_Bar` does not have method `foo`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └ b = y.foo
+              ~~~
+    - |
+      hello.rb:11:0: [error] Cannot assign a value of type `::_Bar` to a variable of type `::_Foo`
+      │   ::_Bar <: ::_Foo
+      │
+      │ Diagnostic ID: Ruby::IncompatibleAssignment
+      │
+      └ x = y
+        ~~~~~

data/smoke/if/a.rb

@@ -2,7 +2,6 @@
 
 x = y = z = (_ = nil)
 
-# !expects IncompatibleAssignment: lhs_type=::String, rhs_type=(::Symbol | nil)
 a = if x
       :foo
     end
@@ -13,7 +12,6 @@ else
   "baz"
 end
 
-# !expects IncompatibleAssignment: lhs_type=::String, rhs_type=(::String | ::Integer)
 a = if z
       "foofoo"
     else

data/smoke/if/test.yaml

@@ -0,0 +1,27 @@
+---
+test:
+  a.rb:
+    diagnostics:
+    - |
+      a.rb:5:0: [error] Cannot assign a value of type `(::Symbol | nil)` to a variable of type `::String`
+      │   (::Symbol | nil) <: ::String
+      │     ::Symbol <: ::String
+      │       ::Object <: ::String
+      │         ::BasicObject <: ::String
+      │
+      │ Diagnostic ID: Ruby::IncompatibleAssignment
+      │
+      └ a = if x
+        ~~~~~~~~
+    - |
+      a.rb:15:0: [error] Cannot assign a value of type `(::String | ::Integer)` to a variable of type `::String`
+      │   (::String | ::Integer) <: ::String
+      │     ::Integer <: ::String
+      │       ::Numeric <: ::String
+      │         ::Object <: ::String
+      │           ::BasicObject <: ::String
+      │
+      │ Diagnostic ID: Ruby::IncompatibleAssignment
+      │
+      └ a = if z
+        ~~~~~~~~

data/smoke/implements/a.rb

@@ -1,5 +1,3 @@
-# !expects@+2 MethodDefinitionMissing: module=::A, method=baz
-# !expects MethodDefinitionMissing: module=::A, method=self.bar
 class A
   # @implements A
 

data/smoke/implements/test.yaml

@@ -0,0 +1,16 @@
+---
+test:
+  a.rb:
+    diagnostics:
+    - |
+      a.rb:1:6: [error] Cannot find implementation of method `::A#baz`
+      │ Diagnostic ID: Ruby::MethodDefinitionMissing
+      │
+      └ class A
+              ~
+    - |
+      a.rb:1:6: [error] Cannot find implementation of method `::A.bar`
+      │ Diagnostic ID: Ruby::MethodDefinitionMissing
+      │
+      └ class A
+              ~

data/smoke/initialize/test.yaml

@@ -0,0 +1,4 @@
+---
+test:
+  a.rb:
+    diagnostics: []

data/smoke/integer/a.rb

@@ -1,33 +1,26 @@
 # @type var x: Numeric
 x = _ = 1
 integer_1 = Integer(x)
-# !expects NoMethodError: type=::Integer, method=foo
 integer_1.foo
 
 integer_2 = Integer("1")
-# !expects NoMethodError: type=::Integer, method=foo
 integer_2.foo
 
 class WithToInt
   def to_int; 1; end
 end
 integer_3 = Integer(WithToInt.new)
-# !expects NoMethodError: type=::Integer, method=foo
 integer_3.foo
 
 class WithToI
   def to_i; 1; end
 end
 integer_4 = Integer(WithToI.new)
-# !expects NoMethodError: type=::Integer, method=foo
 integer_4.foo
 
 integer_5 = Integer("10", 2)
-# !expects NoMethodError: type=::Integer, method=foo
 integer_5.foo
 
-# !expects* UnresolvedOverloading: receiver=::Object, method_name=Integer,
 Integer(Object.new)
 
-# !expects* UnresolvedOverloading: receiver=::Object, method_name=Integer,
 Integer(nil)

data/smoke/integer/test.yaml

@@ -0,0 +1,66 @@
+---
+test:
+  a.rb:
+    diagnostics:
+    - |
+      a.rb:4:10: [error] Type `::Integer` does not have method `foo`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └ integer_1.foo
+                  ~~~
+    - |
+      a.rb:7:10: [error] Type `::Integer` does not have method `foo`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └ integer_2.foo
+                  ~~~
+    - |
+      a.rb:12:20: [error] Cannot detect the type of the expression
+      │ Diagnostic ID: Ruby::FallbackAny
+      │
+      └ integer_3 = Integer(WithToInt.new)
+                            ~~~~~~~~~
+    - |
+      a.rb:13:10: [error] Type `::Integer` does not have method `foo`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └ integer_3.foo
+                  ~~~
+    - |
+      a.rb:18:20: [error] Cannot detect the type of the expression
+      │ Diagnostic ID: Ruby::FallbackAny
+      │
+      └ integer_4 = Integer(WithToI.new)
+                            ~~~~~~~
+    - |
+      a.rb:19:10: [error] Type `::Integer` does not have method `foo`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └ integer_4.foo
+                  ~~~
+    - |
+      a.rb:22:10: [error] Type `::Integer` does not have method `foo`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └ integer_5.foo
+                  ~~~
+    - |
+      a.rb:24:0: [error] Cannot find compatible overloading of method `Integer` of type `::Object`
+      │ Method types:
+      │   def Integer: ((::Numeric | ::String), ?exception: bool) -> ::Integer
+      │              | (::String, ?::Integer, ?exception: bool) -> ::Integer
+      │
+      │ Diagnostic ID: Ruby::UnresolvedOverloading
+      │
+      └ Integer(Object.new)
+        ~~~~~~~~~~~~~~~~~~~
+    - |
+      a.rb:26:0: [error] Cannot find compatible overloading of method `Integer` of type `::Object`
+      │ Method types:
+      │   def Integer: ((::Numeric | ::String), ?exception: bool) -> ::Integer
+      │              | (::String, ?::Integer, ?exception: bool) -> ::Integer
+      │
+      │ Diagnostic ID: Ruby::UnresolvedOverloading
+      │
+      └ Integer(nil)
+        ~~~~~~~~~~~~

data/smoke/interface/a.rb

@@ -2,13 +2,11 @@ class A
   # @dynamic foo
 
   def hello
-    # !expects NoMethodError: type=::A::Object, method=bar
     foo.foo.bar
 
     # @type var object: ::Object
     object = _ = nil
 
-    # !expects NoMethodError: type=::Object, method=object?
     object.object?
   end
 end

data/smoke/interface/test.yaml

@@ -0,0 +1,16 @@
+---
+test:
+  a.rb:
+    diagnostics:
+    - |
+      a.rb:5:12: [error] Type `::A::Object` does not have method `bar`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └     foo.foo.bar
+                    ~~~
+    - |
+      a.rb:10:11: [error] Type `::Object` does not have method `object?`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └     object.object?
+                   ~~~~~~~

data/smoke/kwbegin/a.rb

@@ -1,6 +1,5 @@
 # @type var a: Integer
 
-# !expects IncompatibleAssignment: lhs_type=::Integer, rhs_type=::String
 a = begin
   # @type var x: String
   x = '1'

data/smoke/kwbegin/test.yaml

@@ -0,0 +1,14 @@
+---
+test:
+  a.rb:
+    diagnostics:
+    - |
+      a.rb:3: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
+        ~~~~~~~~~

data/smoke/lambda/a.rb

@@ -1,6 +1,5 @@
 # @type var a: Integer
 
-# !expects IncompatibleAssignment: lhs_type=::Integer, rhs_type=::String
 a = -> (x, y) do
   # @type var x: String
   # @type var y: String
@@ -8,10 +7,8 @@ a = -> (x, y) do
 end["foo", "bar"]
 
 # @type var b: ^(Integer) -> Integer
-# !expects IncompatibleAssignment: lhs_type=^(::Integer) -> ::Integer, rhs_type=::Proc
 b = lambda do |x|
-  # !expects NoMethodError: type=nil, method=+
-  x + 1 
+  x + 1
 end
 
 # @type var c: ^(Integer) -> Integer

data/smoke/lambda/test.yaml

@@ -0,0 +1,28 @@
+---
+test:
+  a.rb:
+    diagnostics:
+    - |
+      a.rb:3: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 = -> (x, y) do
+        ~~~~~~~~~~~~~~~~
+    - |
+      a.rb:11:4: [error] Type `nil` does not have method `+`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └   x + 1
+            ~
+    - |
+      a.rb:10:0: [error] Cannot assign a value of type `::Proc` to a variable of type `^(::Integer) -> ::Integer`
+      │   ::Proc <: ^(::Integer) -> ::Integer
+      │
+      │ Diagnostic ID: Ruby::IncompatibleAssignment
+      │
+      └ b = lambda do |x|
+        ~~~~~~~~~~~~~~~~~

data/smoke/literal/a.rb

@@ -1,16 +1,11 @@
 # @type var x: String
 # @type var y: Integer
 
-# !expects IncompatibleAssignment: lhs_type=::String, rhs_type=::Integer
 x = 1
 
-# !expects IncompatibleAssignment: lhs_type=::String, rhs_type=::Symbol
 x = :foo
 
-# !expects IncompatibleAssignment: lhs_type=::Integer, rhs_type=::String
 y = "foo"
 
-# !expects IncompatibleAssignment: lhs_type=::String, rhs_type=bool
 x = true
-# !expects IncompatibleAssignment: lhs_type=::Integer, rhs_type=bool
 y = false

data/smoke/literal/b.rb

@@ -1,9 +1,7 @@
 l = LiteralMethods.new
 
 l.foo(3)
-# !expects ArgumentTypeMismatch: receiver=::LiteralMethods, expected=3, actual=::Integer
 l.foo(4)
 
 l.bar(foo: :foo)
-# !expects IncompatibleAssignment: lhs_type=:foo, rhs_type=::Symbol
 l.bar(foo: :bar)

data/smoke/literal/test.yaml

@@ -0,0 +1,79 @@
+---
+test:
+  a.rb:
+    diagnostics:
+    - |
+      a.rb:4:0: [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
+      │
+      └ x = 1
+        ~~~~~
+    - |
+      a.rb:6:0: [error] Cannot assign a value of type `::Symbol` to a variable of type `::String`
+      │   ::Symbol <: ::String
+      │     ::Object <: ::String
+      │       ::BasicObject <: ::String
+      │
+      │ Diagnostic ID: Ruby::IncompatibleAssignment
+      │
+      └ x = :foo
+        ~~~~~~~~
+    - |
+      a.rb:8: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
+      │
+      └ y = "foo"
+        ~~~~~~~~~
+    - |
+      a.rb:10:0: [error] Cannot assign a value of type `bool` to a variable of type `::String`
+      │   bool <: ::String
+      │     (true | false) <: ::String
+      │       true <: ::String
+      │         ::TrueClass <: ::String
+      │           ::Object <: ::String
+      │             ::BasicObject <: ::String
+      │
+      │ Diagnostic ID: Ruby::IncompatibleAssignment
+      │
+      └ x = true
+        ~~~~~~~~
+    - |
+      a.rb:11:0: [error] Cannot assign a value of type `bool` to a variable of type `::Integer`
+      │   bool <: ::Integer
+      │     (true | false) <: ::Integer
+      │       true <: ::Integer
+      │         ::TrueClass <: ::Integer
+      │           ::Object <: ::Integer
+      │             ::BasicObject <: ::Integer
+      │
+      │ Diagnostic ID: Ruby::IncompatibleAssignment
+      │
+      └ y = false
+        ~~~~~~~~~
+  b.rb:
+    diagnostics:
+    - |
+      b.rb:4:6: [error] Cannot pass a value of type `::Integer` as an argument of type `3`
+      │   ::Integer <: 3
+      │
+      │ Diagnostic ID: Ruby::ArgumentTypeMismatch
+      │
+      └ l.foo(4)
+              ~
+    - |
+      b.rb:7:11: [error] Cannot assign a value of type `::Symbol` to an expression of type `:foo`
+      │   ::Symbol <: :foo
+      │
+      │ Diagnostic ID: Ruby::IncompatibleAssignment
+      │
+      └ l.bar(foo: :bar)
+                   ~~~~

data/smoke/map/test.yaml

@@ -0,0 +1,4 @@
+---
+test:
+  a.rb:
+    diagnostics: []

data/smoke/method/a.rb

@@ -1,13 +1,10 @@
 # @type method foo: (Integer, y: Integer) -> String
 
-# !expects MethodBodyTypeMismatch: method=foo, expected=::String, actual=::Integer
 def foo(x, y:)
   # @type var z: String
 
-  # !expects IncompatibleAssignment: lhs_type=::String, rhs_type=::Integer
   z = x
 
-  # !expects IncompatibleAssignment: lhs_type=::String, rhs_type=::Integer
   z = y
 
   3
@@ -15,11 +12,9 @@ end
 
 # @type method bar: (Integer) -> String
 
-# !expects MethodArityMismatch: method=bar
 def bar(x, y)
   # @type var z: String
 
-  # !expects IncompatibleAssignment: lhs_type=::String, rhs_type=::Integer
   z = x
 
   z = y