class BasicObject::TypeRegistry

Public Class Methods

clear() click to toggle source
# File lib/typed/runtime/type_registry.rb, line 17
def clear
  generic_types_registry.clear
  registry.clear
  clear_parsing_registries
end
clear_parsing_registries() click to toggle source
# File lib/typed/runtime/type_registry.rb, line 11
def clear_parsing_registries
  generic_types_parser_registry.clear
  parser_registry.clear
end
existential_types_registry=(registry) click to toggle source
# File lib/typed/runtime/type_registry.rb, line 141
def existential_types_registry=(registry)
  @existential_types_registry = registry
end
find(kind, klass, message) click to toggle source
# File lib/typed/runtime/type_registry.rb, line 98
def find(kind, klass, message)
  class_data = registry[[kind, klass]]
  if class_data
    # TODO: What should we when the class is in the registry but the method is missing?
    # The class has been typed but only partially?
    # Dynamic invocation or error?
    # Maybe an additional @dynamic annotation can be added to distinguish the desired outcome.
    # Preferred outcome might be nil to catch errors in unification, safer assumption.
    # class_data[message.to_s] || nil # ::TypedRb::Types::TyDynamicFunction.new(klass, message)
    class_data[message.to_s] || [::TypedRb::Types::TyDynamicFunction.new(klass, message)]
  elsif kind == :instance_variable || kind == :class_variable
    nil
  else
    # if registered?(klass)
    #   nil
    # else
    result = Array.('TypedRb::Types::TyFunction').new
    result << ::TypedRb::Types::TyDynamicFunction.new(klass, message)
    result
    # end
  end
end
find_existential_type(type) click to toggle source
# File lib/typed/runtime/type_registry.rb, line 49
def find_existential_type(type)
  existential_type = existential_types_registry[type]
  if existential_type.nil?
    generic_existential_type = generic_types_registry[type]
    existential_type = if generic_existential_type
                         TypedRb::Types::TyGenericExistentialType.new(type, generic_existential_type.type_vars)
                       else
                         TypedRb::Types::TyExistentialType.new(type)
                       end
    @existential_types_registry[type] = existential_type
  end
  existential_type
end
find_generic_type(type) click to toggle source
# File lib/typed/runtime/type_registry.rb, line 64
def find_generic_type(type)
  @generic_types_registry[type]
end
generic_types_registry=(registry) click to toggle source
# File lib/typed/runtime/type_registry.rb, line 137
def generic_types_registry=(registry)
  @generic_types_registry = registry
end
normalize_types!() click to toggle source
# File lib/typed/runtime/type_registry.rb, line 128
def normalize_types!
  normalize_generic_types!
  normalize_methods!
end
register_generic_type_information(generic_type_information, generic_super_types_information) click to toggle source
# File lib/typed/runtime/type_registry.rb, line 31
def register_generic_type_information(generic_type_information, generic_super_types_information)
  if generic_type_information.is_a?(String)
    # concrete type with a generic super type
    generic_type_information = {
        :type => generic_type_information,
        :parameters => [],
        :kind => :generic_type
    }
  end
  generic_type_information[:super_type] = generic_super_types_information
  if generic_types_parser_registry[generic_type_information[:type]]
    super_type = (generic_types_parser_registry[generic_type_information[:type]][:super_type] || [])
    generic_types_parser_registry[generic_type_information[:type]][:super_type]= super_type.concat(generic_type_information[:super_type])
  else
    generic_types_parser_registry[generic_type_information[:type]] = generic_type_information
  end
end
register_type_information(kind, receiver, method, type_ast) click to toggle source
# File lib/typed/runtime/type_registry.rb, line 24
def register_type_information(kind, receiver, method, type_ast)
  methods = methods_for(kind, receiver)[method] || []
  methods << type_ast
  methods_for(kind, receiver)[method] = methods
end
registered?(klass) click to toggle source
# File lib/typed/runtime/type_registry.rb, line 122
def registered?(klass)
  registered_classes = registry.keys.map(&:last)
  registered_classes.include?(klass)
end
registry=(registry) click to toggle source
# File lib/typed/runtime/type_registry.rb, line 133
def registry=(registry)
  @registry = registry
end
type_var?(klass, variable) click to toggle source
# File lib/typed/runtime/type_registry.rb, line 84
def type_var?(klass, variable)
  singleton_object = generic_types_registry[klass]
  if singleton_object
    singleton_object.type_vars.any? do |type_var|
      type_var.variable == variable
    end
  else
    false
  end
end
type_vars_for(klass) click to toggle source
# File lib/typed/runtime/type_registry.rb, line 69
def type_vars_for(klass)
  singleton_object = find_generic_type(klass)
  if singleton_object
    singleton_object.type_vars.map do |type_var|
      ::TypedRb::Types::Polymorphism::TypeVariable.new(type_var.variable,
                                                       :upper_bound => type_var.upper_bound,
                                                       :lower_bound => type_var.lower_bound,
                                                       :gen_name => false)
    end
  else
    Array.call(TypedRb::Types::Polymorphism::TypeVariable).new
  end
end

Protected Class Methods

existential_types_registry() click to toggle source
# File lib/typed/runtime/type_registry.rb, line 153
def existential_types_registry
  @existential_types_registry ||= {}
end
generic_types_parser_registry() click to toggle source
# File lib/typed/runtime/type_registry.rb, line 170
def generic_types_parser_registry
  @generic_types_parser_registry ||= {}
  @generic_types_parser_registry
end
generic_types_registry() click to toggle source
# File lib/typed/runtime/type_registry.rb, line 158
def generic_types_registry
  @generic_types_registry ||= {}
  @generic_types_registry
end
methods_for(kind, receiver) click to toggle source
# File lib/typed/runtime/type_registry.rb, line 176
def methods_for(kind, receiver)
  method_registry = parser_registry[object_key(kind, receiver)] || {}
  parser_registry[object_key(kind, receiver)] = method_registry
  method_registry
end
parser_registry() click to toggle source
# File lib/typed/runtime/type_registry.rb, line 164
def parser_registry
  @parser_registry ||= {}
  @parser_registry
end
registry() click to toggle source
# File lib/typed/runtime/type_registry.rb, line 148
def registry
  @registry ||= {}
  @registry
end