steep 0.46.0 → 0.48.0

data/lib/steep/signature/validator.rb

@@ -56,9 +56,73 @@ module Steep
         validate_alias
       end
 
+      def validate_type_application_constraints(type_name, type_params, type_args, location:)
+        if type_params.size == type_args.size
+          type_params.zip(type_args).each do |param, arg|
+            if param.upper_bound
+              upper_bound_type = factory.type(param.upper_bound)
+              arg_type = factory.type(arg)
+
+              constraints = Subtyping::Constraints.empty
+
+              checker.check(
+                Subtyping::Relation.new(sub_type: arg_type, super_type: upper_bound_type),
+                self_type: nil,
+                class_type: nil,
+                instance_type: nil,
+                constraints: constraints
+              ).else do |result|
+                @errors << Diagnostic::Signature::UnsatisfiableTypeApplication.new(
+                  type_name: type_name,
+                  type_arg: arg_type,
+                  type_param: Interface::TypeParam.new(
+                    name: param.name,
+                    upper_bound: upper_bound_type,
+                    variance: param.variance,
+                    unchecked: param.unchecked?
+                  ),
+                  location: location
+                )
+              end
+            end
+          end
+        end
+      end
+
       def validate_type(type)
         Steep.logger.debug "#{Location.to_string type.location}: Validating #{type}..."
+
         validator.validate_type type, context: [RBS::Namespace.root]
+
+        name, type_params, type_args =
+          case type
+          when RBS::Types::ClassInstance
+            [
+              type.name,
+              builder.build_instance(type.name).type_params_decl,
+              type.args
+            ]
+          when RBS::Types::Interface
+            [
+              type.name,
+              builder.build_interface(type.name).type_params_decl,
+              type.args
+            ]
+          when RBS::Types::Alias
+            entry = env.alias_decls[type.name]
+
+            [
+              type.name,
+              entry.decl.type_params,
+              type.args
+            ]
+          end
+
+        if name && type_params && type_args
+          if !type_params.empty? && !type_args.empty?
+            validate_type_application_constraints(type.name, type_params, type_args, location: type.location)
+          end
+        end
       end
 
       def ancestor_to_type(ancestor)
@@ -109,64 +173,109 @@ module Steep
         relations
       end
 
+      def each_method_type(definition)
+        type_name = definition.type_name
+
+        definition.methods.each_value do |method|
+          if method.defined_in == type_name
+            method.method_types.each do |method_type|
+              yield method_type
+            end
+          end
+        end
+      end
+
+      def each_variable_type(definition)
+        type_name = definition.type_name
+
+        definition.instance_variables.each_value do |var|
+          if var.declared_in == type_name
+            yield var.type
+          end
+        end
+
+        definition.class_variables.each_value do |var|
+          if var.declared_in == type_name
+            yield var.type
+          end
+        end
+      end
+
+      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)
+          end
+
+          checker.push_variable_bounds(upper_bounds) do
+            method_type.each_type do |type|
+              validate_type(type)
+            end
+          end
+        end
+
+        each_variable_type(definition) do |type|
+          validate_type(type)
+        end
+      end
+
       def validate_one_class(name)
         rescue_validation_errors(name) do
           Steep.logger.debug { "Validating class definition `#{name}`..." }
 
           Steep.logger.tagged "#{name}" do
             builder.build_instance(name).tap do |definition|
-              definition.instance_variables.each do |name, var|
-                if parent = var.parent_variable
-                  var_type = checker.factory.type(var.type)
-                  parent_type = checker.factory.type(parent.type)
+              upper_bounds = definition.type_params_decl.each.with_object({}) do |param, bounds|
+                bounds[param.name] = factory.type_opt(param.upper_bound)
+              end
 
-                  relation = Subtyping::Relation.new(sub_type: var_type, super_type: parent_type)
-                  result1 = checker.check(
+              checker.push_variable_bounds(upper_bounds) do
+                definition.instance_variables.each do |name, var|
+                  if parent = var.parent_variable
+                    var_type = checker.factory.type(var.type)
+                    parent_type = checker.factory.type(parent.type)
+
+                    relation = Subtyping::Relation.new(sub_type: var_type, super_type: parent_type)
+                    result1 = checker.check(relation, self_type: nil, instance_type: nil, class_type: nil, constraints: Subtyping::Constraints.empty)
+                    result2 = checker.check(relation.flip, self_type: nil, instance_type: nil, class_type: nil, constraints: Subtyping::Constraints.empty)
+
+                    unless result1.success? and result2.success?
+                      @errors << Diagnostic::Signature::InstanceVariableTypeError.new(
+                        name: name,
+                        location: var.type.location,
+                        var_type: var_type,
+                        parent_type: parent_type
+                      )
+                    end
+                  end
+                end
+
+                ancestors = builder.ancestor_builder.one_instance_ancestors(name)
+                mixin_constraints(definition, ancestors.included_modules, immediate_self_types: ancestors.self_types).each do |relation, ancestor|
+                  checker.check(
                     relation,
                     self_type: AST::Types::Self.new,
                     instance_type: AST::Types::Instance.new,
                     class_type: AST::Types::Class.new,
                     constraints: Subtyping::Constraints.empty
-                  )
-                  result2 = checker.check(
-                    relation.flip,
-                    self_type: AST::Types::Self.new,
-                    instance_type: AST::Types::Instance.new,
-                    class_type: AST::Types::Class.new,
-                    constraints: Subtyping::Constraints.empty
-                  )
-
-                  unless result1.success? and result2.success?
-                    @errors << Diagnostic::Signature::InstanceVariableTypeError.new(
+                  ).else do
+                    @errors << Diagnostic::Signature::ModuleSelfTypeError.new(
                       name: name,
-                      location: var.type.location,
-                      var_type: var_type,
-                      parent_type: parent_type
+                      location: ancestor.source&.location || raise,
+                      ancestor: ancestor,
+                      relation: relation
                     )
                   end
                 end
-              end
 
-              ancestors = builder.ancestor_builder.one_instance_ancestors(name)
-              mixin_constraints(definition, ancestors.included_modules, immediate_self_types: ancestors.self_types).each do |relation, ancestor|
-                checker.check(
-                  relation,
-                  self_type: AST::Types::Self.new,
-                  instance_type: AST::Types::Instance.new,
-                  class_type: AST::Types::Class.new,
-                  constraints: Subtyping::Constraints.empty
-                ).else do
-                  @errors << Diagnostic::Signature::ModuleSelfTypeError.new(
-                    name: name,
-                    location: ancestor.source&.location || raise,
-                    ancestor: ancestor,
-                    relation: relation
-                  )
+                ancestors.each_ancestor do |ancestor|
+                  case ancestor
+                  when RBS::Definition::Ancestor::Instance
+                    validate_ancestor_application(name, ancestor)
+                  end
                 end
-              end
 
-              definition.each_type do |type|
-                validate_type type
+                validate_definition_type(definition)
               end
             end
 
@@ -220,21 +329,78 @@ module Steep
                   )
                 end
               end
