steep 0.40.0 → 0.44.0

data/lib/steep/type_inference/block_params.rb

@@ -61,7 +61,7 @@ module Steep
             return
           end
 
-          type = annotations.var_type(lvar: var.name)
+          type = annotations.var_type(lvar: var)
 
           case arg.type
           when :arg, :procarg0

data/lib/steep/type_inference/context.rb

@@ -78,6 +78,28 @@ module Steep
             end
           end
         end
+
+        def update(
+          instance_type: self.instance_type,
+          module_type: self.module_type,
+          implement_name: self.implement_name,
+          current_namespace: self.current_namespace,
+          const_env: self.const_env,
+          class_name: self.class_name,
+          instance_definition: self.instance_definition,
+          module_definition: self.module_definition
+        )
+          ModuleContext.new(
+            instance_type: instance_type,
+            module_type: module_type,
+            implement_name: implement_name,
+            current_namespace: current_namespace,
+            const_env: const_env,
+            class_name: class_name,
+            instance_definition: instance_definition,
+            module_definition: module_definition
+          )
+        end
       end
 
       attr_reader :call_context

data/lib/steep/type_inference/local_variable_type_env.rb

@@ -1,9 +1,6 @@
 module Steep
   module TypeInference
     class LocalVariableTypeEnv
-      attr_reader :subtyping
-      attr_reader :self_type
-
       class Entry
         attr_reader :type
         attr_reader :annotations
@@ -39,31 +36,46 @@ module Steep
         end
       end
 
+      attr_reader :subtyping
+      attr_reader :self_type
+      attr_reader :instance_type
+      attr_reader :class_type
       attr_reader :declared_types
       attr_reader :assigned_types
 
-      def self.empty(subtyping:, self_type:)
-        new(subtyping: subtyping, declared_types: {}, assigned_types: {}, self_type: self_type)
+      def self.empty(subtyping:, self_type:, instance_type:, class_type:)
+        new(
+          subtyping: subtyping,
+          declared_types: {},
+          assigned_types: {},
+          self_type: self_type,
+          instance_type: instance_type,
+          class_type: class_type
+        )
       end
 
-      def initialize(subtyping:, declared_types:, assigned_types:, self_type:)
+      def initialize(subtyping:, declared_types:, assigned_types:, self_type:, instance_type:, class_type:)
         @subtyping = subtyping
         @self_type = self_type
 
         @declared_types = declared_types
         @assigned_types = assigned_types
+        @class_type = class_type
+        @instance_type = instance_type
 
         unless (intersection = Set.new(declared_types.keys) & Set.new(assigned_types.keys)).empty?
           raise "Declared types and assigned types should be disjoint: #{intersection}"
         end
       end
 
-      def update(declared_types: self.declared_types, assigned_types: self.assigned_types, self_type: self.self_type)
+      def update(declared_types: self.declared_types, assigned_types: self.assigned_types, self_type: self.self_type, instance_type: self.instance_type, class_type: self.class_type)
         self.class.new(
           subtyping: subtyping,
           declared_types: declared_types,
           assigned_types: assigned_types,
-          self_type: self_type
+          self_type: self_type,
+          instance_type: instance_type,
+          class_type: class_type
         )
       end
 
@@ -73,7 +85,7 @@ module Steep
         if declared_type
           relation = Subtyping::Relation.new(sub_type: type, super_type: declared_type)
           constraints = Subtyping::Constraints.new(unknowns: Set.new)
-          subtyping.check(relation, constraints: constraints, self_type: self_type).else do |result|
+          subtyping.check(relation, constraints: constraints, self_type: self_type, instance_type: instance_type, class_type: class_type).else do |result|
             yield declared_type, type, result
           end
         end
@@ -89,7 +101,7 @@ module Steep
         if declared_type
           relation = Subtyping::Relation.new(sub_type: type, super_type: declared_type)
           constraints = Subtyping::Constraints.new(unknowns: Set.new)
-          subtyping.check(relation, constraints: constraints, self_type: self_type).else do |result|
+          subtyping.check(relation, constraints: constraints, self_type: self_type, instance_type: instance_type, class_type: class_type).else do |result|
             yield declared_type, type, result
           end
 
@@ -113,7 +125,7 @@ module Steep
           if outer_type
             relation = Subtyping::Relation.new(sub_type: inner_type, super_type: outer_type)
             constraints = Subtyping::Constraints.new(unknowns: Set.new)
-            subtyping.check(relation, constraints: constraints, self_type: self_type).else do |result|
+            subtyping.check(relation, constraints: constraints, self_type: self_type, instance_type: instance_type, class_type: class_type).else do |result|
               if block_given?
                 yield var, outer_type, inner_type, result
               end
