Gecko [ v3.cesa.co.za ]

Name	Size	Permission	Date
annotate	[ DIR ]	drwxr-xr-x	2025-06-05 11:22
ast	[ DIR ]	drwxr-xr-x	2025-06-05 11:22
collection	[ DIR ]	drwxr-xr-x	2025-06-05 11:22
definition_builder	[ DIR ]	drwxr-xr-x	2025-06-05 11:22
parser_compat	[ DIR ]	drwxr-xr-x	2025-06-05 11:22
prototype	[ DIR ]	drwxr-xr-x	2025-06-05 11:22
test	[ DIR ]	drwxr-xr-x	2025-06-05 11:22
ancestor_graph.rb	2.47 KB	-rw-r--r--	2022-04-12 11:11
annotate.rb	157 B	-rw-r--r--	2022-04-12 11:11
buffer.rb	1 KB	-rw-r--r--	2022-04-12 11:11
builtin_names.rb	1.59 KB	-rw-r--r--	2022-04-12 11:11
char_scanner.rb	292 B	-rw-r--r--	2022-04-12 11:11
cli.rb	27.19 KB	-rw-r--r--	2022-04-12 11:11
collection.rb	295 B	-rw-r--r--	2022-04-12 11:11
constant.rb	461 B	-rw-r--r--	2022-04-12 11:11
constant_table.rb	5.04 KB	-rw-r--r--	2022-04-12 11:11
definition.rb	9.47 KB	-rw-r--r--	2022-04-12 11:11
definition_builder.rb	32.63 KB	-rw-r--r--	2022-04-12 11:11
environment.rb	15.26 KB	-rw-r--r--	2022-04-12 11:11
environment_loader.rb	3.32 KB	-rw-r--r--	2022-04-12 11:11
environment_walker.rb	4.2 KB	-rw-r--r--	2022-04-12 11:11
errors.rb	11.68 KB	-rw-r--r--	2022-04-12 11:11
factory.rb	301 B	-rw-r--r--	2022-04-12 11:11
location_aux.rb	2.73 KB	-rw-r--r--	2022-04-12 11:11
locator.rb	5.39 KB	-rw-r--r--	2022-04-12 11:11
method_type.rb	2.65 KB	-rw-r--r--	2022-04-12 11:11
namespace.rb	2.12 KB	-rw-r--r--	2022-04-12 11:11
parser_aux.rb	1.3 KB	-rw-r--r--	2022-04-12 11:11
repository.rb	2.83 KB	-rw-r--r--	2022-04-12 11:11
substitution.rb	1.23 KB	-rw-r--r--	2022-04-12 11:11
test.rb	2.57 KB	-rw-r--r--	2022-04-12 11:11
type_alias_dependency.rb	2.82 KB	-rw-r--r--	2022-04-12 11:11
type_alias_regularity.rb	3.14 KB	-rw-r--r--	2022-04-12 11:11
type_name.rb	1.63 KB	-rw-r--r--	2022-04-12 11:11
type_name_resolver.rb	1.56 KB	-rw-r--r--	2022-04-12 11:11
types.rb	27.19 KB	-rw-r--r--	2022-04-12 11:11
validator.rb	4.6 KB	-rw-r--r--	2022-04-12 11:11
variance_calculator.rb	4.45 KB	-rw-r--r--	2022-04-12 11:11
vendorer.rb	2.03 KB	-rw-r--r--	2022-04-12 11:11
version.rb	35 B	-rw-r--r--	2022-04-12 11:11
writer.rb	7.91 KB	-rw-r--r--	2022-04-12 11:11

Rename

module RBS
  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

def incompatible?(params)
        # @type set: Hash[Symbol]
        set = Set[]

params.each do |param|
          unless compatible?(param.name, with_annotation: param.variance)
            set << param.name
          end
        end

unless set.empty?
          set
        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)

function(method_type.type, result: result, context: :covariant)

if block = method_type.block
        function(block.type, result: result, context: :contravariant)
      end

result
    end

def in_inherit(name:, args:, variables:)
      type = if name.class?
               Types::ClassInstance.new(name: name, args: args, location: nil)
             else
               Types::Interface.new(name: name, args: args, location: nil)
             end

Result.new(variables: variables).tap do |result|
        type(type, result: result, context: :covariant)
      end
    end

def in_type_alias(name:)
      decl = env.alias_decls[name].decl or raise
      variables = decl.type_params.each.map(&:name)
      Result.new(variables: variables).tap do |result|
        type(decl.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, Types::Alias
        NoTypeFoundError.check!(type.name,
                                env: env,
                                location: type.location)

type_params = case type
                      when Types::ClassInstance
                        env.class_decls[type.name].type_params
                      when Types::Interface
                        env.interface_decls[type.name].decl.type_params
                      when Types::Alias
                        env.alias_decls[type.name].decl.type_params
                      end

type.args.each.with_index do |ty, i|
          if var = type_params[i]
            case var.variance
            when :invariant
              type(ty, result: result, context: :invariant)
            when :covariant
              type(ty, result: result, context: context)
            when :contravariant
              type(ty, result: result, context: negate(context))
            end
          end
        end
      when Types::Proc
        function(type.type, result: result, context: context)
      else
        type.each_type do |ty|
          type(ty, result: result, context: context)
        end
      end
    end

def function(type, result:, context:)
      type.each_param do |param|
        type(param.type, result: result, context: negate(context))
      end
      type(type.return_type, result: result, context: context)
    end

def negate(variance)
      case variance
      when :invariant
        :invariant
      when :covariant
        :contravariant
      when :contravariant
        :covariant
      else
        raise
      end
    end
  end
end