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

data/lib/steep/signature/validator.rb

@@ -79,8 +79,8 @@ module Steep
           type_params.zip(type_args).each do |param, arg|
             arg or raise
 
-            if param.upper_bound
-              upper_bound_type = factory.type(param.upper_bound).subst(subst)
+            if param.upper_bound_type
+              upper_bound_type = factory.type(param.upper_bound_type).subst(subst)
               arg_type = factory.type(arg)
 
               constraints = Subtyping::Constraints.empty
@@ -101,7 +101,8 @@ module Steep
                     name: param.name,
                     upper_bound: upper_bound_type,
                     variance: param.variance,
-                    unchecked: param.unchecked?
+                    unchecked: param.unchecked?,
+                    default_type: factory.type_opt(param.default_type)
                   ),
                   location: location
                 )
@@ -162,9 +163,9 @@ module Steep
 
           case
           when ancestor.name.interface?
-            AST::Types::Name::Interface.new(name: ancestor.name, args: args, location: nil)
+            AST::Types::Name::Interface.new(name: ancestor.name, args: args)
           when ancestor.name.class?
-            AST::Types::Name::Instance.new(name: ancestor.name, args: args, location: nil)
+            AST::Types::Name::Instance.new(name: ancestor.name, args: args)
           else
             raise "#{ancestor.name}"
           end
@@ -181,7 +182,7 @@ module Steep
         if immediate_self_types && !immediate_self_types.empty?
           # @type var sts: Array[AST::Types::t]
           sts = immediate_self_types.map {|st| ancestor_to_type(st) }
-          self_type = AST::Types::Intersection.build(types: sts.push(self_type), location: nil)
+          self_type = AST::Types::Intersection.build(types: sts.push(self_type))
         end
 
         mixin_ancestors.each do |ancestor|
@@ -236,7 +237,7 @@ module Steep
       def validate_definition_type(definition)
         each_method_type(definition) do |method_type|
           upper_bounds = method_type.type_params.each.with_object({}) do |param, hash|
-            hash[param.name] = factory.type_opt(param.upper_bound)
+            hash[param.name] = factory.type_opt(param.upper_bound_type)
           end
 
           checker.push_variable_bounds(upper_bounds) do
@@ -255,23 +256,21 @@ module Steep
         rescue_validation_errors(name) do
           Steep.logger.debug { "Validating class definition `#{name}`..." }
 
-          class_type = AST::Types::Name::Singleton.new(name: name, location: nil)
+          class_type = AST::Types::Name::Singleton.new(name: name)
           instance_type = AST::Types::Name::Instance.new(
             name: name,
-            args: entry.type_params.map { AST::Types::Any.new(location: nil) },
-            location: nil
+            args: entry.type_params.map { AST::Types::Any.instance() }
           )
 
           Steep.logger.tagged "#{name}" do
             builder.build_instance(name).tap do |definition|
               upper_bounds = definition.type_params_decl.each.with_object({}) do |param, bounds|
-                bounds[param.name] = factory.type_opt(param.upper_bound)
+                bounds[param.name] = factory.type_opt(param.upper_bound_type)
               end
 
               self_type = AST::Types::Name::Instance.new(
                 name: name,
-                args: entry.type_params.map { AST::Types::Var.new(name: _1.name) },
-                location: nil
+                args: entry.type_params.map { AST::Types::Var.new(name: _1.name) }
               )
 
               push_context(self_type: self_type, class_type: class_type, instance_type: instance_type) do
@@ -482,13 +481,12 @@ module Steep
             definition = builder.build_interface(name)
 
             upper_bounds = definition.type_params_decl.each.with_object({}) do |param, bounds|
-              bounds[param.name] = factory.type_opt(param.upper_bound)
+              bounds[param.name] = factory.type_opt(param.upper_bound_type)
             end
 
             self_type = AST::Types::Name::Interface.new(
               name: name,
-              args: definition.type_params.map { AST::Types::Var.new(name: _1) },
-              location: nil
+              args: definition.type_params.map { AST::Types::Var.new(name: _1) }
             )
 
             push_context(self_type: self_type, class_type: nil, instance_type: nil) do