@@ -194,7 +206,9 @@ module Steep
               subtyping: subtyping,
               self_type: self_type,
               declared_types: declared_types,
-              assigned_types: assigned_types
+              assigned_types: assigned_types,
+              instance_type: instance_type,
+              class_type: class_type
             )
           end
 

data/lib/steep/type_inference/logic.rb

@@ -22,7 +22,7 @@ module Steep
           nodes.each do |node|
             case node.type
             when :lvar, :lvasgn
-              vars << node.children[0].name
+              vars << node.children[0]
             end
           end
 

data/lib/steep/type_inference/logic_type_interpreter.rb

@@ -159,16 +159,16 @@ module Steep
       def decompose_value(node)
         case node.type
         when :lvar
-          [node, Set[node.children[0].name]]
+          [node, Set[node.children[0]]]
         when :masgn
           lhs, rhs = node.children
-          lhs_vars = lhs.children.select {|m| m.type == :lvasgn }.map {|m| m.children[0].name }
+          lhs_vars = lhs.children.select {|m| m.type == :lvasgn }.map {|m| m.children[0] }
           val, vars = decompose_value(rhs)
           [val, vars + lhs_vars]
         when :lvasgn
           var, rhs = node.children
           val, vars = decompose_value(rhs)
-          [val, vars + [var.name]]
+          [val, vars + [var]]
         when :begin
           decompose_value(node.children.last)
         when :and
@@ -283,7 +283,7 @@ module Steep
 
         else
           relation = Subtyping::Relation.new(sub_type: type, super_type: instance_type)
-          if subtyping.check(relation, constraints: Subtyping::Constraints.empty, self_type: AST::Types::Self.new).success?
+          if subtyping.check(relation, constraints: Subtyping::Constraints.empty, self_type: AST::Types::Self.new, instance_type: AST::Types::Instance.new, class_type: AST::Types::Class.new).success?
             [
               [type],
               []

data/lib/steep/type_inference/type_env.rb

@@ -38,19 +38,23 @@ module Steep
         end
       end
 
-      def with_annotations(ivar_types: {}, const_types: {}, gvar_types: {}, self_type:, &block)
+      def with_annotations(ivar_types: {}, const_types: {}, gvar_types: {}, self_type:, instance_type:, class_type:, &block)
         dup.tap do |env|
-          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)
+          merge!(original_env: env.ivar_types, override_env: ivar_types, self_type: self_type, instance_type: instance_type, class_type: class_type, &block)
+          merge!(original_env: env.gvar_types, override_env: gvar_types, self_type: self_type, instance_type: instance_type, class_type: class_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,
-                                self_type: self_type,
-                                &block
+              assert_annotation(
+                name,
+                original_type: original_type,
+                annotated_type: annotated_type,
+                self_type: self_type,
+                instance_type: instance_type,
+                class_type: class_type,
+                &block
+              )
             end
             env.const_types[name] = annotated_type
           end
@@ -101,13 +105,20 @@ module Steep
       # @type method assign: (const: TypeName, type: AST::Type) { (Subtyping::Result::Failure | nil) -> void } -> AST::Type
       #                    | (gvar: Symbol, type: AST::Type) { (Subtyping::Result::Failure | nil) -> void } -> AST::Type
       #                    | (ivar: Symbol, type: AST::Type) { (Subtyping::Result::Failure | nil) -> void } -> AST::Type
-      def assign(const: nil, gvar: nil, ivar: nil, type:, self_type:, &block)
+      def assign(const: nil, gvar: nil, ivar: nil, type:, self_type:, instance_type:, class_type:, &block)
         case
         when const
           yield_self do
             const_type = const_types[const] || const_env.lookup(const)
             if const_type
-              assert_assign(var_type: const_type, lhs_type: type, self_type: self_type, &block)
+              assert_assign(
+                var_type: const_type,
+                lhs_type: type,
+                self_type: self_type,
+                instance_type: instance_type,
+                class_type: class_type,
+                &block
+              )
             else
               yield nil
               AST::Types::Any.new
@@ -116,7 +127,14 @@ 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, self_type: self_type, &block)
+              assert_assign(
+                var_type: dictionary[var_name],
+                lhs_type: type,
+                self_type: self_type,
+                instance_type: instance_type,
+                class_type: class_type,
+                &block
+              )
             else
               yield nil
               AST::Types::Any.new
@@ -134,7 +152,7 @@ module Steep
         end
       end
 
