steep 0.39.0 → 0.40.0

data/smoke/class/a.rb

@@ -5,13 +5,11 @@ class A
   end
 
   # A#bar is defined but the implementation is incompatible.
-  # !expects MethodArityMismatch: method=bar
   def bar(y)
     y
   end
 
   # Object#to_s is defined but the implementation is incompatible.
-  # !expects MethodBodyTypeMismatch: method=to_s, expected=::String, actual=::Integer
   def to_s
     3
   end
@@ -21,7 +19,6 @@ class A
     5
   end
 
-  # !expects MethodBodyTypeMismatch: method=self.baz, expected=::Integer, actual=::String
   def self.baz
     "baz"
   end

data/smoke/class/c.rb

@@ -1,4 +1,3 @@
-# !expects UnexpectedDynamicMethod: module=::B, method=type
 class B
   # @implements B
 

data/smoke/class/f.rb

@@ -6,5 +6,4 @@ d = (_ = nil)
 
 e = d
 
-# !expects IncompatibleAssignment: lhs_type=::D, rhs_type=::_E
 d = e

data/smoke/class/g.rb

@@ -1,8 +1,6 @@
-# !expects MethodDefinitionMissing: module=::B, method=name
 class B
 end
 
-# !expects MethodDefinitionMissing: module=::B, method=name
 class C
   # @implements ::B
 end

data/smoke/class/i.rb

@@ -1,14 +1,12 @@
 class IncompatibleChild
   def foo(arg)
     # @type var x: Symbol
-    # !expects IncompatibleAssignment: lhs_type=::Symbol, rhs_type=::Integer
     x = super()
 
     "123"
   end
 
   def initialize()
-    # !expects IncompatibleArguments: receiver=::IncompatibleChild, method_type=(name: ::String) -> untyped
     super()
 
     super

data/smoke/class/test.yaml

