Merge pull request #40 from ruby/validate-variance

Validate variance

Author: soutaro

lib/ruby/signature.rb

@@ -22,6 +22,7 @@
 require "ruby/signature/builtin_names"
 require "ruby/signature/definition"
 require "ruby/signature/definition_builder"
+require "ruby/signature/variance_calculator"
 require "ruby/signature/substitution"
 require "ruby/signature/constant"
 require "ruby/signature/constant_table"

lib/ruby/signature/ast/declarations.rb

@@ -53,6 +53,15 @@ def empty?
           def size
             params.size
           end
+
+          def rename_to(names)
+            ModuleTypeParams.new().tap do |params|
+              names.each.with_index do |new_name, index|
+                param = self.params[index]
+                params.add(TypeParam.new(name: new_name, variance: param.variance, skip_validation: param.skip_validation))
+              end
+            end
+          end
         end
 
         class Class

lib/ruby/signature/definition_builder.rb

@@ -506,8 +506,88 @@ def build_one_instance(type_name, extension_name: nil)
                 )
               end
             end
+
+            validate_parameter_variance(
+              decl: decl,
+              methods: definition.methods
+            )
+          end
+        end
+      end
+
+      def validate_params_with(type_params, result:)
+        type_params.each do |param|
+          unless param.skip_validation
+            unless result.compatible?(param.name, with_annotation: param.variance)
+              yield param
+            end
+          end
+        end
+      end
+
+      def validate_parameter_variance(decl:, methods:)
+        type_params = case decl
+                      when AST::Declarations::Extension
+                        env.find_class(decl.name.absolute!).type_params.rename_to(decl.type_params)
+                      else
+                        decl.type_params
+                      end
+
+        namespace = decl.name.absolute!.to_namespace
+        calculator = VarianceCalculator.new(builder: self)
+        param_names = type_params.each.map(&:name)
+
+        errors = []
+
+        if decl.is_a?(AST::Declarations::Class)
+          if decl.super_class
+            absolute_super_name = absolute_type_name(decl.super_class.name, namespace: namespace, location: decl.location)
+            absolute_args = decl.super_class.args.map {|type| absolute_type(type, namespace: namespace) }
+            result = calculator.in_inherit(name: absolute_super_name, args: absolute_args, variables: param_names)
+
+            validate_params_with type_params, result: result do |param|
+              errors.push InvalidVarianceAnnotationError::InheritanceError.new(
+                param: param
+              )
+            end
+          end
+        end
+
+        decl.members.each do |member|
+          case member
+          when AST::Members::Include
+            if member.name.class?
+              absolute_module_name = absolute_type_name(member.name, namespace: namespace, location: decl.location)
+              absolute_args = member.args.map {|type| absolute_type(type, namespace: namespace) }
+              result = calculator.in_inherit(name: absolute_module_name, args: absolute_args, variables: param_names)
+
+              validate_params_with type_params, result: result do |param|
+                errors.push InvalidVarianceAnnotationError::MixinError.new(
+                  include_member: member,
+                  param: param
+                )
+              end
+            end
           end
         end
+
+        methods.each do |name, method|
+          method.method_types.each do |method_type|
+            result = calculator.in_method_type(method_type: method_type, variables: param_names)
+
+            validate_params_with type_params, result: result do |param|
+              errors.push InvalidVarianceAnnotationError::MethodTypeError.new(
+                method_name: name,
+                method_type: method_type,
+                param: param
+              )
+            end
+          end
+        end
+
+        unless errors.empty?
+          raise InvalidVarianceAnnotationError.new(decl: decl, errors: errors)
+        end
       end
 
       def build_one_singleton(type_name, extension_name: nil)

lib/ruby/signature/errors.rb

@@ -154,5 +154,21 @@ def initialize(name, *decls)
         super "#{Location.to_string decls.last.location}: Duplicated declaration: #{name}"
       end
     end
