steep 0.39.0 → 0.40.0

data/smoke/diagnostics-rbs/unknown-method-alias.rbs

@@ -0,0 +1,3 @@
+class UnknownMethodAlias
+  alias foo bar
+end

data/smoke/diagnostics-rbs/unknown-type-name.rbs

@@ -0,0 +1,13 @@
+class UnknownTypeName
+  type foo = bar
+
+  Hello: World
+
+  include World
+
+  class Foo < ABC
+  end
+
+  module Bar : ZZZ
+  end
+end

data/smoke/diagnostics/Steepfile

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

data/smoke/diagnostics/a.rbs

@@ -0,0 +1,26 @@
+class BlockBodyTypeMismatch
+  def foo: () { () -> Integer } -> void
+end
+
+class MethodDefinitionMissing
+  def foo: () -> void
+end
+
+class UnexpectedDynamicMethod
+  def bar: () -> void
+end
+
+class UnknownConstantAssigned
+end
+
+class UnsatisfiableConstraint
+  def foo: [A, B] (A) { (A) -> void } -> B
+end
+
+class UnexpectedKeyword
+  def foo: (foo: Integer) -> void
+end
+
+class MissingKeyword
+  def foo: (?String, foo: Integer, ?bar: Symbol) -> void
+end

data/smoke/diagnostics/argument_type_mismatch.rb

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

data/smoke/diagnostics/block_body_type_mismatch.rb

@@ -0,0 +1 @@
+BlockBodyTypeMismatch.new.foo { "" }

data/smoke/diagnostics/block_type_mismatch.rb

@@ -0,0 +1,3 @@
+lam = -> (x,y,z) { x + y + z}
+
+123.tap(&lam)

data/smoke/diagnostics/break_type_mismatch.rb

@@ -0,0 +1 @@
+123.tap { break "" }

data/smoke/diagnostics/else_on_exhaustive_case.rb

@@ -0,0 +1,12 @@
+x = [1, ""].sample
+
+case x
+when Integer
+  "Integer"
+when String
+  "String"
+when nil
+  "nil"
+else
+  raise "Unexpected value"
+end

data/smoke/diagnostics/incompatible_annotation.rb

@@ -0,0 +1,6 @@
+a = [1,2,3]
+
+if 1
+  # @type var a: String
+  a + ""
+end

data/smoke/diagnostics/incompatible_argument.rb

@@ -0,0 +1 @@
+[123].at(1,2,3)

data/smoke/diagnostics/incompatible_assignment.rb

@@ -0,0 +1,8 @@
+# @type var x: String
+x = 3
+
+# @type const X: String
+X = 123
+
+# @type ivar @x: Integer
+@x = :foo

data/smoke/diagnostics/method_arity_mismatch.rb

@@ -0,0 +1,11 @@
+class MethodArityMismatch
+  # @type method foo: () -> void
+  def foo(x)
+
+  end
+
+  # @type method bar: (String) -> void
+  def self.bar
+
+  end
+end

data/smoke/diagnostics/method_body_type_mismatch.rb

@@ -0,0 +1,6 @@
+class MethodBodyTypeMismatch
+  # @type method foo: () -> Integer
+  def foo
+    ""
+  end
+end

data/smoke/diagnostics/method_definition_missing.rb

@@ -0,0 +1,2 @@
+class MethodDefinitionMissing
+end

data/smoke/diagnostics/method_return_type_annotation_mismatch.rb

@@ -0,0 +1,7 @@
+class MethodReturnTypeAnnotationMismatch
+  # @type method foo: () -> String
+  def foo
+    # @type return: Integer
+    123
+  end
+end

data/smoke/diagnostics/missing_keyword.rb

@@ -0,0 +1 @@
+MissingKeyword.new.foo bar: :bar

data/smoke/diagnostics/no_method.rb

@@ -0,0 +1 @@
+1.foo()

data/smoke/diagnostics/required_block_missing.rb

@@ -0,0 +1 @@
+123.tap()

data/smoke/diagnostics/return_type_mismatch.rb

@@ -0,0 +1,6 @@
+class ReturnTypeMismatch
+  # @type method foo: () -> String
+  def foo
+    return 30
+  end
+end

