steep 0.39.0 → 0.40.0

data/lib/steep/version.rb

@@ -1,3 +1,3 @@
 module Steep
-  VERSION = "0.39.0"
+  VERSION = "0.40.0"
 end

data/smoke/alias/a.rb

@@ -1,7 +1,6 @@
 # @type var x: foo
 x = ""
 
-# !expects* UnresolvedOverloading: receiver=(::String | ::Integer), method_name=+,
 x + 123
 
 # @type var y: bar
@@ -11,9 +10,7 @@ y = []
 # @type var z: Symbol
 case x
 when String
-  # !expects IncompatibleAssignment: lhs_type=::Symbol, rhs_type=::String
   z = x
 when Integer
-  # !expects IncompatibleAssignment: lhs_type=::Symbol, rhs_type=::Integer
   z = x
 end

data/smoke/alias/b.rb

@@ -3,5 +3,4 @@
 a = ["", :foo]
 
 # @type var x: Integer
-# !expects IncompatibleAssignment: lhs_type=::Integer, rhs_type=::String
 x = a[0]

data/smoke/alias/c.rb

@@ -1,10 +1,8 @@
 # @type var x: String
 
-# !expects IncompatibleAssignment: lhs_type=::String, rhs_type=::Integer
 x = AliasMethodArg.new.foo(:foo)
 
 # @type var name: name
 name = :bar
 
-# !expects IncompatibleAssignment: lhs_type=::String, rhs_type=::Integer
 x = AliasMethodArg.new.foo(name)

data/smoke/alias/test.yaml

@@ -0,0 +1,73 @@
+---
+test:
+  a.rb:
+    diagnostics:
+    - |
+      a.rb:4:0: [error] Cannot find compatible overloading of method `+` of type `(::String | ::Integer)`
+      │ Method types:
+      │   def +: ((::string & ::Integer)) -> (::String | ::Integer)
+      │        | ((::string & ::Float)) -> (::String | ::Float)
+      │        | ((::string & ::Rational)) -> (::String | ::Rational)
+      │        | ((::string & ::Complex)) -> (::String | ::Complex)
+      │
+      │ Diagnostic ID: Ruby::UnresolvedOverloading
+      │
+      └ x + 123
+        ~~~~~~~
+    - |
+      a.rb:13:2: [error] Cannot assign a value of type `::String` to a variable of type `::Symbol`
+      │   ::String <: ::Symbol
+      │     ::Object <: ::Symbol
+      │       ::BasicObject <: ::Symbol
+      │
+      │ Diagnostic ID: Ruby::IncompatibleAssignment
+      │
+      └   z = x
+          ~~~~~
+    - |
+      a.rb:15:2: [error] Cannot assign a value of type `::Integer` to a variable of type `::Symbol`
+      │   ::Integer <: ::Symbol
+      │     ::Numeric <: ::Symbol
+      │       ::Object <: ::Symbol
+      │         ::BasicObject <: ::Symbol
+      │
+      │ Diagnostic ID: Ruby::IncompatibleAssignment
+      │
+      └   z = x
+          ~~~~~
+  b.rb:
+    diagnostics:
+    - |
+      b.rb:6: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
+      │
+      └ x = a[0]
+        ~~~~~~~~
+  c.rb:
+    diagnostics:
+    - |
+      c.rb:3: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 = AliasMethodArg.new.foo(:foo)
+        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    - |
+      c.rb:8: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 = AliasMethodArg.new.foo(name)
+        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

data/smoke/and/a.rb

@@ -3,9 +3,6 @@
 
 a = "foo"
 
-# !expects IncompatibleAssignment: lhs_type=::String, rhs_type=(::String | nil)
 b = a && a.to_str
 
-# !expects IncompatibleAssignment: lhs_type=::Integer, rhs_type=(::String | nil)
 c = a && a.to_str
-

data/smoke/and/test.yaml

