steep 1.8.0.dev.2 → 1.8.0.pre.1

data/lib/steep/subtyping/check.rb

@@ -59,7 +59,7 @@ module Steep
       def variable_upper_bound(name)
         @bounds.reverse_each do |hash|
           if hash.key?(name)
-            return hash[name]
+            return hash.fetch(name)
           end
         end
 
@@ -129,20 +129,17 @@ module Steep
             if ancestor.name.class?
               AST::Types::Name::Instance.new(
                 name: name,
-                args: args,
-                location: nil
+                args: args
               )
             else
               AST::Types::Name::Interface.new(
                 name: name,
-                args: args,
-                location: nil
+                args: args
               )
             end
           when RBS::Definition::Ancestor::Singleton
             AST::Types::Name::Singleton.new(
-              name: name,
-              location: nil
+              name: name
             )
           end
         end
@@ -163,20 +160,17 @@ module Steep
             if ancestor.name.class?
               AST::Types::Name::Instance.new(
                 name: name,
-                args: args,
-                location: nil
+                args: args
               )
             else
               AST::Types::Name::Interface.new(
                 name: name,
-                args: args,
-                location: nil
+                args: args
               )
             end
           when RBS::Definition::Ancestor::Singleton
             AST::Types::Name::Singleton.new(
-              name: name,
-              location: nil
+              name: name
             )
           end
         end
@@ -271,9 +265,6 @@ module Steep
         when relation.sub_type.is_a?(AST::Types::Bot)
           success(relation)
 
-        when relation.sub_type.is_a?(AST::Types::Logic::Base) && (true_type?(relation.super_type) || false_type?(relation.super_type))
-          success(relation)
-
         when relation.super_type.is_a?(AST::Types::Boolean)
           Expand(relation) do
             check_type(
@@ -284,7 +275,7 @@ module Steep
             )
           end
 
