steep 0.37.0 → 0.42.0

data/lib/steep/type_inference/constant_env.rb

@@ -15,9 +15,13 @@ module Steep
         @table = RBS::ConstantTable.new(builder: factory.definition_builder)
       end
 
+      def lookup_constant(name)
+        table.resolve_constant_reference(name, context: context)
+      end
+
       def lookup(name)
         cache[name] ||= begin
-          constant = table.resolve_constant_reference(name, context: context)
+          constant = lookup_constant(name)
 
           if constant
             factory.type(constant.type)

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_type_interpreter.rb

@@ -41,8 +41,11 @@ module Steep
 
         if type.is_a?(AST::Types::Logic::Base)
           vars.each do |var_name|
-            truthy_env = truthy_env.assign!(var_name, node: node, type: AST::Builtin.true_type)
-            falsy_env = truthy_env.assign!(var_name, node: node, type: AST::Builtin.false_type)
+            var_type = truthy_env[var_name]
+            truthy_type, falsy_type = factory.unwrap_optional(var_type)
+            falsy_type ||= AST::Builtin.nil_type
+            truthy_env = truthy_env.assign!(var_name, node: node, type: truthy_type) {|_, type, _| type }
+            falsy_env = truthy_env.assign!(var_name, node: node, type: falsy_type) {|_, type, _| type }
           end
 
           case type
@@ -77,11 +80,16 @@ module Steep
 
                 if arg_type.is_a?(AST::Types::Name::Singleton)
                   receiver_vars.each do |var_name|
-                    var_type = env[var_name]
-                    truthy_type, falsy_type = type_case_select(var_type, arg_type.name)
-
-                    truthy_env = truthy_env.assign!(var_name, node: node, type: truthy_type)
-                    falsy_env = falsy_env.assign!(var_name, node: node, type: falsy_type)
+                    case var_name
+                    when :_, :__any__, :__skip__
+                      # skip
+                    else
+                      var_type = env[var_name]
+                      truthy_type, falsy_type = type_case_select(var_type, arg_type.name)
+
+                      truthy_env = truthy_env.assign!(var_name, node: node, type: truthy_type)
+                      falsy_env = falsy_env.assign!(var_name, node: node, type: falsy_type)
+                    end
                   end
                 end
               end
@@ -93,7 +101,7 @@ module Steep
 
               if receiver
                 _, arg_vars = decompose_value(arg)
-                receiver_type = typing.type_of(node: receiver)
+                receiver_type = factory.deep_expand_alias(typing.type_of(node: receiver))
 
                 if receiver_type.is_a?(AST::Types::Name::Singleton)
                   arg_vars.each do |var_name|
@@ -106,6 +114,23 @@ module Steep
                 end
               end
             end
+          when AST::Types::Logic::ArgEqualsReceiver
+            case value_node.type
+            when :send
+              receiver, _, arg = value_node.children
+
+              if receiver
+                _, arg_vars = decompose_value(arg)
+
+                arg_vars.each do |var_name|
+                  var_type = factory.deep_expand_alias(env[var_name])
+                  truthy_types, falsy_types = literal_var_type_case_select(receiver, var_type)
+
+                  truthy_env = truthy_env.assign!(var_name, node: node, type: AST::Types::Union.build(types: truthy_types, location: nil))
+                  falsy_env = falsy_env.assign!(var_name, node: node, type: AST::Types::Union.build(types: falsy_types, location: nil))
+                end
+              end
+            end
           when AST::Types::Logic::Not
             receiver, * = value_node.children
             receiver_type = typing.type_of(node: receiver)
@@ -156,6 +181,60 @@ module Steep
         end
       end
 
+      def literal_var_type_case_select(value_node, arg_type)
+        case arg_type
+        when AST::Types::Union
+          truthy_types = []
+          falsy_types = []
+
+          arg_type.types.each do |type|
+            ts, fs = literal_var_type_case_select(value_node, type)
+            truthy_types.push(*ts)
+            falsy_types.push(*fs)
+          end
+
+          [truthy_types, falsy_types]
+        else
+          value_type = typing.type_of(node: value_node)
+          types = [arg_type]
+
+          case value_node.type
+          when :nil
+            types.partition do |type|
+              type.is_a?(AST::Types::Nil) || AST::Builtin::NilClass.instance_type?(type)
+            end
+          when :true
+            types.partition do |type|
+              AST::Builtin::TrueClass.instance_type?(type) ||
+                (type.is_a?(AST::Types::Literal) && type.value == true)
+            end
+          when :false
+            types.partition do |type|
+              AST::Builtin::FalseClass.instance_type?(type) ||
+                (type.is_a?(AST::Types::Literal) && type.value == false)
+            end
+          when :int, :str, :sym
+            types.each.with_object([[], []]) do |type, pair|
+              true_types, false_types = pair
+
+              case
+              when type.is_a?(AST::Types::Literal)
+                if type.value == value_node.children[0]
+                  true_types << type
+                else
+                  false_types << type
+                end
+              else
+                true_types << AST::Types::Literal.new(value: value_node.children[0])
+                false_types << type
+              end
+            end
+          else
+            [[arg_type], [arg_type]]
+          end
+        end
+      end
+
       def type_case_select(type, klass)
         truth_types, false_types = type_case_select0(type, klass)
 
@@ -186,20 +265,6 @@ module Steep
 
           [truthy_types, falsy_types]
 
-        when AST::Types::Name::Instance
-          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?
-            [
-              [type],
-              []
-            ]
-          else
-            [
-              [],
-              [type]
-            ]
-          end
-
         when AST::Types::Name::Alias
           ty = factory.expand_alias(type)
           type_case_select0(ty, klass)
@@ -217,10 +282,18 @@ module Steep
           ]
 
         else
-          [
-            [],
-            [type]
-          ]
+          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, instance_type: AST::Types::Instance.new, class_type: AST::Types::Class.new).success?
+            [
+              [type],
+              []
+            ]
+          else
+            [
+              [],
+              [type]
+            ]
+          end
         end
       end
     end

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/typing.rb

@@ -21,8 +21,9 @@ module Steep
     attr_reader :contexts
     attr_reader :root_context
     attr_reader :method_calls
+    attr_reader :source_index
 
-    def initialize(source:, root_context:, parent: nil, parent_last_update: parent&.last_update, contexts: nil)
+    def initialize(source:, root_context:, parent: nil, parent_last_update: parent&.last_update, contexts: nil, source_index: nil)
       @source = source
 
       @parent = parent
@@ -35,6 +36,8 @@ module Steep
       @root_context = root_context
       @contexts = contexts || TypeInference::ContextArray.from_source(source: source)
       @method_calls = {}.compare_by_identity
+
+      @source_index = source_index || Index::SourceIndex.new(source: source)
     end
 
     def add_error(error)
@@ -195,7 +198,8 @@ module Steep
       child = self.class.new(source: source,
                              parent: self,
                              root_context: root_context,
-                             contexts: TypeInference::ContextArray.new(buffer: contexts.buffer, range: range, context: nil))
+                             contexts: TypeInference::ContextArray.new(buffer: contexts.buffer, range: range, context: nil),
+                             source_index: source_index.new_child)
       @should_update = true
 
       if block_given?
@@ -224,6 +228,8 @@ module Steep
       errors.each do |error|
         parent.add_error error
       end
+
+      parent.source_index.merge!(source_index)
     end
   end
 end

data/lib/steep/version.rb

@@ -1,3 +1,3 @@
 module Steep
-  VERSION = "0.37.0"
+  VERSION = "0.42.0"
 end