steep 0.1.0.pre

data/sig/signature.rbi

@@ -0,0 +1,54 @@
+class Steep__Signature__Error
+  def initialize: (signature: Steep__Signature) -> any
+  def signature: -> Steep__Signature
+end
+
+class Steep__Signature__Errors__UnknownTypeName <: Steep__Signature__Error
+  def initialize: (signature: Steep__Signature, type: Steep__Type) -> any
+  def type: -> Steep__Type
+end
+
+class Steep__MethodType
+  def substitute: (klass: Steep__Type, instance: Steep__Type, params: Hash<Symbol, Steep__Type>) -> Steep__MethodType
+end
+
+class Steep__Interface
+  def initialize: (name: Symbol, methods: Hash<Symbol, Steep__Method>) -> any
+end
+
+class Steep__Method
+  def initialize: (types: Array<Steep__MethodType>, super_method: Steep__Method) -> any
+  def substitute: (klass: Steep__Type, instance: Steep__Type, params: Hash<Symbol, Steep__Type>) -> Steep__Method
+end
+
+class Steep__Signature
+end
+
+class Steep__Signature__Member
+end
+
+class Steep__Signature__Errors__IncompatibleOverride <: Steep__Signature__Error
+  def initialize: (signature: Steep__Signature, method_name: Symbol, this_method: Steep__Method, super_method: Steep__Method) -> any
+  def method_name: -> Symbol
+  def this_method: -> Steep__Method
+  def super_method: -> Steep__Method
+end
+
+class Steep__Signature__Extension
+  def initialize: (module_name: Symbol, extension_name: Symbol, members: Array<Steep__Signature__Member>) -> any
+  def module_name: -> Symbol
+  def extension_name: -> Symbol
+  def members: -> Array<Steep__Signature__Member>
+  def name: -> Symbol
+end
+
+class Steep__Signature__Interface
+  def initialize: (name: Symbol, params: Array<Symbol>, methods: Hash<Symbol, Array<Steep__MethodType>>) -> any
+
+  def name: -> Symbol
+  def params: -> Array<Symbol>
+  def methods: -> Hash<Symbol, Array<Steep__MethodType>>
+
+  def to_interface: (klass: Steep__Type, instance: Steep__Type, params: Array<Steep__Type>) -> any
+  def validate: (any) -> any
+end

data/sig/types.rbi

@@ -0,0 +1,43 @@
+class Steep__TypeName
+  def initialize: (name: Symbol) -> any
+end
+
+class Steep__Type
+  def closed?: -> _Boolean
+  def substitute: (klass: Steep__Type, instance: Steep__Type, params: Hash<Symbol, Steep__Type>) -> instance
+end
+
+class Steep__Types__Name <: Steep__Type
+  def initialize: (name: Steep__TypeName, params: Array<Steep__Type>) -> any
+
+  def name: -> Steep__TypeName
+  def params: -> Array<Steep__Type>
+
+  def self.interface: (name: Symbol, ?params: Array<Steep__Type>) -> Steep__Types__Name
+  def self.module: (name: Symbol, ?params: Array<Steep__Type>) -> Steep__Types__Name
+  def self.instance: (name: Symbol, ?params: Array<Steep__Type>) -> Steep__Types__Name
+end
+
+class Steep__Types__Union <: Steep__Type
+  def initialize: (types: Array<Steep__Type>) -> any
+  def types: -> Array<Steep__Type>
+end
+
+class Steep__Types__Merge <: Steep__Type
+  def initialize: (types: Array<Steep__Type>) -> any
+  def types: -> Array<Steep__Type>
+end
+
+class Steep__Types__Var <: Steep__Type
+  def initialize: (name: Symbol) -> any
+  def name: -> Symbol
+end
+
+class Steep__Types__Instance <: Steep__Type
+end
+
+class Steep__Types__Class <: Steep__Type
+end
+
+class Steep__Types__Any <: Steep__Type
+end

data/smoke/and/a.rb

@@ -0,0 +1,9 @@
+# @type var b: String
+# @type var c: Integer
+
+a = "foo"
+
+b = a && a.to_str
+
+# !expects IncompatibleAssignment: lhs_type=Integer, rhs_type=String
+c = a && a.to_str

data/smoke/array/a.rb

@@ -0,0 +1,22 @@
+# @type var a: Array<Integer>
+
+a = []
+a[1] = 3
+
+# !expects ArgumentTypeMismatch: type=Array<Integer>, method=[]=
+a[2] = "foo"
+
+# @type var i: Integer
+# @type var s: String
+
+i = a[0]
+
+# !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/block/a.rb

@@ -0,0 +1,12 @@
+# @type var a: A
+
+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/a.rbi

@@ -0,0 +1,4 @@
+class A
+  def foo: { (String) -> any } -> String
+         | -> Integer
+end

data/smoke/case/a.rb

@@ -0,0 +1,20 @@
+# @type var a: Integer
+
+# !expects IncompatibleAssignment: lhs_type=Integer, rhs_type=Integer | Array<String> | String
+a = case 1
+    when 2
+      1
+    when 0, 100
+      ["String"]
+    when 3
+      nil
+    when 4
+    else
+      "string"
+    end
+
+a = case
+    # !expects ArgumentTypeMismatch: type=Integer, method=+
+    when 1+"a"
+      nil
+    end

data/smoke/class/a.rb

