steep 0.11.1 → 0.12.0

data/lib/steep/type_inference/constant_env.rb

@@ -1,20 +1,18 @@
 module Steep
   module TypeInference
     class ConstantEnv
-      attr_reader :builder
       attr_reader :context
       attr_reader :cache
+      attr_reader :factory
+      attr_reader :table
 
-      # ConstantEnv receives an optional Names::Module, not a Namespace, because this is a simulation of Ruby.
+      # ConstantEnv receives an Names::Module as a context, not a Namespace, because this is a simulation of Ruby.
       # Any namespace is a module or class.
-      def initialize(builder:, context:)
+      def initialize(factory:, context:)
         @cache = {}
-        @builder = builder
+        @factory = factory
         @context = context
-      end
-
-      def signatures
-        builder.signatures
+        @table = Ruby::Signature::ConstantTable.new(builder: factory.definition_builder)
       end
 
       def namespace
@@ -26,24 +24,18 @@ module Steep
       end
 
       def lookup(name)
-        cache[name] ||= lookup0(name, namespace: namespace)
-      end
+        cache[name] ||= begin
+          constant = table.resolve_constant_reference(
+            factory.type_name_1(name),
+            context: factory.namespace_1(namespace)
+          )
 
-      # @type method lookup0: (Names::Module, namespace: AST::Namespace) -> Type
-      def lookup0(name, namespace:)
-        full_name = name.in_namespace(namespace)
-        case
-        when signatures.module_name?(full_name)
-          AST::Types::Name::Module.new(name: full_name)
-        when signatures.class_name?(full_name)
-          AST::Types::Name::Class.new(name: full_name, constructor: true)
-        when signatures.const_name?(full_name)
-          builder.absolute_type(signatures.find_const(name, current_module: namespace).type,
-                                current: namespace)
-        else
-          unless namespace.empty?
-            lookup0(name, namespace: namespace.parent)
+          if constant
+            factory.type(constant.type)
           end
+        rescue => exn
+          Steep.logger.error "Looking up a constant failed: name=#{name}, context=#{context}, error=#{exn.inspect}"
+          nil
         end
       end
     end

data/lib/steep/type_inference/type_env.rb

@@ -37,23 +37,27 @@ module Steep
           annotations.const_types.each do |name, type|
             env.set(const: name, type: type)
           end
-          signatures.globals.each do |name, annot|
-            type = subtyping.builder.absolute_type(annot.type, current: AST::Namespace.root)
-            env.set(gvar: name, type: type)
+          signatures.name_to_global.each do |name, global|
+            type = signatures.absolute_type(global.type, namespace: Ruby::Signature::Namespace.root) {|ty| ty.name.absolute! }
+            env.set(gvar: name, type: subtyping.factory.type(type))
           end
         end
       end
 
-      def with_annotations(lvar_types: {}, ivar_types: {}, const_types: {}, gvar_types: {}, &block)
+      def with_annotations(lvar_types: {}, ivar_types: {}, const_types: {}, gvar_types: {}, self_type:, &block)
         dup.tap do |env|
-          merge!(original_env: env.lvar_types, override_env: lvar_types, &block)
-          merge!(original_env: env.ivar_types, override_env: ivar_types, &block)
-          merge!(original_env: env.gvar_types, override_env: gvar_types, &block)
+          merge!(original_env: env.lvar_types, override_env: lvar_types, self_type: self_type, &block)
+          merge!(original_env: env.ivar_types, override_env: ivar_types, self_type: self_type, &block)
+          merge!(original_env: env.gvar_types, override_env: gvar_types, self_type: self_type, &block)
 
           const_types.each do |name, annotated_type|
             original_type = self.const_types[name] || const_env.lookup(name)
             if original_type
-              assert_annotation name, original_type: original_type, annotated_type: annotated_type, &block
+              assert_annotation name,
+                                original_type: original_type,
+                                annotated_type: annotated_type,
+                                self_type: self_type,
+                                &block
             end
             env.const_types[name] = annotated_type
           end
@@ -142,14 +146,14 @@ module Steep
       #                    | (gvar: Symbol, type: AST::Type) { (Subtyping::Result::Failure | nil) -> void } -> AST::Type
       #                    | (ivar: Symbol, type: AST::Type) { (Subtyping::Result::Failure | nil) -> void } -> AST::Type
       #                    | (lvar: Symbol | LabeledName, type: AST::Type) { (Subtyping::Result::Failure) -> void } -> AST::Type
-      def assign(lvar: nil, const: nil, gvar: nil, ivar: nil, type:, &block)
+      def assign(lvar: nil, const: nil, gvar: nil, ivar: nil, type:, self_type:, &block)
         case
         when lvar
           yield_self do
             name = lvar_name(lvar)
             var_type = lvar_types[name]
             if var_type