+
+    class InvalidVarianceAnnotationError < StandardError
+      MethodTypeError = Struct.new(:method_name, :method_type, :param, keyword_init: true)
+      InheritanceError = Struct.new(:super_class, :param, keyword_init: true)
+      MixinError = Struct.new(:include_member, :param, keyword_init: true)
+
+      attr_reader :decl
+      attr_reader :errors
+
+      def initialize(decl:, errors:)
+        @decl = decl
+        @errors = errors
+
+        super "#{Location.to_string decl.location}: Invalid variance annotation: #{decl.name}"
+      end
+    end
   end
 end

lib/ruby/signature/types.rb

@@ -708,6 +708,20 @@ def each_type
           end
         end
 
+        def each_param(&block)
+          if block_given?
+            required_positionals.each(&block)
+            optional_positionals.each(&block)
+            rest_positionals&.yield_self(&block)
+            trailing_positionals.each(&block)
+            required_keywords.each_value(&block)
+            optional_keywords.each_value(&block)
+            rest_keywords&.yield_self(&block)
+          else
+            enum_for :each_param
+          end
+        end
+
         def to_json(*a)
           {
             required_positionals: required_positionals,

lib/ruby/signature/variance_calculator.rb

@@ -0,0 +1,140 @@
+module Ruby
+  module Signature
+    class VarianceCalculator
+      class Result
+        attr_reader :result
+
+        def initialize(variables:)
+          @result = {}
+          variables.each do |x|
+            result[x] = :unused
+          end
+        end
+
+        def covariant(x)
+          case result[x]
+          when :unused
+            result[x] = :covariant
+          when :contravariant
+            result[x] = :invariant
+          end
+        end
+
+        def contravariant(x)
+          case result[x]
+          when :unused
+            result[x] = :contravariant
+          when :covariant
+            result[x] = :invariant
+          end
+        end
+
+        def invariant(x)
+          result[x] = :invariant
+        end
+
+        def each(&block)
+          result.each(&block)
+        end
+
+        def include?(name)
+          result.key?(name)
+        end
+
+        def compatible?(var, with_annotation:)
+          variance = result[var]
+
+          case
+          when variance == :unused
+            true
+          when with_annotation == :invariant
+            true
+          when variance == with_annotation
+            true
+          else
+            false
+          end
+        end
+      end
+
+      attr_reader :builder
+
+      def initialize(builder:)
+        @builder = builder
+      end
+
+      def env
+        builder.env
+      end
+
+      def in_method_type(method_type:, variables:)
+        result = Result.new(variables: variables)
+
+        method_type.type.each_param do |param|
+          type(param.type, result: result, context: :contravariant)
+        end
+
+        if method_type.block
+          method_type.block.type.each_param do |param|
+            type(param.type, result: result, context: :covariant)
+          end
+          type(method_type.block.type.return_type, result: result, context: :contravariant)
+        end
+
+        type(method_type.type.return_type, result: result, context: :covariant)
+
+        result
+      end
+
+      def in_inherit(name:, args:, variables:)
+        type = Types::ClassInstance.new(name: name, args: args, location: nil)
+
+        Result.new(variables: variables).tap do |result|
+          type(type, result: result, context: :covariant)
+        end
+      end
+
+      def type(type, result:, context:)
+        case type
+        when Types::Variable
+          if result.include?(type.name)
+            case context
+            when :covariant
+              result.covariant(type.name)
+            when :contravariant
+              result.contravariant(type.name)
+            when :invariant
+              result.invariant(type.name)
+            end
+          end
+        when Types::ClassInstance, Types::Interface
+          decl = env.find_class(type.name)
+          type.args.each.with_index do |ty, i|
+            var = decl.type_params.params[i]
+            case var.variance
+            when :invariant
+              type(ty, result: result, context: :invariant)
+            when :covariant
+              type(ty, result: result, context: context)
+            when :contravariant
+              con = case context
+                    when :invariant
+                      :invariant
+                    when :covariant
+                      :contravariant
+                    when :contravariant
+                      :covariant
+                    end
+              type(ty, result: result, context: con)
+            end
+          end
+        when Types::Tuple, Types::Record, Types::Union, Types::Intersection
+          # Covariant types
+          type.each_type do |ty|
+            type(ty, result: result, context: context)
+          end
+        end
+      end
+    end
+  end
+end