@@ -0,0 +1,24 @@
+---
+test:
+  a.rb:
+    diagnostics:
+    - |
+      a.rb:6:0: [error] Cannot assign a value of type `(::String | nil)` to a variable of type `::String`
+      │   (::String | nil) <: ::String
+      │     nil <: ::String
+      │
+      │ Diagnostic ID: Ruby::IncompatibleAssignment
+      │
+      └ b = a && a.to_str
+        ~~~~~~~~~~~~~~~~~
+    - |
+      a.rb:8:0: [error] Cannot assign a value of type `(::String | nil)` to a variable of type `::Integer`
+      │   (::String | nil) <: ::Integer
+      │     ::String <: ::Integer
+      │       ::Object <: ::Integer
+      │         ::BasicObject <: ::Integer
+      │
+      │ Diagnostic ID: Ruby::IncompatibleAssignment
+      │
+      └ c = a && a.to_str
+        ~~~~~~~~~~~~~~~~~

data/smoke/array/a.rb

@@ -3,19 +3,16 @@
 a = []
 a[1] = 3
 
-# !expects* UnresolvedOverloading: receiver=::Array[::Integer], method_name=[]=,
 a[2] = "foo"
 
 # @type var i: Integer
 i = a[0]
 
 # @type var s: String
-# !expects IncompatibleAssignment: lhs_type=::String, rhs_type=::Integer
 s = a[1]
 
 
 b = ["a", "b", "c"]
 
 s = b[0]
-# !expects IncompatibleAssignment: lhs_type=::Integer, rhs_type=::String
 i = b[1]

data/smoke/array/b.rb

@@ -8,7 +8,5 @@ y = x
 # @type var b: Array[String]
 
 a = []
-# !expects IncompatibleAssignment: lhs_type=::Array[::String], rhs_type=::Array[::Integer]
 b = a
-# !expects IncompatibleAssignment: lhs_type=::Array[::Integer], rhs_type=::Array[::String]
 a = b

data/smoke/array/c.rb

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

data/smoke/array/test.yaml

@@ -0,0 +1,80 @@
+---
+test:
+  a.rb:
+    diagnostics:
+    - |
+      a.rb:6:0: [error] Cannot find compatible overloading of method `[]=` of type `::Array[::Integer]`
+      │ Method types:
+      │   def []=: (::int, ::Integer) -> ::Integer
+      │          | (::int, ::int, ::Integer) -> ::Integer
+      │          | (::int, ::int, ::Array[::Integer]) -> ::Array[::Integer]
+      │          | (::int, ::int, nil) -> nil
+      │          | (::Range[::Integer], ::Integer) -> ::Integer
+      │          | (::Range[::Integer], ::Array[::Integer]) -> ::Array[::Integer]
+      │          | (::Range[::Integer], nil) -> nil
+      │
+      │ Diagnostic ID: Ruby::UnresolvedOverloading
+      │
+      └ a[2] = "foo"
+        ~~~~~~~~~~~~
+    - |
+      a.rb:12: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
+      │
+      └ s = a[1]
+        ~~~~~~~~
+    - |
+      a.rb:18: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
+      │
+      └ i = b[1]
+        ~~~~~~~~
+  b.rb:
+    diagnostics:
+    - |
+      b.rb:11:0: [error] Cannot assign a value of type `::Array[::Integer]` to a variable of type `::Array[::String]`
+      │   ::Array[::Integer] <: ::Array[::String]
+      │     ::Integer <: ::String
+      │       ::Numeric <: ::String
+      │         ::Object <: ::String
+      │           ::BasicObject <: ::String
+      │
+      │ Diagnostic ID: Ruby::IncompatibleAssignment
+      │
+      └ b = a
+        ~~~~~
+    - |
+      b.rb:12: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
+      │
+      └ a = b
+        ~~~~~
+  c.rb:
+    diagnostics:
+    - |
+      c.rb:6:0: [error] Cannot assign a value of type `::Array[::Integer]` to a variable of type `::Array[(::String | nil)]`
+      │   ::Array[::Integer] <: ::Array[(::String | nil)]
+      │     ::Integer <: (::String | nil)
+      │       ::Integer <: ::String
+      │         ::Numeric <: ::String
+      │           ::Object <: ::String
+      │             ::BasicObject <: ::String
+      │
+      │ Diagnostic ID: Ruby::IncompatibleAssignment
+      │
+      └ x = [1]
+        ~~~~~~~