-              assert_assign(var_type: var_type, lhs_type: type, &block)
+              assert_assign(var_type: var_type, lhs_type: type, self_type: self_type, &block)
             else
               lvar_types[name] = type
             end
@@ -158,7 +162,7 @@ module Steep
           yield_self do
             const_type = const_types[const] || const_env.lookup(const)
             if const_type
-              assert_assign(var_type: const_type, lhs_type: type, &block)
+              assert_assign(var_type: const_type, lhs_type: type, self_type: self_type, &block)
             else
               yield nil
               AST::Types::Any.new
@@ -167,7 +171,7 @@ module Steep
         else
           lookup_dictionary(ivar: ivar, gvar: gvar) do |var_name, dictionary|
             if dictionary.key?(var_name)
-              assert_assign(var_type: dictionary[var_name], lhs_type: type, &block)
+              assert_assign(var_type: dictionary[var_name], lhs_type: type, self_type: self_type, &block)
             else
               yield nil
               AST::Types::Any.new
@@ -194,34 +198,38 @@ module Steep
         end
       end
 
-      def assert_assign(var_type:, lhs_type:)
+      def assert_assign(var_type:, lhs_type:, self_type:)
+        return var_type if var_type == lhs_type
+
         var_type = subtyping.expand_alias(var_type)
         lhs_type = subtyping.expand_alias(lhs_type)
 
         relation = Subtyping::Relation.new(sub_type: lhs_type, super_type: var_type)
         constraints = Subtyping::Constraints.new(unknowns: Set.new)
 
-        subtyping.check(relation, constraints: constraints).else do |result|
+        subtyping.check(relation, self_type: self_type, constraints: constraints).else do |result|
           yield result
         end
 
         var_type
       end
 
-      def merge!(original_env:, override_env:, &block)
+      def merge!(original_env:, override_env:, self_type:, &block)
         original_env.merge!(override_env) do |name, original_type, override_type|
-          assert_annotation name, annotated_type: override_type, original_type: original_type, &block
+          assert_annotation name, annotated_type: override_type, original_type: original_type, self_type: self_type, &block
         end
       end
 
-      def assert_annotation(name, annotated_type:, original_type:)
+      def assert_annotation(name, annotated_type:, original_type:, self_type:)
+        return annotated_type if annotated_type == original_type
+
         annotated_type = subtyping.expand_alias(annotated_type)
         original_type = subtyping.expand_alias(original_type)
 
         relation = Subtyping::Relation.new(sub_type: annotated_type, super_type: original_type)
         constraints = Subtyping::Constraints.new(unknowns: Set.new)
 
-        subtyping.check(relation, constraints: constraints).else do |result|
+        subtyping.check(relation, constraints: constraints, self_type: self_type).else do |result|
           yield name, relation, result
         end
 

data/lib/steep/version.rb

@@ -1,3 +1,3 @@
 module Steep
-  VERSION = "0.11.1"
+  VERSION = "0.12.0"
 end

data/sample/Steepfile

@@ -0,0 +1,6 @@
+target :app do
+  check "lib"
+  signature "sig"
+
+  library "set", "pathname"
+end

data/sample/lib/conference.rb

@@ -0,0 +1,12 @@
+class Conference
+  # @dynamic title, year
+  attr_reader :title
+  attr_reader :year
+
+  def initialize(title:, year:)
+    @title = title
+    @year = year
+  end
+end
+
+Conference.new()

data/sample/sig/conference.rbs

@@ -0,0 +1,6 @@
+class Conference
+  attr_reader title: String
+  attr_reader year: Integer
+
+  def initialize: (title: String, year: Integer) -> void
+end

data/smoke/alias/Steepfile

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

data/smoke/alias/a.rb

@@ -1,10 +1,10 @@
 # @type var x: foo
 x = ""
 
-# !expects NoMethodError: type=::foo, method=+
+# !expects ArgumentTypeMismatch: receiver=(::Integer | ::String), expected=::String, actual=::Integer
 x + 123
 
-# @type var y: bar<Integer>
+# @type var y: bar
 y = x
 y = []
 

data/smoke/alias/{a.rbi → a.rbs}

@@ -1,5 +1,5 @@
 type foo = String | Integer
-type bar<'a> = Array<'a> | foo
+type bar = Array[Integer] | foo
 type baz = [String, Symbol]
 
 type name = :foo | :bar

data/smoke/and/Steepfile

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

data/smoke/array/Steepfile

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

data/smoke/array/a.rb

@@ -1,9 +1,9 @@
-# @type var a: Array<Integer>
+# @type var a: Array[Integer]
 
 a = []
 a[1] = 3
 
