steep 0.1.0.pre2 → 0.1.0

data/lib/steep.rb

@@ -1,33 +1,88 @@
 require "steep/version"
 
 require "pathname"
-require "parser/current"
 require "ast_utils"
+require "active_support/core_ext/object/try"
+require "logger"
+require "active_support/tagged_logging"
+require "rainbow"
+
+require "steep/module_name"
+require "steep/ast/location"
+require "steep/ast/types/helper"
+require "steep/ast/types/any"
+require "steep/ast/types/instance"
+require "steep/ast/types/class"
+require "steep/ast/types/union"
+require "steep/ast/types/var"
+require "steep/ast/types/name"
+require "steep/ast/types/self"
+require "steep/ast/types/intersection"
+require "steep/ast/types/void"
+require "steep/ast/types/bot"
+require "steep/ast/types/top"
+require "steep/ast/method_type"
+require "steep/ast/type_params"
+require "steep/ast/signature/class"
+require "steep/ast/signature/module"
+require "steep/ast/signature/members"
+require "steep/ast/signature/extension"
+require "steep/ast/signature/interface"
+require "steep/ast/signature/env"
+require "steep/ast/signature/const"
+require "steep/ast/signature/gvar"
+require "steep/ast/annotation"
+require "steep/ast/annotation/collection"
+require "steep/ast/buffer"
 
-require "steep/types"
 require "steep/type_name"
-require "steep/interface"
-require "steep/signature/class"
-require "steep/signature/interface"
+
+require "steep/interface/method_type"
+require "steep/interface/method"
+require "steep/interface/builder"
+require "steep/interface/substitution"
+require "steep/interface/abstract"
+require "steep/interface/instantiated"
+require "steep/interface/ivar_chain"
+
+require "steep/subtyping/check"
+require "steep/subtyping/result"
+require "steep/subtyping/relation"
+require "steep/subtyping/trace"
+require "steep/subtyping/constraints"
+require "steep/subtyping/variable_variance"
+require "steep/subtyping/variable_occurrence"
+
 require "steep/signature/errors"
-require "steep/signature/extension"
-require "steep/types/any"
-require "steep/types/name"
-require "steep/types/var"
-require "steep/types/union"
-require "steep/types/class"
-require "steep/types/instance"
-require "steep/types/merge"
-require "steep/type_assignability"
 require "steep/parser"
-require "steep/annotation"
 require "steep/source"
 require "steep/typing"
 require "steep/errors"
 require "steep/type_construction"
+require "steep/type_inference/send_args"
+require "steep/type_inference/block_params"
+require "steep/type_inference/constant_env"
+require "steep/type_inference/type_env"
 
+require "steep/drivers/utils/validator"
+require "steep/drivers/utils/each_signature"
 require "steep/drivers/check"
+require "steep/drivers/validate"
+require "steep/drivers/annotations"
+require "steep/drivers/scaffold"
+
+if ENV["NO_COLOR"]
+  Rainbow.enabled = false
+end
 
 module Steep
-  # Your code goes here...
+  def self.logger
+    unless @logger
+      @logger = ActiveSupport::TaggedLogging.new(Logger.new(STDERR))
+      @logger.push_tags "Steep #{VERSION}"
+      @logger.level = Logger::ERROR
+    end
+
+    @logger
+  end
 end

data/smoke/and/a.rb

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

data/smoke/array/a.rb

@@ -3,20 +3,19 @@
 a = []
 a[1] = 3
 
-# !expects ArgumentTypeMismatch: type=Array<Integer>, method=[]=
+# !expects ArgumentTypeMismatch: receiver=::Array<::Integer>, expected=::Integer, actual=::String
 a[2] = "foo"
 
 # @type var i: Integer
-# @type var s: String
-
 i = a[0]
 
-# !expects IncompatibleAssignment: lhs_type=String, rhs_type=Integer
+# @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
+# !expects IncompatibleAssignment: lhs_type=::Integer, rhs_type=::String
 i = b[1]

data/smoke/array/b.rb

@@ -1,16 +1,16 @@
 x = ""
 y = 1
 
-# !expects IncompatibleAssignment: lhs_type=String, rhs_type=Integer
+# !expects IncompatibleAssignment: lhs_type=::String, rhs_type=::Integer
 x = y
-# !expects IncompatibleAssignment: lhs_type=Integer, rhs_type=String
+# !expects IncompatibleAssignment: lhs_type=::Integer, rhs_type=::String
 y = x
 
 # @type var a: Array<Integer>
 # @type var b: Array<String>
 
 a = []
-# !expects IncompatibleAssignment: lhs_type=Array<String>, rhs_type=Array<Integer>
+# !expects IncompatibleAssignment: lhs_type=::Array<::String>, rhs_type=::Array<::Integer>
 b = a
-# !expects IncompatibleAssignment: lhs_type=Array<Integer>, rhs_type=Array<String>
+# !expects IncompatibleAssignment: lhs_type=::Array<::Integer>, rhs_type=::Array<::String>
 a = b

data/smoke/block/a.rb

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

data/smoke/block/a.rbi

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

data/smoke/block/b.rb