data/smoke/block/a.rb

@@ -5,8 +5,6 @@ a = A.new
 # @type var i: Integer
 # @type var s: String
 
-# !expects IncompatibleAssignment: lhs_type=::String, rhs_type=::Integer
 s = a.foo
 
-# !expects IncompatibleAssignment: lhs_type=::Integer, rhs_type=::String
 i = a.foo { nil }

data/smoke/block/b.rb

@@ -2,13 +2,11 @@
 a = (_ = nil)
 
 a.bar do |x|
-  # !expects BreakTypeMismatch: expected=::Symbol, actual=::Integer
   break 3
 end
 
 # @type var s: ::String
 
-# !expects IncompatibleAssignment: lhs_type=::String, rhs_type=(::Integer | ::Symbol)
 s = a.bar do |x|
   # @type break: ::Integer
   break 3

data/smoke/block/d.rb

@@ -3,13 +3,9 @@ a = -> (x) { x.to_s }
 
 # @type var b: Array[Float]
 
-# !expects IncompatibleAssignment: lhs_type=::Array[::Float], rhs_type=::Array[::String]
 b = [1,2,3].map(&a)
 
-# !expects IncompatibleAssignment: lhs_type=::Array[::Float], rhs_type=::Array[::String]
 b = [1,2,3].map(&:to_s)
 
-# !expects* UnresolvedOverloading: receiver=::Array[::Integer], method_name=map,
 [1,2,3].map(&:no_such_method)
-# !expects* UnresolvedOverloading: receiver=::Array[::Integer], method_name=map,
 [1,2,3].map(&:divmod)

data/smoke/block/test.yaml