-      def assert_assign(var_type:, lhs_type:, self_type:)
+      def assert_assign(var_type:, lhs_type:, self_type:, instance_type:, class_type:)
         return var_type if var_type == lhs_type
 
         var_type = subtyping.expand_alias(var_type)
@@ -143,20 +161,28 @@ module Steep
         relation = Subtyping::Relation.new(sub_type: lhs_type, super_type: var_type)
         constraints = Subtyping::Constraints.new(unknowns: Set.new)
 
-        subtyping.check(relation, self_type: self_type, constraints: constraints).else do |result|
+        subtyping.check(relation, self_type: self_type, constraints: constraints, instance_type: instance_type, class_type: class_type).else do |result|
           yield result
         end
 
         var_type
       end
 
-      def merge!(original_env:, override_env:, self_type:, &block)
+      def merge!(original_env:, override_env:, self_type:, instance_type:, class_type:, &block)
         original_env.merge!(override_env) do |name, original_type, override_type|
-          assert_annotation name, annotated_type: override_type, original_type: original_type, self_type: self_type, &block
+          assert_annotation(
+            name,
+            annotated_type: override_type,
+            original_type: original_type,
+            self_type: self_type,
+            instance_type: instance_type,
+            class_type: class_type,
+            &block
+          )
         end
       end
 
-      def assert_annotation(name, annotated_type:, original_type:, self_type:)
+      def assert_annotation(name, annotated_type:, original_type:, self_type:, instance_type:, class_type:)
         return annotated_type if annotated_type == original_type
 
         annotated_type = subtyping.expand_alias(annotated_type)
@@ -165,7 +191,7 @@ module Steep
         relation = Subtyping::Relation.new(sub_type: annotated_type, super_type: original_type)
         constraints = Subtyping::Constraints.new(unknowns: Set.new)
 
-        subtyping.check(relation, constraints: constraints, self_type: self_type).else do |result|
+        subtyping.check(relation, constraints: constraints, self_type: self_type, instance_type: instance_type, class_type: class_type).else do |result|
           yield name, relation, result
         end
 

data/lib/steep/version.rb

@@ -1,3 +1,3 @@
 module Steep
-  VERSION = "0.40.0"
+  VERSION = "0.44.0"
 end

data/smoke/alias/test_expectations.yml

@@ -0,0 +1,96 @@
+---
+- file: a.rb
+  diagnostics:
+  - range:
+      start:
+        line: 4
+        character: 0
+      end:
+        line: 4
+        character: 7
+    severity: ERROR
+    message: |-
+      Cannot find compatible overloading of method `+` of type `(::String | ::Integer)`
+      Method types:
+        def +: ((::string & ::Integer)) -> (::String | ::Integer)
+             | ((::string & ::Float)) -> (::String | ::Float)
+             | ((::string & ::Rational)) -> (::String | ::Rational)
+             | ((::string & ::Complex)) -> (::String | ::Complex)
+    code: Ruby::UnresolvedOverloading
+  - range:
+      start:
+        line: 13
+        character: 2
+      end:
+        line: 13
+        character: 7
+    severity: ERROR
+    message: |-
+      Cannot assign a value of type `::String` to a variable of type `::Symbol`
+        ::String <: ::Symbol
+          ::Object <: ::Symbol
+            ::BasicObject <: ::Symbol
+    code: Ruby::IncompatibleAssignment
+  - range:
+      start:
+        line: 15
+        character: 2
+      end:
+        line: 15
+        character: 7
+    severity: ERROR
+    message: |-
+      Cannot assign a value of type `::Integer` to a variable of type `::Symbol`
+        ::Integer <: ::Symbol
+          ::Numeric <: ::Symbol
+            ::Object <: ::Symbol
+              ::BasicObject <: ::Symbol
+    code: Ruby::IncompatibleAssignment
+- file: b.rb
+  diagnostics:
+  - range:
+      start:
+        line: 6
+        character: 0
+      end:
+        line: 6
+        character: 8
+    severity: ERROR
+    message: |-
+      Cannot assign a value of type `::String` to a variable of type `::Integer`
+        ::String <: ::Integer
+          ::Object <: ::Integer
+            ::BasicObject <: ::Integer
+    code: Ruby::IncompatibleAssignment
+- file: c.rb
+  diagnostics:
+  - range:
+      start:
+        line: 3
+        character: 0
+      end:
+        line: 3
+        character: 32
+    severity: ERROR
+    message: |-
+      Cannot assign a value of type `::Integer` to a variable of type `::String`
+        ::Integer <: ::String
+          ::Numeric <: ::String
+            ::Object <: ::String
+              ::BasicObject <: ::String
+    code: Ruby::IncompatibleAssignment
+  - range:
+      start:
+        line: 8
+        character: 0
+      end:
+        line: 8
+        character: 32
+    severity: ERROR
+    message: |-
+      Cannot assign a value of type `::Integer` to a variable of type `::String`
+        ::Integer <: ::String
+          ::Numeric <: ::String
+            ::Object <: ::String
+              ::BasicObject <: ::String
+    code: Ruby::IncompatibleAssignment