-# !expects ArgumentTypeMismatch: receiver=::Array<::Integer>, expected=::Integer, actual=::String
+# !expects* UnresolvedOverloading: receiver=::Array[::Integer], method_name=[]=,
 a[2] = "foo"
 
 # @type var i: Integer

data/smoke/array/b.rb

@@ -6,11 +6,11 @@ x = y
 # !expects IncompatibleAssignment: lhs_type=::Integer, rhs_type=::String
 y = x
 
-# @type var a: Array<Integer>
-# @type var b: Array<String>
+# @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/array/c.rb

@@ -1,7 +1,7 @@
-# @type var x: Array<String?>
+# @type var x: Array[String?]
 
 x = ["foo"]
 x = [nil]
 
-# !expects IncompatibleAssignment: lhs_type=::Array<(::String | nil)>, rhs_type=::Array<::Integer>
+# !expects IncompatibleAssignment: lhs_type=::Array[(::String | nil)], rhs_type=::Array[::Integer]
 x = [1]

data/smoke/block/Steepfile

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

data/smoke/block/{a.rbi → a.rbs}

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

data/smoke/block/d.rb

@@ -1,15 +1,15 @@
 # @type var a: ^(Integer) -> String
 a = -> (x) { x.to_s }
 
-# @type var b: Array<Float>
+# @type var b: Array[Float]
 
-# !expects IncompatibleAssignment: lhs_type=::Array<::Float>, rhs_type=::Array<::String>
+# !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>
+# !expects IncompatibleAssignment: lhs_type=::Array[::Float], rhs_type=::Array[::String]
 b = [1,2,3].map(&:to_s)
 
-# !expects* BlockTypeMismatch:
+# !expects* UnresolvedOverloading: receiver=::Array[::Integer], method_name=map,
 [1,2,3].map(&:no_such_method)
-# !expects* BlockTypeMismatch:
-[1,2,3].map(&:floor)
+# !expects* UnresolvedOverloading: receiver=::Array[::Integer], method_name=map,
+[1,2,3].map(&:divmod)

data/smoke/case/Steepfile

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

data/smoke/case/a.rb

@@ -1,6 +1,6 @@
 # @type var a: Integer
 
-# !expects IncompatibleAssignment: lhs_type=::Integer, rhs_type=(::Array<::String> | ::Integer | ::String | nil)
+# !expects IncompatibleAssignment: lhs_type=::Integer, rhs_type=(::Array[::String] | ::Integer | ::String | nil)
 a = case 1
     when 2
       1
@@ -13,8 +13,9 @@ a = case 1
       "string"
     end
 
+# !expects IncompatibleAssignment: lhs_type=::Integer, rhs_type=(::Integer | nil)
 a = case
-    # !expects ArgumentTypeMismatch: receiver=::Integer, expected=::Integer, actual=::String
+    # !expects* UnresolvedOverloading: receiver=::Integer, method_name=+,
     when 1+"a"
-      (_ = nil)
+      30
     end

data/smoke/class/Steepfile

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

data/smoke/class/a.rb

@@ -1,10 +1,7 @@
 class A
-  # @type instance: A
-  # @type module: A.class
-
   # A#foo is defined and the implementation is compatible.
   def foo(x)
-    x
+    x + ""
   end
 
   # A#bar is defined but the implementation is incompatible.

data/smoke/class/a.rbs

@@ -0,0 +1,24 @@
+class A
+  def foo: (String) -> untyped
+  def bar: () -> String
+  def self.baz: -> Integer
+end
+
+class B
+  def name: -> String
+end
+
+class C
+  def foo: -> instance
+  def bar: -> instance
+end
+
+class D
+  def initialize: (String) -> untyped
+  def foo: -> untyped
+end
+
+class E
+  def initialize: () -> untyped
+  def foo: -> untyped
+end

data/smoke/class/h.rb

@@ -7,9 +7,13 @@ class WithSingletonConstructor
   end
 
   def self.create()
-    new(foo: "hoge")
+    instance = new(foo: "hoge")
+
+    instance.foo
+
+    _ = instance
   end
 
   new(foo: "hoge")
-  create()
+  create().foo
 end

data/smoke/class/{h.rbi → h.rbs}

@@ -1,7 +1,6 @@
 class WithSingletonConstructor
   attr_reader foo: String
 
-  def initialize: (foo: String) -> any
+  def initialize: (foo: String) -> void
   def self.create: -> instance
 end
-

data/smoke/class/i.rb

@@ -8,10 +8,9 @@ class IncompatibleChild
   end
 
   def initialize()
-    # !expects IncompatibleArguments: receiver=::IncompatibleChild, method_type=(name: ::String) -> any
+    # !expects IncompatibleArguments: receiver=::IncompatibleChild, method_type=(name: ::String) -> untyped
     super()
 
-    # !expects IncompatibleZuper: method=initialize
     super
   end
 end