@@ -0,0 +1,96 @@
+---
+test:
+  a.rb:
+    diagnostics:
+    - |
+      a.rb:8: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
+      │
+      └ s = a.foo
+        ~~~~~~~~~
+    - |
+      a.rb:10: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
+      │
+      └ i = a.foo { nil }
+        ~~~~~~~~~~~~~~~~~
+  b.rb:
+    diagnostics:
+    - |
+      b.rb:5:2: [error] Cannot break with a value of type `::Integer` because type `::Symbol` is assumed
+      │   ::Integer <: ::Symbol
+      │     ::Numeric <: ::Symbol
+      │       ::Object <: ::Symbol
+      │         ::BasicObject <: ::Symbol
+      │
+      │ Diagnostic ID: Ruby::BreakTypeMismatch
+      │
+      └   break 3
+          ~~~~~~~
+    - |
+      b.rb:10:0: [error] Cannot assign a value of type `(::Integer | ::Symbol)` to a variable of type `::String`
+      │   (::Integer | ::Symbol) <: ::String
+      │     ::Integer <: ::String
+      │       ::Numeric <: ::String
+      │         ::Object <: ::String
+      │           ::BasicObject <: ::String
+      │
+      │ Diagnostic ID: Ruby::IncompatibleAssignment
+      │
+      └ s = a.bar do |x|
+        ~~~~~~~~~~~~~~~~
+  c.rb:
+    diagnostics: []
+  d.rb:
+    diagnostics:
+    - |
+      d.rb:6:0: [error] Cannot assign a value of type `::Array[::String]` to a variable of type `::Array[::Float]`
+      │   ::Array[::String] <: ::Array[::Float]
+      │     ::String <: ::Float
+      │       ::Object <: ::Float
+      │         ::BasicObject <: ::Float
+      │
+      │ Diagnostic ID: Ruby::IncompatibleAssignment
+      │
+      └ b = [1,2,3].map(&a)
+        ~~~~~~~~~~~~~~~~~~~
+    - |
+      d.rb:8:0: [error] Cannot assign a value of type `::Array[::String]` to a variable of type `::Array[::Float]`
+      │   ::Array[::String] <: ::Array[::Float]
+      │     ::String <: ::Float
+      │       ::Object <: ::Float
+      │         ::BasicObject <: ::Float
+      │
+      │ Diagnostic ID: Ruby::IncompatibleAssignment
+      │
+      └ b = [1,2,3].map(&:to_s)
+        ~~~~~~~~~~~~~~~~~~~~~~~
+    - |
+      d.rb:10:0: [error] Cannot find compatible overloading of method `map` of type `::Array[::Integer]`
+      │ Method types:
+      │   def map: [U] () { (::Integer) -> U } -> ::Array[U]
+      │          | () -> ::Enumerator[::Integer, ::Array[untyped]]
+      │
+      │ Diagnostic ID: Ruby::UnresolvedOverloading
+      │
+      └ [1,2,3].map(&:no_such_method)
+        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    - |
+      d.rb:11:0: [error] Cannot find compatible overloading of method `map` of type `::Array[::Integer]`
+      │ Method types:
+      │   def map: [U] () { (::Integer) -> U } -> ::Array[U]
+      │          | () -> ::Enumerator[::Integer, ::Array[untyped]]
+      │
+      │ Diagnostic ID: Ruby::UnresolvedOverloading
+      │
+      └ [1,2,3].map(&:divmod)
+        ~~~~~~~~~~~~~~~~~~~~~

data/smoke/broken/Steepfile

@@ -0,0 +1,5 @@
+target :test do
+  typing_options :strict
+  check "*.rb"
+  signature "*.rbs"
+end

data/smoke/broken/test.yaml

@@ -0,0 +1,6 @@
+---
+test:
+  broken.rbs:
+    diagnostics: []
+  broken.rb:
+    diagnostics: []

data/smoke/case/a.rb

@@ -1,6 +1,5 @@
 # @type var a: Integer
 
-# !expects IncompatibleAssignment: lhs_type=::Integer, rhs_type=(::Integer | ::Array[::String] | nil | ::String)
 a = case 1
     when 2
       1
@@ -13,9 +12,7 @@ a = case 1
       "string"
     end
 
-# !expects IncompatibleAssignment: lhs_type=::Integer, rhs_type=(::Integer | nil)
 a = case
-    # !expects* UnresolvedOverloading: receiver=::Integer, method_name=+,
     when 1+"a"
       30
     end

data/smoke/case/test.yaml

@@ -0,0 +1,36 @@
+---
+test:
+  a.rb:
+    diagnostics:
+    - |
+      a.rb:3:0: [error] Cannot assign a value of type `(::Integer | ::Array[::String] | nil | ::String)` to a variable of type `::Integer`
+      │   (::Integer | ::Array[::String] | nil | ::String) <: ::Integer
+      │     ::Array[::String] <: ::Integer
+      │       ::Object <: ::Integer
+      │         ::BasicObject <: ::Integer
+      │
+      │ Diagnostic ID: Ruby::IncompatibleAssignment
+      │
+      └ a = case 1
+        ~~~~~~~~~~
+    - |
+      a.rb:16:9: [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
+      │
+      └     when 1+"a"
+                 ~~~~~
+    - |
+      a.rb:15:0: [error] Cannot assign a value of type `(::Integer | nil)` to a variable of type `::Integer`
+      │   (::Integer | nil) <: ::Integer
+      │     nil <: ::Integer
+      │
+      │ Diagnostic ID: Ruby::IncompatibleAssignment
+      │
+      └ a = case
+        ~~~~~~~~