@@ -0,0 +1,15 @@
+# @type var a: A
+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
+end

data/smoke/case/a.rb

@@ -1,6 +1,6 @@
 # @type var a: Integer
 
-# !expects IncompatibleAssignment: lhs_type=Integer, rhs_type=Integer | Array<String> | String
+# !expects IncompatibleAssignment: lhs_type=::Integer, rhs_type=(::Array<::String> | ::Integer | ::NilClass | ::String)
 a = case 1
     when 2
       1
@@ -14,7 +14,7 @@ a = case 1
     end
 
 a = case
-    # !expects ArgumentTypeMismatch: type=Integer, method=+
+    # !expects ArgumentTypeMismatch: receiver=::Integer, expected=::Integer, actual=::String
     when 1+"a"
-      nil
+      (_ = nil)
     end

data/smoke/class/a.rb

@@ -8,13 +8,13 @@ class A
   end
 
   # A#bar is defined but the implementation is incompatible.
-  # !expects MethodParameterTypeMismatch: method=bar
+  # !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
+  # !expects MethodBodyTypeMismatch: method=to_s, expected=::String, actual=::Integer
   def to_s
     3
   end
@@ -24,7 +24,7 @@ class A
     5
   end
 
-  # !expects MethodBodyTypeMismatch: method=self.baz, expected=Integer, actual=String
+  # !expects MethodBodyTypeMismatch: method=self.baz, expected=::Integer, actual=::String
   def self.baz
     "baz"
   end

data/smoke/class/b.rb

@@ -2,6 +2,4 @@
 # @var type a: Integer
 
 s = "".class.allocate
-
-# !expects IncompatibleAssignment: lhs_type=String, rhs_type=Integer
 s = 3.class.allocate

data/smoke/class/d.rb

@@ -2,8 +2,8 @@
 # @type const B: A.class constructor
 # @type const C: A.class noconstructor
 
-# !expects NoMethodError: type=A.module, method=new
+# !expects NoMethodError: type=::A.class, method=new
 a = A.new
 b = B.new
-# !expects NoMethodError: type=A.module noconstructor, method=new
+# !expects NoMethodError: type=::A.class noconstructor, method=new
 c = C.new

data/smoke/class/e.rb

@@ -6,7 +6,7 @@ class C
   end
 
   def bar
-    # !expects NoMethodError: type=C.module noconstructor, method=new
+    # !expects NoMethodError: type=C.class noconstructor, method=new
     self.class.new
   end
 end

data/smoke/class/f.rb

@@ -1,8 +1,8 @@
 # @type var e: E
 # @type var d: D
 
-e = nil
-d = nil
+e = (_ = nil)
+d = (_ = nil)
 
 e = d
 d = e

data/smoke/class/g.rb

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

data/smoke/const/a.rb

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

data/smoke/dstr/a.rb

@@ -2,5 +2,5 @@
 
 a = 0
 
-# !expects NoMethodError: type=Integer, method=foo
+# !expects NoMethodError: type=::Integer, method=foo
 b = "Hello #{a.foo} world!"

data/smoke/ensure/a.rb

@@ -0,0 +1,22 @@
+# @type var a: Integer
+# @type var b: Integer
+
+# !expects IncompatibleAssignment: lhs_type=::Integer, rhs_type=::String
+a = begin
+      'foo'
+    ensure
+      # !expects IncompatibleAssignment: lhs_type=::Integer, rhs_type=::Symbol
+      b = :foo
+      1
+    end
+
+# @type method foo: (String) -> String
+
+# !expects MethodBodyTypeMismatch: method=foo, expected=::String, actual=::Integer
+def foo(a)
+  10
+ensure
+  # !expects ArgumentTypeMismatch: receiver=::Integer, expected=::Integer, actual=::String
+  1 + '1'
+  a
+end

data/smoke/enumerator/a.rb

@@ -2,18 +2,18 @@
 
 a = [1]
 
-# !expects IncompatibleAssignment: lhs_type=Hash<Symbol, String>, rhs_type=String
+# !expects IncompatibleAssignment: lhs_type=::Hash<::Symbol, ::String>, rhs_type=::String
 hash = a.each.with_object("") do |x, y|
-  # !expects IncompatibleAssignment: lhs_type=Hash<Symbol, String>, rhs_type=Integer
+  # !expects IncompatibleAssignment: lhs_type=::Hash<::Symbol, ::String>, rhs_type=::Integer
   hash = x
-  # !expects IncompatibleAssignment: lhs_type=Hash<Symbol, String>, rhs_type=String
+  # !expects IncompatibleAssignment: lhs_type=::Hash<::Symbol, ::String>, rhs_type=::String
   hash = y
 end
 
-# !expects IncompatibleAssignment: lhs_type=Hash<Symbol, String>, rhs_type=Array<Integer>
+# !expects IncompatibleAssignment: lhs_type=::Hash<::Symbol, ::String>, rhs_type=::Array<::Integer>
 hash = a.each.with_index do |x, y|
-  # !expects IncompatibleAssignment: lhs_type=Hash<Symbol, String>, rhs_type=Integer
+  # !expects IncompatibleAssignment: lhs_type=::Hash<::Symbol, ::String>, rhs_type=::Integer
   hash = x