data/smoke/and/test_expectations.yml

@@ -0,0 +1,31 @@
+---
+- file: a.rb
+  diagnostics:
+  - range:
+      start:
+        line: 6
+        character: 0
+      end:
+        line: 6
+        character: 17
+    severity: ERROR
+    message: |-
+      Cannot assign a value of type `(::String | nil)` to a variable of type `::String`
+        (::String | nil) <: ::String
+          nil <: ::String
+    code: Ruby::IncompatibleAssignment
+  - range:
+      start:
+        line: 8
+        character: 0
+      end:
+        line: 8
+        character: 17
+    severity: ERROR
+    message: |-
+      Cannot assign a value of type `(::String | nil)` to a variable of type `::Integer`
+        (::String | nil) <: ::Integer
+          ::String <: ::Integer
+            ::Object <: ::Integer
+              ::BasicObject <: ::Integer
+    code: Ruby::IncompatibleAssignment

data/smoke/array/test_expectations.yml

@@ -0,0 +1,103 @@
+---
+- file: a.rb
+  diagnostics:
+  - range:
+      start:
+        line: 6
+        character: 0
+      end:
+        line: 6
+        character: 12
+    severity: ERROR
+    message: |-
+      Cannot find compatible overloading of method `[]=` of type `::Array[::Integer]`
+      Method types:
+        def []=: (::int, ::Integer) -> ::Integer
+               | (::int, ::int, ::Integer) -> ::Integer
+               | (::int, ::int, ::Array[::Integer]) -> ::Array[::Integer]
+               | (::int, ::int, nil) -> nil
+               | (::Range[::Integer], ::Integer) -> ::Integer
+               | (::Range[::Integer], ::Array[::Integer]) -> ::Array[::Integer]
+               | (::Range[::Integer], nil) -> nil
+    code: Ruby::UnresolvedOverloading
+  - range:
+      start:
+        line: 12
+        character: 0
+      end:
+        line: 12
+        character: 8
+    severity: ERROR
+    message: |-
+      Cannot assign a value of type `::Integer` to a variable of type `::String`
+        ::Integer <: ::String
+          ::Numeric <: ::String
+            ::Object <: ::String
+              ::BasicObject <: ::String
+    code: Ruby::IncompatibleAssignment
+  - range:
+      start:
+        line: 18
+        character: 0
+      end:
+        line: 18
+        character: 8
+    severity: ERROR
+    message: |-
+      Cannot assign a value of type `::String` to a variable of type `::Integer`
+        ::String <: ::Integer
+          ::Object <: ::Integer
+            ::BasicObject <: ::Integer
+    code: Ruby::IncompatibleAssignment
+- file: b.rb
+  diagnostics:
+  - range:
+      start:
+        line: 11
+        character: 0
+      end:
+        line: 11
+        character: 5
+    severity: ERROR
+    message: |-
+      Cannot assign a value of type `::Array[::Integer]` to a variable of type `::Array[::String]`
+        ::Array[::Integer] <: ::Array[::String]
+          ::Integer <: ::String
+            ::Numeric <: ::String
+              ::Object <: ::String
+                ::BasicObject <: ::String
+    code: Ruby::IncompatibleAssignment
+  - range:
+      start:
+        line: 12
+        character: 0
+      end:
+        line: 12
+        character: 5
+    severity: ERROR
+    message: |-
+      Cannot assign a value of type `::Array[::String]` to a variable of type `::Array[::Integer]`
+        ::Array[::String] <: ::Array[::Integer]
+          ::String <: ::Integer
+            ::Object <: ::Integer
+              ::BasicObject <: ::Integer
+    code: Ruby::IncompatibleAssignment
+- file: c.rb
+  diagnostics:
+  - range:
+      start:
+        line: 6
+        character: 0
+      end:
+        line: 6
+        character: 7
+    severity: ERROR
+    message: |-
+      Cannot assign a value of type `::Array[::Integer]` to a variable of type `::Array[(::String | nil)]`
+        ::Array[::Integer] <: ::Array[(::String | nil)]
+          ::Integer <: (::String | nil)
+            ::Integer <: ::String
+              ::Numeric <: ::String
+                ::Object <: ::String
+                  ::BasicObject <: ::String
+    code: Ruby::IncompatibleAssignment