-        when relation.sub_type.is_a?(AST::Types::Boolean)
+        when relation.sub_type.is_a?(AST::Types::Boolean) || relation.sub_type.is_a?(AST::Types::Logic::Base)
           Expand(relation) do
             check_type(
               Relation.new(
@@ -357,20 +348,51 @@ module Steep
           constraints.add(relation.sub_type.name, super_type: relation.super_type)
           Success(relation)
 
-        when relation.sub_type.is_a?(AST::Types::Union)
+        when relation.sub_type.is_a?(AST::Types::Var) && ub = variable_upper_bound(relation.sub_type.name)
+          Expand(relation) do
+            check_type(Relation.new(sub_type: ub, super_type: relation.super_type))
+          end
+
+        when relation.sub_type.is_a?(AST::Types::Intersection) && relation.super_type.is_a?(AST::Types::Union)
+          Any(relation) do |base_result|
+            # Expand the super_type first
+            base_result.add(relation) do
+              Any(relation) do |result|
+                relation.super_type.types.sort_by {|ty| (path = hole_path(ty)) ? -path.size : -Float::INFINITY }.each do |super_type|
+                  rel = Relation.new(sub_type: relation.sub_type, super_type: super_type)
+                  result.add(rel) do
+                    check_type(rel)
+                  end
+                end
+              end
+            end
+
+            # Expand the sub_type if it fails
+            base_result.add(relation) do
+              Any(relation) do |result|
+                relation.sub_type.types.sort_by {|ty| (path = hole_path(ty)) ? -path.size : -Float::INFINITY }.each do |sub_type|
+                  rel = Relation.new(sub_type: sub_type, super_type: relation.super_type)
+                  result.add(rel) do
+                    check_type(rel)
+                  end
+                end
+              end
+            end
+          end
+
+        when relation.super_type.is_a?(AST::Types::Intersection)
           All(relation) do |result|
-            relation.sub_type.types.each do |sub_type|
-              rel = Relation.new(sub_type: sub_type, super_type: relation.super_type)
-              result.add(rel) do
+            relation.super_type.types.each do |super_type|
+              result.add(Relation.new(sub_type: relation.sub_type, super_type: super_type)) do |rel|
                 check_type(rel)
               end
             end
           end
 
-        when relation.super_type.is_a?(AST::Types::Union)
-          Any(relation) do |result|
-            relation.super_type.types.sort_by {|ty| (path = hole_path(ty)) ? -path.size : -Float::INFINITY }.each do |super_type|
-              rel = Relation.new(sub_type: relation.sub_type, super_type: super_type)
+        when relation.sub_type.is_a?(AST::Types::Union)
+          All(relation) do |result|
+            relation.sub_type.types.each do |sub_type|
+              rel = Relation.new(sub_type: sub_type, super_type: relation.super_type)
               result.add(rel) do
                 check_type(rel)
               end
@@ -387,23 +409,16 @@ module Steep
             end
           end
 
-        when relation.super_type.is_a?(AST::Types::Intersection)
-          All(relation) do |result|
-            relation.super_type.types.each do |super_type|
-              result.add(Relation.new(sub_type: relation.sub_type, super_type: super_type)) do |rel|
+        when relation.super_type.is_a?(AST::Types::Union)
+          Any(relation) do |result|
+            relation.super_type.types.sort_by {|ty| (path = hole_path(ty)) ? -path.size : -Float::INFINITY }.each do |super_type|
+              rel = Relation.new(sub_type: relation.sub_type, super_type: super_type)
+              result.add(rel) do
                 check_type(rel)
               end
             end
           end
 
-        when relation.sub_type.is_a?(AST::Types::Var) && ub = variable_upper_bound(relation.sub_type.name)
-          Expand(relation) do
-            check_type(Relation.new(sub_type: ub, super_type: relation.super_type))
-          end
-
-        when relation.super_type.is_a?(AST::Types::Var) || relation.sub_type.is_a?(AST::Types::Var)
-          Failure(relation, Result::Failure::UnknownPairError.new(relation: relation))
-
         when relation.super_type.is_a?(AST::Types::Name::Interface)
           Expand(relation) do
             check_interface(
@@ -497,37 +512,72 @@ module Steep
           Expand(relation) do
             tuple_element_type =
               AST::Types::Union.build(
-                types: relation.sub_type.types,
-                location: relation.sub_type.location
+                types: relation.sub_type.types
               )
 
             check_type(Relation.new(sub_type: tuple_element_type, super_type: super_type.args[0]))
           end
 
+        when relation.sub_type.is_a?(AST::Types::Tuple)
+          Any(relation) do |result|
+            # Check by converting the tuple to array
+            tuple_element_type = AST::Types::Union.build(types: relation.sub_type.types)
+            array_type = AST::Builtin::Array.instance_type(tuple_element_type)
+            result.add(Relation.new(sub_type: array_type, super_type: relation.super_type)) do
+              check_type(_1)
+            end
+
+            # Check by shapes
+            shape_relation = relation.map {|type|
+              # @type break: nil
+              builder.shape(
+                type, Interface::Builder::Config.new(self_type: type, variable_bounds: variable_upper_bounds)
+              )&.public_shape or break
+            }
+            if shape_relation
+              result.add(shape_relation) { check_interface(_1) }
+            end
+          end
+
         when relation.sub_type.is_a?(AST::Types::Record) && relation.super_type.is_a?(AST::Types::Record)
           All(relation) do |result|
             relation.super_type.elements.each_key do |key|
-              rel = Relation.new(
-                sub_type: relation.sub_type.elements[key] || AST::Builtin.nil_type,
-                super_type: relation.super_type.elements[key]
-              )
+              super_element_type = relation.super_type.elements[key]
 
-              result.add(rel) do
-                check_type(rel)
+              if relation.sub_type.elements.key?(key)
+                sub_element_type = relation.sub_type.elements[key]
+              else
+                if relation.super_type.required?(key)
+                  sub_element_type = AST::Builtin.nil_type
+                end
+              end
+
+              if sub_element_type
+                rel = Relation.new(sub_type: sub_element_type, super_type: super_element_type)
+                result.add(rel) { check_type(rel) }
               end
             end
           end
 
-        when relation.sub_type.is_a?(AST::Types::Record) && relation.super_type.is_a?(AST::Types::Name::Base)
-          Expand(relation) do
-            check_interface(
-              relation.map {|type|
-                builder.shape(
-                  type,
-                  Interface::Builder::Config.new(self_type: type, variable_bounds: variable_upper_bounds)
-                )&.public_shape or raise
-              }
-            )
+        when relation.sub_type.is_a?(AST::Types::Record)
+          Any(relation) do |result|
+            # Check by converting the record to hash
+            key_type = AST::Types::Union.build(types: relation.sub_type.elements.each_key.map {|key| AST::Types::Literal.new(value: key) })
+            value_type = AST::Types::Union.build(types: relation.sub_type.elements.each_value.map {|key| key })
+            hash_type = AST::Builtin::Hash.instance_type(key_type, value_type)
+            result.add(Relation.new(sub_type: hash_type, super_type: relation.super_type)) { check_type(_1) }
+
+            # Check by the shapes
+            shape_relation = relation.map do |type|
+              # @type break: nil
+              builder.shape(
+                type,
+                Interface::Builder::Config.new(self_type: type, variable_bounds: variable_upper_bounds)
+              )&.public_shape or break
+            end
+            if shape_relation
+              result.add(shape_relation) { check_interface(_1) }
+            end
           end
 
         when relation.sub_type.is_a?(AST::Types::Proc) && AST::Builtin::Proc.instance_type?(relation.super_type)

data/lib/steep/subtyping/constraints.rb

@@ -113,13 +113,13 @@ module Steep
         end
 
         if super_type && !super_type.is_a?(AST::Types::Top)
-          type = eliminate_variable(super_type, to: AST::Types::Top.new)
+          type = eliminate_variable(super_type, to: AST::Types::Top.instance)
           supers << type
           skips << type if skip
         end
 
         if sub_type && !sub_type.is_a?(AST::Types::Bot)
-          type = eliminate_variable(sub_type, to: AST::Types::Bot.new)
+          type = eliminate_variable(sub_type, to: AST::Types::Bot.instance)
           subs << type
           skips << type if skip
         end
@@ -147,19 +147,19 @@ module Steep
         case type
         when AST::Types::Name::Instance, AST::Types::Name::Alias, AST::Types::Name::Interface
           type.args.map do |ty|
-            eliminate_variable(ty, to: AST::Types::Any.new)
+            eliminate_variable(ty, to: AST::Types::Any.instance)
           end.yield_self do |args|
-            type.class.new(name: type.name, args: args, location: type.location)
+            type.class.new(name: type.name, args: args)
           end
         when AST::Types::Union
           type.types.map do |ty|
-            eliminate_variable(ty, to: AST::Types::Any.new)
+            eliminate_variable(ty, to: AST::Types::Any.instance)
           end.yield_self do |types|
             AST::Types::Union.build(types: types)
           end
         when AST::Types::Intersection
           type.types.map do |ty|
-            eliminate_variable(ty, to: AST::Types::Any.new)
+            eliminate_variable(ty, to: AST::Types::Any.instance)
           end.yield_self do |types|
             AST::Types::Intersection.build(types: types)
           end
@@ -171,14 +171,10 @@ module Steep
           end
         when AST::Types::Tuple
           AST::Types::Tuple.new(
-            types: type.types.map {|ty| eliminate_variable(ty, to: AST::Builtin.any_type) },
-            location: type.location
+            types: type.types.map {|ty| eliminate_variable(ty, to: AST::Builtin.any_type) }
           )
         when AST::Types::Record
-          AST::Types::Record.new(
-            elements: type.elements.transform_values {|ty| eliminate_variable(ty, to: AST::Builtin.any_type) },
-            location: type.location
-          )
+          type.map_type { eliminate_variable(_1, to: AST::Builtin.any_type) }
         when AST::Types::Proc
           type.map_type {|ty| eliminate_variable(ty, to: AST::Builtin.any_type) }
         else
@@ -213,7 +209,7 @@ module Steep
 
         case upper_bound.size
         when 0
-          AST::Types::Top.new
+          AST::Types::Top.instance
         when 1
           upper_bound.first || raise
         else
@@ -226,7 +222,7 @@ module Steep
 
         case lower_bound.size
         when 0
-          AST::Types::Bot.new
+          AST::Types::Bot.instance
         when 1
           lower_bound.first || raise
         else
@@ -293,7 +289,7 @@ module Steep
               end
             else
               vars << var
-              types << AST::Types::Any.new
+              types << AST::Types::Any.instance
             end
           end
         end