@@ -0,0 +1,89 @@
+---
+test:
+  a.rb:
+    diagnostics:
+    - |
+      a.rb:8:9: [error] Method parameters are incompatible with declaration `() -> ::String`
+      │ Diagnostic ID: Ruby::MethodArityMismatch
+      │
+      └   def bar(y)
+                 ~~~
+    - |
+      a.rb:13:2: [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 to_s
+          ~~~~~~~~
+    - |
+      a.rb:22:2: [error] Cannot allow method body have type `::String` because declared as type `::Integer`
+      │   ::String <: ::Integer
+      │     ::Object <: ::Integer
+      │       ::BasicObject <: ::Integer
+      │
+      │ Diagnostic ID: Ruby::MethodBodyTypeMismatch
+      │
+      └   def self.baz
+          ~~~~~~~~~~~~
+  b.rb:
+    diagnostics: []
+  c.rb:
+    diagnostics:
+    - |
+      c.rb:1:6: [error] @dynamic annotation contains unknown method name `type`
+      │ Diagnostic ID: Ruby::UnexpectedDynamicMethod
+      │
+      └ class B
+              ~
+  f.rb:
+    diagnostics:
+    - |
+      f.rb:9:0: [error] Cannot assign a value of type `::_E` to a variable of type `::D`
+      │   ::_E <: ::D
+      │
+      │ Diagnostic ID: Ruby::IncompatibleAssignment
+      │
+      └ d = e
+        ~~~~~
+  g.rb:
+    diagnostics:
+    - |
+      g.rb:1:6: [error] Cannot find implementation of method `::B#name`
+      │ Diagnostic ID: Ruby::MethodDefinitionMissing
+      │
+      └ class B
+              ~
+    - |
+      g.rb:4:6: [error] Cannot find implementation of method `::B#name`
+      │ Diagnostic ID: Ruby::MethodDefinitionMissing
+      │
+      └ class C
+              ~
+  h.rb:
+    diagnostics: []
+  i.rb:
+    diagnostics:
+    - |
+      i.rb:4:4: [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
+      │
+      └     x = super()
+            ~~~~~~~~~~~
+    - |
+      i.rb:10:4: [error] Cannot find method `initialize` of type `::IncompatibleChild` with compatible arity
+      │ Method types:
+      │   def initialize: (name: ::String) -> untyped
+      │
+      │ Diagnostic ID: Ruby::IncompatibleArguments
+      │
+      └     super()
+            ~~~~~~~

data/smoke/const/a.rb

@@ -1,7 +1,6 @@
 # @type const A: Integer
 # @type var x: String
 
-# !expects IncompatibleAssignment: lhs_type=::String, rhs_type=::Integer
 x = A
 
 x = B
@@ -12,7 +11,6 @@ module X
   def foo
     # @type var x: String
 
-    # !expects IncompatibleAssignment: lhs_type=::String, rhs_type=::Integer
     x = A
 
     x = B
@@ -22,7 +20,6 @@ end
 
 # @type const Foo::Bar::Baz: Integer
 
-# !expects IncompatibleAssignment: lhs_type=::String, rhs_type=::Integer
 x = Foo::Bar::Baz
 
 z = Foo

data/smoke/const/b.rb

@@ -0,0 +1,7 @@
+module Foo
+  module Bar
+    Baz = "Hello"
+
+    Baz2 = "World"
+  end
+end

data/smoke/const/b.rbs

@@ -0,0 +1,5 @@
+module Foo
+  module Bar
+    Baz: Integer
+  end
+end

data/smoke/const/test.yaml

@@ -0,0 +1,96 @@
+---
+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 = A
+        ~~~~~
+    - |
+      a.rb:6:4: [error] Cannot detect the type of the expression
+      │ Diagnostic ID: Ruby::FallbackAny
+      │
+      └ x = B
+            ~
+    - |
+      a.rb:8:7: [error] Cannot detect the type of the expression
+      │ Diagnostic ID: Ruby::FallbackAny
+      │
+      └ module X
+               ~
+    - |
+      a.rb:14: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
+      │
+      └     x = A
+            ~~~~~
+    - |
+      a.rb:16:8: [error] Cannot detect the type of the expression
+      │ Diagnostic ID: Ruby::FallbackAny
+      │
+      └     x = B
+                ~
+    - |
+      a.rb:23: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 = Foo::Bar::Baz
+        ~~~~~~~~~~~~~~~~~
+    - |
+      a.rb:26:4: [error] Cannot detect the type of the expression
+      │ Diagnostic ID: Ruby::FallbackAny
+      │
+      └ x = z::Bar::Baz
+            ~~~~~~
+    - |
+      a.rb:26:4: [error] Cannot detect the type of the expression
+      │ Diagnostic ID: Ruby::FallbackAny
+      │
+      └ x = z::Bar::Baz
+            ~~~~~~~~~~~
+    - |
+      a.rb:27: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 = ::Foo::Bar::Baz
+        ~~~~~~~~~~~~~~~~~~~
+  b.rb:
+    diagnostics:
+    - |
+      b.rb:3:4: [error] Cannot assign a value of type `::String` to a constant of type `::Integer`
+      │   ::String <: ::Integer
+      │     ::Object <: ::Integer
+      │       ::BasicObject <: ::Integer
+      │
+      │ Diagnostic ID: Ruby::IncompatibleAssignment
+      │
+      └     Baz = "Hello"
+            ~~~~~~~~~~~~~
+    - |
+      b.rb:5:4: [error] Cannot find the declaration of constant `Baz2`
+      │ Diagnostic ID: Ruby::UnknownConstantAssigned
+      │
+      └     Baz2 = "World"
+            ~~~~

data/smoke/diagnostics-rbs-duplicated/Steepfile

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

data/smoke/diagnostics-rbs-duplicated/a.rbs

@@ -0,0 +1,5 @@
+class A
+end
+
+module A
+end

data/smoke/diagnostics-rbs-duplicated/test.yaml

@@ -0,0 +1,10 @@
+---
+test:
+  a.rbs:
+    diagnostics:
+    - |
+      a.rbs:4:0: [error] Declaration of `::A` is duplicated
+      │ Diagnostic ID: Ruby::DuplicatedDeclaration
+      │
+      └ module A
+        ~~~~~~~~

data/smoke/diagnostics-rbs/Steepfile

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

data/smoke/diagnostics-rbs/duplicated-method-definition.rbs

@@ -0,0 +1,20 @@
+class DuplicatedMethodDefinitionError
+  def foo: () -> void
+  def foo: () -> Integer
+
+  interface _Hello
+    def f: () -> void
+
+    def f: () -> void
+  end
+
+  interface _A
+    def g: () -> void
+  end
+
+  class A
+    include _A
+
+    def g: () -> String
+  end
+end

data/smoke/diagnostics-rbs/generic-parameter-mismatch.rbs

@@ -0,0 +1,7 @@
+class GenericParameterMismatchError
+  class Foo[A]
+  end
+
+  class Foo[A, B]
+  end
+end

data/smoke/diagnostics-rbs/invalid-method-overload.rbs

@@ -0,0 +1,3 @@
+class InvalidMethodOverload
+  def foo: () -> void | ...
+end

data/smoke/diagnostics-rbs/invalid-type-application.rbs

@@ -0,0 +1,7 @@
+class InvalidTypeApplication
+  type foo = Integer[3]
+
+  type bar = Array[1, 2]
+
+  type baz = Hash
+end

data/smoke/diagnostics-rbs/invalid_variance_annotation.rbs

@@ -0,0 +1,3 @@
+class InvalidVarianceAnnotationError[out A]
+  def foo: (A) -> void
+end

data/smoke/diagnostics-rbs/recursive-alias.rbs

@@ -0,0 +1,5 @@
+class RecursiveAlias
+  alias foo bar
+  alias bar baz
+  alias baz foo
+end

data/smoke/diagnostics-rbs/recursive-class.rbs

@@ -0,0 +1,8 @@
+class Foo < Bar
+end
+
+class Bar < Baz
+end
+
+class Baz < Foo
+end

data/smoke/diagnostics-rbs/superclass-mismatch.rbs

@@ -0,0 +1,7 @@
+class SuperclassMismatch
+  class Foo < String
+  end
+
+  class Foo < Integer
+  end
+end

data/smoke/diagnostics-rbs/test.yaml

@@ -0,0 +1,142 @@
+---
+test:
+  duplicated-method-definition.rbs:
+    diagnostics:
+    - |
+      duplicated-method-definition.rbs:2:2: [error] Non-overloading method definition of `foo` in `::DuplicatedMethodDefinitionError` cannot be duplicated
+      │ Diagnostic ID: Ruby::DuplicatedMethodDefinition
+      │
+      └   def foo: () -> void
+          ~~~~~~~~~~~~~~~~~~~
+    - |
+      duplicated-method-definition.rbs:18:4: [error] Non-overloading method definition of `g` in `::DuplicatedMethodDefinitionError::A` cannot be duplicated
+      │ Diagnostic ID: Ruby::DuplicatedMethodDefinition
+      │
+      └     def g: () -> String
+            ~~~~~~~~~~~~~~~~~~~
+    - |
+      duplicated-method-definition.rbs:6:4: [error] Non-overloading method definition of `f` in `::DuplicatedMethodDefinitionError::_Hello` cannot be duplicated
+      │ Diagnostic ID: Ruby::DuplicatedMethodDefinition
+      │
+      └     def f: () -> void
+            ~~~~~~~~~~~~~~~~~
+  generic-parameter-mismatch.rbs:
+    diagnostics:
+    - |
+      generic-parameter-mismatch.rbs:5:2: [error] Different generic parameters are specified across definitions of `::GenericParameterMismatchError::Foo`
+      │ Diagnostic ID: Ruby::GenericParameterMismatch
+      │
+      └   class Foo[A, B]
+          ~~~~~~~~~~~~~~~
+  invalid-method-overload.rbs:
+    diagnostics:
+    - |
+      invalid-method-overload.rbs:2:2: [error] Cannot find a non-overloading definition of `foo` in `::InvalidMethodOverload`
+      │ Diagnostic ID: Ruby::InvalidMethodOverload
+      │
+      └   def foo: () -> void | ...
+          ~~~~~~~~~~~~~~~~~~~~~~~~~
+  invalid-type-application.rbs:
+    diagnostics:
+    - |
+      invalid-type-application.rbs:2:13: [error] Type `::Integer` is not generic but used as a generic type with 1 arguments
+      │ Diagnostic ID: Ruby::InvalidTypeApplication
+      │
+      └   type foo = Integer[3]
+                     ~~~~~~~~~~
+    - |
+      invalid-type-application.rbs:4:13: [error] Type `::Array` expects 1 arguments, but 2 arguments are given
+      │ Diagnostic ID: Ruby::InvalidTypeApplication
+      │
+      └   type bar = Array[1, 2]
+                     ~~~~~~~~~~~
+    - |
+      invalid-type-application.rbs:6:13: [error] Type `::Hash` is generic but used as a non generic type
+      │ Diagnostic ID: Ruby::InvalidTypeApplication
+      │
+      └   type baz = Hash
+                     ~~~~
+  invalid_variance_annotation.rbs:
+    diagnostics:
+    - |
+      invalid_variance_annotation.rbs:2:11: [error] The variance of type parameter `A` is covariant, but used in incompatible position here
+      │ Diagnostic ID: Ruby::InvalidVarianceAnnotation
+      │
+      └   def foo: (A) -> void
+                   ~~~~~~~~~~~
+  recursive-alias.rbs:
+    diagnostics:
+    - |
+      recursive-alias.rbs:2:2: [error] Circular method alias is detected in `::RecursiveAlias`: foo -> bar -> baz
+      │ Diagnostic ID: Ruby::RecursiveAlias
+      │
+      └   alias foo bar
+          ~~~~~~~~~~~~~
+  recursive-class.rbs:
+    diagnostics:
+    - |
+      recursive-class.rbs:1:0: [error] Circular inheritance/mix-in is detected: ::Foo <: ::Bar <: ::Baz <: ::Foo
+      │ Diagnostic ID: Ruby::RecursiveAncestor
+      │
+      └ class Foo < Bar
+        ~~~~~~~~~~~~~~~
+    - |
+      recursive-class.rbs:4:0: [error] Circular inheritance/mix-in is detected: ::Bar <: ::Baz <: ::Foo <: ::Bar
+      │ Diagnostic ID: Ruby::RecursiveAncestor
+      │
+      └ class Bar < Baz
+        ~~~~~~~~~~~~~~~
+    - |
+      recursive-class.rbs:7:0: [error] Circular inheritance/mix-in is detected: ::Baz <: ::Foo <: ::Bar <: ::Baz
+      │ Diagnostic ID: Ruby::RecursiveAncestor
+      │
+      └ class Baz < Foo
+        ~~~~~~~~~~~~~~~
+  superclass-mismatch.rbs:
+    diagnostics:
+    - |
+      superclass-mismatch.rbs:2:2: [error] Different superclasses are specified for `::SuperclassMismatch::Foo`
+      │ Diagnostic ID: Ruby::SuperclassMismatch
+      │
+      └   class Foo < String
+          ~~~~~~~~~~~~~~~~~~
+  unknown-method-alias.rbs:
+    diagnostics:
+    - |
+      unknown-method-alias.rbs:2:2: [error] Cannot find the original method `bar` in `::UnknownMethodAlias`
+      │ Diagnostic ID: Ruby::UnknownMethodAlias
+      │
+      └   alias foo bar
+          ~~~~~~~~~~~~~
+  unknown-type-name.rbs:
+    diagnostics:
+    - |
+      unknown-type-name.rbs:6:2: [error] Cannot find type `World`
+      │ Diagnostic ID: Ruby::UnknownTypeName
+      │
+      └   include World
+          ~~~~~~~~~~~~~
+    - |
+      unknown-type-name.rbs:8:2: [error] Cannot find type `ABC`
+      │ Diagnostic ID: Ruby::UnknownTypeName
+      │
+      └   class Foo < ABC
+          ~~~~~~~~~~~~~~~
+    - |
+      unknown-type-name.rbs:11:15: [error] Cannot find type `ZZZ`
+      │ Diagnostic ID: Ruby::UnknownTypeName
+      │
+      └   module Bar : ZZZ
+                       ~~~
+    - |
+      unknown-type-name.rbs:4:9: [error] Cannot find type `::World`
+      │ Diagnostic ID: Ruby::UnknownTypeName
+      │
+      └   Hello: World
+                 ~~~~~
+    - |
+      unknown-type-name.rbs:2:13: [error] Cannot find type `::bar`
+      │ Diagnostic ID: Ruby::UnknownTypeName
+      │
+      └   type foo = bar
+                     ~~~