-
-              definition.each_type do |type|
-                validate_type type
+              ancestors.each_ancestor do |ancestor|
+                case ancestor
+                when RBS::Definition::Ancestor::Instance
+                  validate_ancestor_application(name, ancestor)
+                end
               end
+
+              validate_definition_type(definition)
             end
           end
         end
       end
 
+      def validate_ancestor_application(name, ancestor)
+        unless ancestor.args.empty?
+          definition =
+            case
+            when ancestor.name.class?
+              builder.build_instance(ancestor.name)
+            when ancestor.name.interface?
+              builder.build_interface(ancestor.name)
+            end
+
+          location =
+            if ancestor.source == :super
+              primary_decl = env.class_decls[name].primary.decl
+              if super_class = primary_decl.super_class
+                super_class.location
+              else
+                # Implicit super class (Object): this can be skipped in fact...
+                primary_decl.location[:name]
+              end
+            else
+              ancestor.source.location
+            end
+
+          validate_type_application_constraints(
+            ancestor.name,
+            definition.type_params_decl,
+            ancestor.args,
+            location: location
+          )
+        end
+      end
+
       def validate_one_interface(name)
         rescue_validation_errors(name) do
           Steep.logger.debug "Validating interface `#{name}`..."
           Steep.logger.tagged "#{name}" do
-            builder.build_interface(name).each_type do |type|
-              validate_type type
+            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)
+            end
+
+            checker.push_variable_bounds(upper_bounds) do
+              validate_definition_type(definition)
+
+              ancestors = builder.ancestor_builder.one_interface_ancestors(name)
+              ancestors.each_ancestor do |ancestor|
+                case ancestor
+                when RBS::Definition::Ancestor::Instance
+                  # Interface ancestor cannot be other than Interface
+                  defn = builder.build_interface(ancestor.name)
+                  validate_type_application_constraints(
+                    ancestor.name,
+                    defn.type_params_decl,
+                    ancestor.args,
+                    location: ancestor.source.location || raise
+                  )
+                end
+              end
             end
           end
         end
@@ -277,24 +443,30 @@ module Steep
         end
       end
 
-      def validate_one_alias(name)
+      def validate_one_alias(name, entry = env.alias_decls[name])
         rescue_validation_errors(name) do
           Steep.logger.debug "Validating alias `#{name}`..."
-          builder.expand_alias(name).tap do |type|
-            validate_type(type)
+          upper_bounds = entry.decl.type_params.each.with_object({}) do |param, bounds|
+            bounds[param.name] = factory.type_opt(param.upper_bound)
+          end
+
+          validator.validate_type_alias(entry: entry) do |type|
+            checker.push_variable_bounds(upper_bounds) do
+              validate_type(entry.decl.type)
+            end
           end
         end
       end
 
       def validate_alias
         env.alias_decls.each do |name, entry|
-          validate_one_alias(name)
+          validate_one_alias(name, entry)
         end
       end
 
       def rescue_validation_errors(type_name = nil)
         yield
-      rescue RBS::ErrorBase => exn
+      rescue RBS::BaseError => exn
         @errors << Diagnostic::Signature.from_rbs_error(exn, factory: factory)
       end
     end

data/lib/steep/source.rb

@@ -71,7 +71,11 @@ module Steep
 
       mapping = {}.compare_by_identity
 
-      construct_mapping(node: node, annotations: annotations, mapping: mapping)
+      if node
+        construct_mapping(node: node, annotations: annotations, mapping: mapping)
+      else
+        Steep.logger.fatal { "#{path} is empty source code" }
+      end
 
       annotations.each do |annot|
         mapping[node] ||= []

data/lib/steep/subtyping/cache.rb

@@ -0,0 +1,30 @@
+module Steep
+  module Subtyping
+    class Cache
+      attr_reader :subtypes
+
+      def initialize
+        @subtypes = {}
+      end
+
+      def subtype(relation, self_type, instance_type, class_type, bounds)
+        key = [relation, self_type, instance_type, class_type, bounds]
+        subtypes[key]
+      end
+
+      def [](relation, self_type, instance_type, class_type, bounds)
+        key = [relation, self_type, instance_type, class_type, bounds]
+        subtypes[key]
+      end
+
+      def []=(relation, self_type, instance_type, class_type, bounds, value)
+        key = [relation, self_type, instance_type, class_type, bounds]
+        subtypes[key] = value
+      end
+
+      def no_subtype_cache?
+        @subtypes.empty?
+      end
+    end
+  end
+end