@@ -561,11 +559,10 @@ module Steep
       def validate_one_alias(name, entry = env.type_alias_decls[name])
         *, inner_most_outer_module = entry.outer
         if inner_most_outer_module
-          class_type = AST::Types::Name::Singleton.new(name: inner_most_outer_module.name, location: nil)
+          class_type = AST::Types::Name::Singleton.new(name: inner_most_outer_module.name)
           instance_type = AST::Types::Name::Instance.new(
             name: inner_most_outer_module.name,
-            args: inner_most_outer_module.type_params.map { AST::Types::Any.new(location: nil) },
-            location: nil
+            args: inner_most_outer_module.type_params.map { AST::Types::Any.instance() },
           )
         end
 
@@ -579,7 +576,7 @@ module Steep
             end
 
             upper_bounds = entry.decl.type_params.each.with_object({}) do |param, bounds|
-              bounds[param.name] = factory.type_opt(param.upper_bound)
+              bounds[param.name] = factory.type_opt(param.upper_bound_type)
             end
 
             validator.validate_type_alias(entry: entry) do |type|

data/lib/steep/source.rb

@@ -8,6 +8,7 @@ module Steep
     attr_reader :ignores
 
     extend NodeHelper
+    extend ModuleHelper
 
     def initialize(buffer:, path:, node:, mapping:, comments:, ignores:)
       @buffer = buffer
@@ -295,8 +296,14 @@ module Steep
     end
 
     def annotations(block:, factory:, context:)
+      annotations =
+        if block
+          mapping.fetch(block, [])
+        else
+          []
+        end #: Array[AST::Annotation::t]
       AST::Annotation::Collection.new(
-        annotations: (mapping[block] || []),
+        annotations: annotations,
         factory: factory,
         context: context
       )
@@ -444,6 +451,32 @@ module Steep
       end
     end
 
+    def self.skip_arg_assertions(node)
+      send_node, _ = deconstruct_sendish_and_block_nodes(node)
+      return false unless send_node
+
+      if send_node.type == :send
+        receiver, method, args = deconstruct_send_node!(send_node)
+
+        return false unless receiver
+
+        if receiver.type == :const
+          if type_name = module_name_from_node(receiver.children[0], receiver.children[1])
+            if type_name.namespace.empty?
+              if type_name.name == :Data && method == :define
+                return true
+              end
+              if type_name.name == :Struct && method == :new
+                return true
+              end
+            end
+          end
+        end
+      end
+
+      false
+    end
+
     def self.insert_type_node(node, comments)
       if node.location.expression
         first_line = node.location.expression.first_line
@@ -567,6 +600,19 @@ module Steep
         body = insert_type_node(body, comments) if body
         return adjust_location(node.updated(nil, [object, name, args, body]))
       else
+        if skip_arg_assertions(node)
+          # Data.define, Struct.new, ...??
+          if node.location.expression
+            first_line = node.location.expression.first_line
+            last_line = node.location.expression.last_line
+
+            child_assertions = comments.delete_if {|line, _ | first_line < line && line < last_line }
+            node = map_child_node(node) {|child| insert_type_node(child, child_assertions) }
+
+            return adjust_location(node)
+          end
+        end
+
         adjust_location(
           map_child_node(node, nil) {|child| insert_type_node(child, comments) }
         )

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

@@ -28,7 +28,7 @@ module Steep
           attr_reader :lower_bound
           attr_reader :upper_bound
 
-          def initialize(var: nil, lower_bound: nil, upper_bound: nil)
+          def initialize(var:, lower_bound:, upper_bound:)
             @var = var
             @lower_bound = lower_bound
             @upper_bound = upper_bound
@@ -96,7 +96,7 @@ module Steep
         unless Set.new(vars).disjoint?(unknowns)
           raise UnsatisfiedInvariantError.new(
             reason: UnsatisfiedInvariantError::VariablesUnknownsNotDisjoint.new(vars: vars),
-            constraints: constraints
+            constraints: self
           )
         end
       end
@@ -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