@@ -0,0 +1,31 @@
+class A
+  # @type instance: A
+  # @type module: A.class
+
+  # A#foo is defined and the implementation is compatible.
+  def foo(x)
+    x
+  end
+
+  # A#bar is defined but the implementation is incompatible.
+  # !expects MethodParameterTypeMismatch: 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
+
+  # No method definition given via signature, there is no type error.
+  def to_str
+    5
+  end
+
+  # !expects MethodBodyTypeMismatch: method=self.baz, expected=Integer, actual=String
+  def self.baz
+    "baz"
+  end
+end

data/smoke/class/a.rbi

@@ -0,0 +1,9 @@
+class A
+  def foo: (String) -> any
+  def bar: () -> String
+  def self.baz: -> Integer
+end
+
+class B
+  def name: -> String
+end

data/smoke/class/b.rb

@@ -0,0 +1,7 @@
+# @var type s: String
+# @var type a: Integer
+
+s = "".class.allocate
+
+# !expects IncompatibleAssignment: lhs_type=String, rhs_type=Integer
+s = 3.class.allocate

data/smoke/class/c.rb

@@ -0,0 +1,10 @@
+# !expects UnexpectedDynamicMethod: module=B, method=type
+class B
+  # @implements B
+
+  # @dynamic name
+  attr_reader :name
+
+  # @dynamic type
+  attr_reader :type
+end

data/smoke/const/a.rb

@@ -0,0 +1,30 @@
+# @type const A: Integer
+# @type var x: String
+
+# !expects IncompatibleAssignment: lhs_type=String, rhs_type=Integer
+x = A
+
+x = B
+
+module X
+  # @type const A: Integer
+
+  def foo
+    # @type var x: String
+
+    # !expects IncompatibleAssignment: lhs_type=String, rhs_type=Integer
+    x = A
+
+    x = B
+  end
+end
+
+
+# @type const Foo::Bar::Baz: Integer
+
+# !expects IncompatibleAssignment: lhs_type=String, rhs_type=Integer
+x = Foo::Bar::Baz
+
+z = Foo
+x = z::Bar::Baz
+x = ::Foo::Bar::Baz

data/smoke/dstr/a.rb

@@ -0,0 +1,6 @@
+# @type var b: String
+
+a = 0
+
+# !expects NoMethodError: type=Integer, method=foo
+b = "Hello #{a.foo} world!"

data/smoke/extension/a.rb

@@ -0,0 +1,11 @@
+# @type var foo: Foo
+
+foo = nil
+
+foo.try do |x|
+  # @type var string: String
+
+  # !expects IncompatibleAssignment: lhs_type=String, rhs_type=Foo
+  string = x
+end
+

data/smoke/extension/a.rbi

@@ -0,0 +1,8 @@
+extension Object (X)
+  def try: <'a> { (instance) -> 'a } -> 'a
+  def f: -> Object
+end
+
+class Foo
+  def f: -> String
+end

data/smoke/extension/b.rb

@@ -0,0 +1,12 @@
+# @type var foo: Foo
+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

@@ -0,0 +1,9 @@
+class Foo
+  # @implements Foo
+
+  def f()
+    # @type var string: String
+    # !expects IncompatibleAssignment: lhs_type=String, rhs_type=Object
+    string = super()
+  end
+end

data/smoke/hello/hello.rb

@@ -0,0 +1,13 @@
+# @type var x: _Foo
+# @type var y: _Bar
+
+x = nil
+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/hello.rbi

@@ -0,0 +1,7 @@
+interface _Foo
+  def foo: -> any
+end
+
+interface _Bar
+  def bar: -> any
+end

data/smoke/if/a.rb

@@ -0,0 +1,20 @@
+# @type var a: String
+
+# !expects IncompatibleAssignment: lhs_type=String, rhs_type=Symbol
+a = if x
+      :foo
+    end
+
+if y
+  :foo
+else
+  "baz"
+end
+
+# !expects IncompatibleAssignment: lhs_type=String, rhs_type=String | Integer
+a = if z
+      "foofoo"
+    else
+      3
+    end
+

data/smoke/implements/a.rb

@@ -0,0 +1,14 @@
+# !expects@+2 MethodDefinitionMissing: module=A, method=baz
+# !expects MethodDefinitionMissing: module=A, method=self.bar
+class A
+  # @implements A
+
+  def foo()
+  end
+
+  def bar()
+  end
+
+  def self.baz
+  end
+end

data/smoke/implements/a.rbi

@@ -0,0 +1,6 @@
+class A
+  def foo: -> any
+  def baz: -> any
+  def self.bar: -> any
+  def self.baz: -> any
+end

data/smoke/literal/a.rb

@@ -0,0 +1,16 @@
+# @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=_Boolean
+x = true
+# !expects IncompatibleAssignment: lhs_type=Integer, rhs_type=_Boolean
+y = false

data/smoke/map/a.rb

@@ -0,0 +1,5 @@
+a = [1,2,3]
+
+# @type var b: Array<Integer>
+
+b = a.map {|x| x.to_i }

data/smoke/method/a.rb

@@ -0,0 +1,26 @@
+# @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
+end
+
+# @type method bar: (Integer) -> String
+
+# !expects MethodParameterTypeMismatch: method=bar
+def bar(x, y)
+  # @type var z: String
+
+  # !expects IncompatibleAssignment: lhs_type=String, rhs_type=Integer
+  z = x
+
+  z = y
+end