data/smoke/diagnostics/test.yaml

@@ -0,0 +1,333 @@
+---
+test:
+  argument_type_mismatch.rb:
+    diagnostics:
+    - |
+      argument_type_mismatch.rb:1:9: [error] Cannot pass a value of type `::String` as an argument of type `::int`
+      │   ::String <: ::int
+      │     ::String <: (::Integer | ::_ToInt)
+      │       ::String <: ::Integer
+      │         ::Object <: ::Integer
+      │           ::BasicObject <: ::Integer
+      │
+      │ Diagnostic ID: Ruby::ArgumentTypeMismatch
+      │
+      └ [123].at("")
+                 ~~
+  block_body_type_mismatch.rb:
+    diagnostics:
+    - |
+      block_body_type_mismatch.rb:1:30: [error] Cannot allow block body have type `::String` because declared as type `::Integer`
+      │   ::String <: ::Integer
+      │     ::Object <: ::Integer
+      │       ::BasicObject <: ::Integer
+      │
+      │ Diagnostic ID: Ruby::BlockBodyTypeMismatch
+      │
+      └ BlockBodyTypeMismatch.new.foo { "" }
+                                      ~~~~~~
+  block_type_mismatch.rb:
+    diagnostics:
+    - |
+      block_type_mismatch.rb:3:8: [error] Cannot pass a value of type `^(untyped, untyped, untyped) -> untyped` as a block-pass-argument of type `^(::Integer) -> void`
+      │   ^(untyped, untyped, untyped) -> untyped <: ^(::Integer) -> void
+      │
+      │ Diagnostic ID: Ruby::BlockTypeMismatch
+      │
+      └ 123.tap(&lam)
+                ~~~~
+  break_type_mismatch.rb:
+    diagnostics:
+    - |
+      break_type_mismatch.rb:1:10: [error] Cannot break with a value of type `::String` because type `::Integer` is assumed
+      │   ::String <: ::Integer
+      │     ::Object <: ::Integer
+      │       ::BasicObject <: ::Integer
+      │
+      │ Diagnostic ID: Ruby::BreakTypeMismatch
+      │
+      └ 123.tap { break "" }
+                  ~~~~~~~~
+  else_on_exhaustive_case.rb:
+    diagnostics:
+    - |
+      else_on_exhaustive_case.rb:11:2: [error] The branch is unreachable because the condition is exhaustive
+      │ Diagnostic ID: Ruby::ElseOnExhaustiveCase
+      │
+      └   raise "Unexpected value"
+          ~~~~~~~~~~~~~~~~~~~~~~~~
+  incompatible_annotation.rb:
+    diagnostics:
+    - |
+      incompatible_annotation.rb:5:2: [error] Type annotation about `a` is incompatible since ::String <: ::Array[::Integer] doesn't hold
+      │   ::String <: ::Array[::Integer]
+      │     ::Object <: ::Array[::Integer]
+      │       ::BasicObject <: ::Array[::Integer]
+      │
+      │ Diagnostic ID: Ruby::IncompatibleAnnotation
+      │
+      └   a + ""
+          ~~~~~~
+  incompatible_argument.rb:
+    diagnostics:
+    - |
+      incompatible_argument.rb:1:6: [error] Cannot find method `at` of type `::Array[::Integer]` with compatible arity
+      │ Method types:
+      │   def at: (::int) -> (::Integer | nil)
+      │
+      │ Diagnostic ID: Ruby::IncompatibleArguments
+      │
+      └ [123].at(1,2,3)
+              ~~
+  incompatible_assignment.rb:
+    diagnostics:
+    - |
+      incompatible_assignment.rb:2: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 = 3
+        ~~~~~
+    - |
+      incompatible_assignment.rb:5:0: [error] Cannot assign a value of type `::Integer` to a constant of type `::String`
+      │   ::Integer <: ::String
+      │     ::Numeric <: ::String
+      │       ::Object <: ::String
+      │         ::BasicObject <: ::String
+      │
+      │ Diagnostic ID: Ruby::IncompatibleAssignment
+      │
+      └ X = 123
+        ~~~~~~~
+    - |
+      incompatible_assignment.rb:8:0: [error] Cannot assign a value of type `::Symbol` to a variable of type `::Integer`
+      │   ::Symbol <: ::Integer
+      │     ::Object <: ::Integer
+      │       ::BasicObject <: ::Integer
+      │
+      │ Diagnostic ID: Ruby::IncompatibleAssignment
+      │
+      └ @x = :foo
+        ~~~~~~~~~
+  method_arity_mismatch.rb:
+    diagnostics:
+    - |
+      method_arity_mismatch.rb:3:9: [error] Method parameters are incompatible with declaration `() -> void`
+      │ Diagnostic ID: Ruby::MethodArityMismatch
+      │
+      └   def foo(x)
+                 ~~~
+    - |
+      method_arity_mismatch.rb:8:11: [error] Method parameters are incompatible with declaration `(::String) -> void`
+      │ Diagnostic ID: Ruby::MethodArityMismatch
+      │
+      └   def self.bar
+                   ~~~
+  method_body_type_mismatch.rb:
+    diagnostics:
+    - |
+      method_body_type_mismatch.rb:3: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 foo
+          ~~~~~~~
+  method_definition_missing.rb:
+    diagnostics:
+    - |
+      method_definition_missing.rb:1:6: [error] Cannot find implementation of method `::MethodDefinitionMissing#foo`
+      │ Diagnostic ID: Ruby::MethodDefinitionMissing
+      │
+      └ class MethodDefinitionMissing
+              ~~~~~~~~~~~~~~~~~~~~~~~
+  method_return_type_annotation_mismatch.rb:
+    diagnostics:
+    - |
+      method_return_type_annotation_mismatch.rb:3:2: [error] Annotation `@type return` specifies type `::Integer` where declared as type `::String`
+      │   ::Integer <: ::String
+      │     ::Numeric <: ::String
+      │       ::Object <: ::String
+      │         ::BasicObject <: ::String
+      │
+      │ Diagnostic ID: Ruby::MethodReturnTypeAnnotationMismatch
+      │
+      └   def foo
+          ~~~~~~~
+  missing_keyword.rb:
+    diagnostics:
+    - |
+      missing_keyword.rb:1:23: [error] Cannot omit required keywords: `foo`
+      │ Diagnostic ID: Ruby::MissingKeyword
+      │
+      └ MissingKeyword.new.foo bar: :bar
+                               ~~~~~~~~~
+  no_method.rb:
+    diagnostics:
+    - |
+      no_method.rb:1:2: [error] Type `::Integer` does not have method `foo`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └ 1.foo()
+          ~~~
+  required_block_missing.rb:
+    diagnostics:
+    - |
+      required_block_missing.rb:1:4: [error] The method cannot be called without a block
+      │ Diagnostic ID: Ruby::RequiredBlockMissing
+      │
+      └ 123.tap()
+            ~~~
+  return_type_mismatch.rb:
+    diagnostics:
+    - |
+      return_type_mismatch.rb:4:4: [error] The method cannot return a value of type `::Integer` because declared as type `::String`
+      │   ::Integer <: ::String
+      │     ::Numeric <: ::String
+      │       ::Object <: ::String
+      │         ::BasicObject <: ::String
+      │
+      │ Diagnostic ID: Ruby::ReturnTypeMismatch
+      │
+      └     return 30
+            ~~~~~~~~~
+  unexpected_block_given.rb:
+    diagnostics:
+    - |
+      unexpected_block_given.rb:1:10: [error] The method cannot be called with a block
+      │ Diagnostic ID: Ruby::UnexpectedBlockGiven
+      │
+      └ [1].at(1) { 123 }
+                  ~~~~~~~
+  unexpected_dynamic_method.rb:
+    diagnostics:
+    - |
+      unexpected_dynamic_method.rb:1:6: [error] @dynamic annotation contains unknown method name `foo`
+      │ Diagnostic ID: Ruby::UnexpectedDynamicMethod
+      │
+      └ class UnexpectedDynamicMethod
+              ~~~~~~~~~~~~~~~~~~~~~~~
+  unexpected_jump.rb:
+    diagnostics:
+    - |
+      unexpected_jump.rb:1:0: [error] Cannot jump from here
+      │ Diagnostic ID: Ruby::UnexpectedJump
+      │
+      └ break
+        ~~~~~
+    - |
+      unexpected_jump.rb:3:0: [error] Cannot jump from here
+      │ Diagnostic ID: Ruby::UnexpectedJump
+      │
+      └ next
+        ~~~~
+  unexpected_jump_value.rb:
+    diagnostics:
+    - |
+      unexpected_jump_value.rb:2:2: [error] The value given to break will be ignored
+      │ Diagnostic ID: Ruby::UnexpectedJumpValue
+      │
+      └   break 10
+          ~~~~~~~~
+  unexpected_keyword.rb:
+    diagnostics:
+    - |
+      unexpected_keyword.rb:1:26: [error] Cannot specify unexpected keyword arguments: `bar`
+      │ Diagnostic ID: Ruby::UnexpectedKeyword
+      │
+      └ UnexpectedKeyword.new.foo(foo: 123, bar: :bar)
+                                  ~~~~~~~~~~~~~~~~~~~
+  unexpected_splat.rb:
+    diagnostics:
+    - |
+      unexpected_splat.rb:1:13: [error] Hash splat is given with object other than `Hash[X, Y]`
+      │ Diagnostic ID: Ruby::UnexpectedSplat
+      │
+      └ { foo: :bar, **123 }
+                     ~~~~~
+  unexpected_yield.rb:
+    diagnostics:
+    - |
+      unexpected_yield.rb:4:4: [error] No block given for `yield`
+      │ Diagnostic ID: Ruby::UnexpectedYield
+      │
+      └     yield
+            ~~~~~
+    - |
+      unexpected_yield.rb:4:4: [error] Cannot detect the type of the expression
+      │ Diagnostic ID: Ruby::FallbackAny
+      │
+      └     yield
+            ~~~~~
+  unknown_constant_assigned.rb:
+    diagnostics:
+    - |
+      unknown_constant_assigned.rb:2:2: [error] Cannot find the declaration of constant `FOO`
+      │ Diagnostic ID: Ruby::UnknownConstantAssigned
+      │
+      └   FOO = 123
+          ~~~
+    - |
+      unknown_constant_assigned.rb:4:2: [error] Cannot detect the type of the expression
+      │ Diagnostic ID: Ruby::FallbackAny
+      │
+      └   FOO::BAR = 123
+          ~~~
+    - |
+      unknown_constant_assigned.rb:4:2: [error] Cannot find the declaration of constant `FOO::BAR`
+      │ Diagnostic ID: Ruby::UnknownConstantAssigned
+      │
+      └   FOO::BAR = 123
+          ~~~~~~~~
+    - |
+      unknown_constant_assigned.rb:6:2: [error] Cannot find the declaration of constant `::FOO`
+      │ Diagnostic ID: Ruby::UnknownConstantAssigned
+      │
+      └   ::FOO = :foo
+          ~~~~~
+  unresolved_overloading.rb:
+    diagnostics:
+    - |
+      unresolved_overloading.rb:1:0: [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 + ""
+        ~~~~~~
+  unsatisfiable_constraint.rb:
+    diagnostics:
+    - |
+      unsatisfiable_constraint.rb:6:4: [error] Type `::String` does not have method `foo`
+      │ Diagnostic ID: Ruby::NoMethod
+      │
+      └   x.foo()
+            ~~~
+    - |
+      unsatisfiable_constraint.rb:4:0: [error] Unsatisfiable constraint `::Array[untyped] <: A(1) <: ::String` is generated through (A(1)) { (A(1)) -> void } -> B(2)
+      │   ::Array[untyped] <: ::String
+      │     ::Object <: ::String
+      │       ::BasicObject <: ::String
+      │
+      │ Diagnostic ID: Ruby::UnsatisfiableConstraint
+      │
+      └ test.foo([]) do |x|
+        ~~~~~~~~~~~~~~~~~~~
+  unsupported_syntax.rb:
+    diagnostics:
+    - |
+      unsupported_syntax.rb:1:0: [error] sclass receiver must be instance type or singleton type, but type given `(::Integer | ::String | nil)`
+      │ Diagnostic ID: Ruby::UnsupportedSyntax
+      │
+      └ class <<[1, ""].sample
+        ~~~~~~~~~~~~~~~~~~~~~~