-  # !expects IncompatibleAssignment: lhs_type=Hash<Symbol, String>, rhs_type=Integer
+  # !expects IncompatibleAssignment: lhs_type=::Hash<::Symbol, ::String>, rhs_type=::Integer
   hash = y
 end

data/smoke/enumerator/b.rb

@@ -0,0 +1,22 @@
+# @type var b: Array<String>
+# @type var c: Array<Integer>
+
+a = [1]
+
+# !expects* UnsatisfiableConstraint:
+b = a.each.with_object([]) do |i, xs|
+  # @type var xs: String
+  xs << i.to_s
+end
+
+# !expects IncompatibleAssignment: lhs_type=::Array<::Integer>, rhs_type=::Array<::String>
+c = a.each.with_object([]) do |i, xs|
+  # @type var xs: Array<String>
+  xs << i.to_s
+end
+
+# @type var d: String
+# !expects IncompatibleAssignment: lhs_type=::String, rhs_type=::Array<any>
+d = a.each.with_object([]) do |i, xs|
+  xs << i.to_s
+end

data/smoke/extension/a.rb

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

data/smoke/extension/b.rb

@@ -1,12 +1,12 @@
 # @type var foo: Foo
-foo = nil
+foo = (_ = nil)
 
 # @type var integer: Integer
 
 # Foo#f returns String because overridden
-# !expects IncompatibleAssignment: lhs_type=Integer, rhs_type=String
+# !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
+# !expects IncompatibleAssignment: lhs_type=::Integer, rhs_type=::Object
 integer = "".f()

data/smoke/extension/c.rb

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

data/smoke/hello/hello.rb

@@ -1,8 +1,8 @@
 # @type var x: _Foo
 # @type var y: _Bar
 
-x = nil
-y = nil
+x = (_ = nil)
+y = (_ = nil)
 
 a = x.foo
 

data/smoke/if/a.rb

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

data/smoke/kwbegin/a.rb

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

data/smoke/literal/a.rb

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

data/smoke/method/a.rb

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

data/smoke/method/a.rbi

@@ -0,0 +1,4 @@
+class X
+  def foo: (String) -> Integer
+         | (Integer) -> String
+end

data/smoke/method/b.rb

@@ -0,0 +1,29 @@
+class A
+  # @implements X
+
+  # !expects*@+2 MethodDefinitionWithOverloading: method=foo, types=
+  # !expects MethodBodyTypeMismatch: method=foo, expected=(::Integer | ::String), actual=::Symbol
+  def foo(x)
+    :foobar
+  end
+end
+
+class B
+  # @implements X
+
+  # @type method foo: (::String | ::Integer) -> any
+  def foo(x)
+    3
+  end
+end
+
+class C
+  # @implements X
+
+  # @type method foo: (Symbol) -> Symbol
+
+  # !expects IncompatibleMethodTypeAnnotation: interface_method=::X.foo, annotation_method=foo
+  def foo(x)
+    :foo
+  end
+end

data/smoke/module/a.rb

@@ -2,7 +2,7 @@ module A
   # @implements A
 
   def count
-    # @type var n: Integer
+    # @type var n: ::Integer
     n = 0
 
     each do |_|
@@ -10,10 +10,10 @@ module A
     end
 
     # @type var s: String
-    # !expects IncompatibleAssignment: lhs_type=String, rhs_type=Integer
+    # !expects IncompatibleAssignment: lhs_type=::String, rhs_type=::Integer
     s = n
 
-    # !expects NoMethodError: type=Object + _Each<Integer> + A, method=foo
+    # !expects NoMethodError: type=(::A & ::Object & _Each<::Integer>), method=foo
     foo()
 
     n

data/smoke/module/a.rbi

@@ -5,3 +5,12 @@ end
 module A : _Each<Integer>
   def count: () -> Integer
 end
+
+module X
+  def foo: () -> Integer
+end
+
+module Palette
+  def self?.defacto_palette: -> Array<Array<Integer>>
+  def self.nestopia_palette: -> Array<Array<Integer>>
+end

data/smoke/module/b.rb

@@ -1,8 +1,8 @@
+# ALLOW FAILURE
+
 # @type var klass: Class<any>
 # @type var mod: Module
 
 3.is_a?(3.class)
 klass = 3.class
 mod = "".class
-
-

data/smoke/module/c.rb

@@ -18,6 +18,6 @@ module A
   # ok
   block_given?
 
-  # !expects NoMethodError: type=Module + A.module, method=no_such_method_in_module
+  # !expects NoMethodError: type=(::A.module & ::Module), method=no_such_method_in_module
   no_such_method_in_module
 end

data/smoke/module/d.rb

@@ -0,0 +1,5 @@
+# If there is a same name module definition, it automatically implements.
+
+# !expects MethodDefinitionMissing: module=::X, method=foo
+module X
+end

data/smoke/module/e.rb

@@ -0,0 +1,13 @@
+# If module has a @implements annotation, it wins
+
+module X
+  # @implements A
+
+  def count
+    3
+  end
+
+  def foo
+    "3"
+  end
+end