typed.rb 0.0.11

data/lib/typed/runtime/normalization/validations.rb

@@ -0,0 +1,47 @@
+module TypedRb
+  module Runtime
+    module Normalization
+      module Validations
+        def validate_signature(type, normalized_signature)
+          return if type == :class_variable || type == :instance_variable
+          return if normalized_signature.is_a?(TypedRb::Types::TyFunction)
+          fail ::TypedRb::Types::TypeParsingError,
+               "Error parsing receiver, method signature: #{type} :: '#{normalized_signature}'"
+        end
+
+        def validate_signatures(normalized_signatures, klass, method)
+          arities = normalized_signatures.map(&:arity)
+          duplicated_arities = arities.select { |arity| arities.count(arity) > 1 }
+          duplicated_arities.each do |arity|
+            duplicated = normalized_signatures.select { |signature| signature.arity == arity }
+            unless duplicated.count == 2 && duplicated.first.block_type.nil? != duplicated.last.block_type.nil?
+              error_message = "Duplicated arity '#{arity}' for method '#{klass}' / '#{method}'"
+              fail ::TypedRb::Types::TypeParsingError, error_message
+            end
+          end
+        end
+
+        def validate_method(class_methods_info, klass, method, method_type)
+          if method_type == :instance
+            unless (class_methods_info[:instance_methods]).include?(method.to_sym)
+              fail ::TypedRb::Types::TypeParsingError,
+                   "Declared typed instance method '#{method}' not found for class '#{klass}'"
+            end
+          elsif method_type == :class
+            unless class_methods_info[:all_methods].include?(method.to_sym)
+              fail ::TypedRb::Types::TypeParsingError,
+                   "Declared typed class method '#{method}' not found for class '#{klass}'"
+            end
+          end
+        end
+
+        def validate_function_signature(klass, method, signature, method_type)
+          if signature.is_a?(Hash)
+            join = method_type == :instance ? '#' : '::'
+            fail ::TypedRb::Types::TypeParsingError, "Declared method #{klass}#{join}#{method}(#{signature}) is not a valid arrow"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/typed/runtime/normalization.rb

@@ -0,0 +1,196 @@
+require_relative '../runtime'
+
+module TypedRb
+  module Runtime
+    module Normalization
+      include Validations
+      ts '#normalize_generic_types! / -> unit'
+      def normalize_generic_types!
+        initial_value = @generic_types_registry || Hash.call(Class, TypedRb::Types::TyGenericSingletonObject).new
+        @generic_types_registry = generic_types_parser_registry.each_with_object(initial_value) do |type_info, acc|
+          generic_singleton_object = build_generic_singleton_object(type_info)
+          acc[generic_singleton_object.ruby_type] = generic_singleton_object
+        end
+        generic_types_parser_registry.each do |type_info|
+          check_generic_super_type(type_info)
+        end
+      end
+
+      ts '#normalize_methods! / -> unit'
+      def normalize_methods!
+        @registry = @registry || {}
+        parser_registry.each_pair do |object_key, method_signatures|
+          method_type, class_name = parse_object_key(object_key)
+          klass = parse_class(class_name)
+          @registry[[method_type, klass]] = normalize_method_signatures(method_signatures, klass, method_type)
+        end
+      end
+
+      ts '#check_super_type_annotations / -> unit'
+      def check_super_type_annotations
+        @generic_types_registry.values.each do |type|
+          type.super_type.self_materialize if type.super_type
+        end
+      end
+
+      def build_generic_singleton_object(type_info)
+        type_class, info = type_info
+        TypedRb.log(binding, :debug,  "Normalising generic type: #{type_class}")
+        info[:type] = Class.for_name(type_class)
+        info[:parameters] = info[:parameters].map do |parameter|
+          ::TypedRb::Runtime::TypeParser.parse(parameter, info[:type])
+        end
+        ::TypedRb::Types::TyGenericSingletonObject.new(info[:type], info[:parameters])
+      end
+
+      def check_generic_super_type(type_info)
+        _, info = type_info
+        super_type = build_generic_super_type(info)
+        @generic_types_registry[info[:type]].super_type = super_type if super_type
+      end
+
+      def build_generic_super_type(info)
+        with_super_type = valid_super_type?(info[:type], info[:super_type])
+        if with_super_type
+          TypedRb.log(binding, :debug,  "Normalising generic super type: #{info[:super_type][:type]} for #{info[:type]}")
+          build_generic_singleton_object([info[:super_type][:type], info[:super_type]])
+        end
+      end
+
+      def valid_super_type?(base_class, super_type_info)
+        return false if super_type_info.nil?
+        valid = base_class.ancestors.map(&:name).detect { |klass_name| klass_name == super_type_info[:type].to_s }
+        return true if valid
+        fail ::TypedRb::Types::TypeParsingError,
+             "Super type annotation '#{super_type_info[:type]}' not a super class of '#{base_class}'"
+      end
+
+      def parse_class(class_name)
+        return :main if class_name == :main
+        Class.for_name(class_name.to_s)
+      end
+
+      def find_methods(klass)
+        return find_methods_for_top_level_object if klass == :main
+        find_methods_for_class(klass)
+      end
+
+      def collect_methods(object, options)
+        messages = if options[:instance]
+                     [:public_instance_methods, :protected_instance_methods, :private_instance_methods]
+                   else
+                     [:public_methods, :protected_methods, :private_methods]
+                   end
+        messages.inject([]) do |acc, message|
+          acc + object.send(message)
+        end
+      end
+
+      def find_methods_for_top_level_object
+        all_instance_methods = collect_methods(TOPLEVEL_BINDING, instance: false)
+        all_methods = collect_methods(TOPLEVEL_BINDING.receiver.class, instance: false)
+        build_class_methods_info(:main, all_instance_methods, all_methods)
+      end
+
+      def find_methods_for_class(klass)
+        all_instance_methods = collect_methods(klass, instance: true)
+        all_methods = collect_methods(klass, instance: false)
+        build_class_methods_info(klass, all_instance_methods, all_methods)
+      end
+
+      def build_class_methods_info(klass, all_instance_methods, all_methods)
+        {
+          :class            => klass,
+          :instance_methods => all_instance_methods,
+          :all_methods      => all_methods
+        }
+      end
+
+      ts '#normalize_signature! / Class -> String -> TypedRb::Types::TyFunction'
+      def normalize_signature!(klass, type)
+        normalized_signature = ::TypedRb::Runtime::TypeParser.parse(type, klass)
+        ::TypedRb::Model::TmFun.with_fresh_bindings(klass, normalized_signature)
+      end
+
+      def normalize_method_signatures(method_signatures, klass, method_type)
+        method_signatures.each_with_object({}) do |method_info, signatures_acc|
+          method, signatures = method_info
+          validate_method(find_methods(klass), klass, method, method_type)
+          normalized_signatures = signatures.map do |signature|
+            validate_function_signature(klass, method, signature, method_type)
+            normalized_method = normalize_signature!(klass, signature)
+            validate_signature(method_type, normalized_method)
+            compute_parameters_info(method_type, klass, method, normalized_method, signature)
+            normalized_method
+          end
+          if method_type == :instance_variable || method_type == :class_variable
+            # TODO: print a warning if the declaration of the variable is duplicated
+            signatures_acc[method] = normalized_signatures.first
+          else
+            validate_signatures(normalized_signatures, klass, method)
+            signatures_acc[method] = normalized_signatures.sort { |fa, fb| fa.arity <=> fb.arity }
+          end
+        end
+      end
+
+      def compute_parameters_info(method_type, klass, method, normalized_method, signature)
+        return if method_type == :instance_variable || method_type == :class_variable
+        ruby_params = if method_type == :instance
+                        if klass == :main
+                          TOPLEVEL_BINDING.receiver.method(method).parameters
+                        else
+                          klass.instance_method(method).parameters
+                        end
+                      else
+                        if klass == :main
+                          TOPLEVEL_BINDING.receiver.class.method(method).parameters
+                        else
+                          klass.method(method).parameters
+                        end
+                      end
+        ruby_params_clean = ruby_params.reject { |(kind, _)| kind == :block }
+        min, max = ruby_params_clean.each_with_object([0, 0]) do |(kind, _), acc|
+          acc[1] += 1
+          acc[1] = Float::INFINITY if kind == :rest
+          acc[0] += 1 if kind == :req
+        end
+
+        signature_clean = signature.reject { |acc| acc.is_a?(Hash) && acc[:kind] == :block_arg }
+        if signature_clean.count < min || signature_clean.count > max
+          fail ::TypedRb::Types::TypeParsingError,
+               "Type signature declaration for method '#{klass}.#{method}': '#{signature_clean}' inconsistent with method parameters #{ruby_params.inspect}"
+        end
+
+        count = 0
+        parameters_info = signature_clean.map do |signature_value|
+          type, name = if count > ruby_params_clean.count
+                         ruby_params_clean.last
+                       else
+                         ruby_params_clean[count]
+                       end
+          count += 1
+
+          if signature_value.is_a?(Hash) && signature_value[:kind] == :rest
+            [:rest, name]
+          elsif type == :rest
+            [:opt, name]
+          else
+            [type, name]
+          end
+        end
+
+        normalized_method.parameters_info = parameters_info
+      end
+
+      ts '#object_key / String -> String -> String'
+      def object_key(kind, receiver)
+        "#{kind}|#{receiver}"
+      end
+
+      ts '#parse_object_key / String -> Symbol'
+      def parse_object_key(object_key)
+        object_key.split('|').map(&:to_sym)
+      end
+    end
+  end
+end

data/lib/typed/runtime/parser_context.rb

@@ -0,0 +1,36 @@
+module TypedRb
+  # Helper class used to keep an stack of type signatures
+  # being parsed.
+  class ParsingContext
+    def initialize
+      @types_stack = []
+    end
+
+    def push(type)
+      @types_stack << type
+    end
+
+    def pop
+      @types_stack.pop
+    end
+
+    def with_type(type)
+      push type
+      result = yield
+      pop
+      result
+    end
+
+    def context_name
+      @types_stack.last.join('::')
+    end
+
+    def path_name
+      @types_stack.map { |key| key[1] }.join('::')
+    end
+
+    def singleton_class?
+      @types_stack.last.first == :self rescue false
+    end
+  end
+end

data/lib/typed/runtime/type_parser.rb

@@ -0,0 +1,215 @@
+require_relative '../runtime'
+
+module TypedRb
+  module Runtime
+    class TypeParser
+      class << self
+        def parse(type, klass)
+          fail TypedRb::Types::TypeParsingError, 'Error parsing type: nil value.' if type.nil?
+          if type == 'unit'
+            Types::TyUnit.new
+          elsif type == 'Boolean'
+            Types::TyBoolean.new
+          elsif type.is_a?(Array)
+            parse_function_type(type, klass)
+          elsif type.is_a?(Hash) && (type[:kind] == :type_var || type[:kind] == :method_type_var)
+            maybe_class = Class.for_name(type[:type]) rescue false
+            if maybe_class
+              type[:type] = maybe_class
+            else
+              type[:type] = "#{klass}:#{type[:type]}"
+            end
+            parse_type_var(type)
+          elsif type.is_a?(Hash) && type[:kind] == :generic_type
+            parse_concrete_type(type, klass)
+          elsif type.is_a?(Hash) && type[:kind] == :rest
+            parse_rest_args(type, klass)
+          elsif type == :unit
+            Types::TyUnit.new
+          else
+            parse_singleton_object_type(type)
+          end
+        end
+
+        def parse_type_var(type)
+          if type[:binding] == '<'
+            upper_bound = Class.for_name(type[:bound]) rescue type[:bound]
+            upper_bound = if upper_bound.is_a?(Module)
+                            Types::TySingletonObject.new(upper_bound)
+                          else
+                            Types::Polymorphism::TypeVariable.new(upper_bound, :gen_name => false)
+                          end
+            Types::Polymorphism::TypeVariable.new(type[:type],
+                                                  :upper_bound => upper_bound,
+                                                  :gen_name    => false)
+          elsif type[:binding] == '>'
+            lower_bound = Class.for_name(type[:bound])
+            lower_bound = if lower_bound.is_a?(Module)
+                            Types::TySingletonObject.new(lower_bound)
+                          else
+                            Types::Polymorphism::TypeVariable.new(lower_bound, :gen_name => false)
+                          end
+            Types::Polymorphism::TypeVariable.new(type[:type],
+                                                  :lower_bound => lower_bound,
+                                                  :gen_name    => false)
+          elsif type[:type].is_a?(Module)
+            type_object = Types::TyObject.new(type[:type])
+            type_var = Types::Polymorphism::TypeVariable.new("#{type[:type]}:T",
+                                                             :gen_name => false,
+                                                             :upper_bound => type_object,
+                                                             :lower_bound => type_object)
+            type_var.bind(type_object)
+            type_var
+          else
+            Types::Polymorphism::TypeVariable.new(type[:type], :gen_name => false)
+          end
+        end
+
+        def parse_rest_args(type,  klass)
+          parsed_parameter = parse(type[:parameters].first, klass)
+          if parsed_parameter.is_a?(Types::Polymorphism::TypeVariable) ||
+             parsed_parameter.is_a?(Types::TyGenericSingletonObject)
+            # TODO: should I use #parse_singleton_object_type here?
+            Types::TyGenericSingletonObject.new(Array, [parsed_parameter])
+          else
+            type_var = Types::Polymorphism::TypeVariable.new('Array:T', :gen_name => false,
+                                                                        :upper_bound => parsed_parameter,
+                                                                        :lower_bound => parsed_parameter)
+            type_var.bind(parsed_parameter)
+            Types::TyGenericObject.new(Array, [type_var])
+          end
+        end
+
+        def parse_concrete_type(type, klass)
+          # parameter_names -> container class type vars
+          TypedRb.log(binding, :debug, "Parsing concrete type #{type} within #{klass}")
+
+          #TODO: GET RID OF THIS?
+          parameter_names = BasicObject::TypeRegistry.type_vars_for(klass).each_with_object({}) do |variable, acc|
+            acc[variable.name.split(':').last] = variable
+          end
+          # this is the concrete argument to parse
+          # it might refer to type vars in the container class
+          ruby_type = Class.for_name(type[:type])
+          is_generic = false
+          concrete_type_vars = []
+          # for each parameter:
+          # - klass.is_variable? -> variable -> generic singletion
+          # - klass.is not variable? ->  bound_type -> generic object
+          rrt = BasicObject::TypeRegistry.type_vars_for(ruby_type)
+          rrt.each_with_index do |type_var, i|
+            #TODO: GET RID OF THIS?
+            param = type[:parameters][i]
+            maybe_bound_param = parameter_names[param[:type]]
+            parsed_type_var = if maybe_bound_param
+                                is_generic = true
+                                maybe_bound_param
+                              else
+                                if param[:kind] == :generic_type
+                                  # It is a nested generic type
+                                  #klass = Class.for_name(param[:type])
+                                  bound = parse(param, klass)
+                                  concrete_param = Types::Polymorphism::TypeVariable.new(type_var.name,
+                                                                                         :upper_bound => bound,
+                                                                                         :lower_bound => bound,
+                                                                                         :gen_name => false)
+                                  concrete_param.bind(bound)
+                                  is_generic = bound.is_a?(Types::TyGenericSingletonObject) ? true : false
+                                  concrete_param
+                                elsif param[:bound]
+                                  # A type parameter that is not bound in the generic type declaration.
+                                  # It has to be local to the method or a wildcard '?'
+                                  is_generic = true
+                                  # TODO: add some reference to the method if the variable is method specific?
+                                  if param[:type] == '?' # [? < Type]
+                                    param[:type] = "#{type_var.name}:#{type_application_counter}:#{param[:type]}"
+                                  else # [E < Type]
+                                    param[:type] = "#{type_var.name}:#{param[:type]}:#{type_application_counter}"
+                                  end
+                                  parse(param, klass)
+                                elsif param[:type] == '?' # [?]
+                                  is_generic = true
+                                  Types::Polymorphism::TypeVariable.new(param[:type], :gen_name => false)
+                                elsif param[:sub_kind] == :method_type_var # method[E] / [E]
+                                  # A type parameter that is not bound in the generic type declaration.
+                                  # It has to be local to the method
+                                  is_generic = true
+                                  Types::Polymorphism::TypeVariable.new("#{klass}:#{param[:type]}", :gen_name => false)
+                                else  # [Type]
+                                  begin
+                                    # The Generic type is bound to a concrete type: bound == upper_bound == lower_bound
+                                    bound = Types::TySingletonObject.new(Class.for_name(param[:type]))
+                                    concrete_param = Types::Polymorphism::TypeVariable.new(type_var.name,
+                                                                                           :upper_bound => bound,
+                                                                                           :lower_bound => bound,
+                                                                                           :gen_name => false)
+                                    concrete_param.bind(bound)
+                                    concrete_param
+                                  rescue NameError # [E] / E != ruby type
+                                    # TODO: transform this into the method_type_var shown before
+                                    is_generic = true
+                                    Types::Polymorphism::TypeVariable.new(param[:type], :gen_name => false)
+                                  end
+                                end
+                              end
+            concrete_type_vars << parsed_type_var
+          end
+
+          if is_generic
+            Types::TyGenericSingletonObject.new(ruby_type, concrete_type_vars)
+          else
+            Types::TyGenericObject.new(ruby_type, concrete_type_vars)
+          end
+        end
+
+        def type_application_counter
+          @type_application_counter ||= 0
+          @type_application_counter += 1
+        end
+
+        def parse_existential_object_type(type)
+          ruby_type = Class.for_name(type)
+          BasicObject::TypeRegistry.find_existential_type(ruby_type)
+        rescue StandardError => e
+          TypedRb.log(binding, :error, "Error parsing existential object from type #{type}, #{e.message}")
+          raise TypedRb::Types::TypeParsingError, "Unknown Ruby type #{type}"
+        end
+
+        def parse_singleton_object_type(type, node = nil)
+          ruby_type = Class.for_name(type)
+          generic_type = BasicObject::TypeRegistry.find_generic_type(ruby_type)
+          if generic_type
+            generic_type.node = node
+            generic_type
+          else
+            Types::TySingletonObject.new(ruby_type, node)
+          end
+        rescue StandardError => e
+          TypedRb.log(binding, :error, "Error parsing singleton object from type #{type}, #{e.message}")
+          raise TypedRb::Types::TypeParsingError, "Unknown Ruby type #{type}"
+        end
+
+        def parse_function_type(arg_types, klass)
+          return_type = parse(arg_types.pop, klass)
+          block_type = if arg_types.last.is_a?(Hash) && arg_types.last[:kind] == :block_arg
+                         block_type = arg_types.pop
+                         parse_function_type(block_type[:block], klass)
+                       end
+          parsed_arg_types = arg_types.map { |arg| parse(arg, klass) }
+          is_generic = (parsed_arg_types + [return_type]).any? do |var|
+            var.is_a?(Types::TyGenericSingletonObject) ||
+            var.is_a?(Types::Polymorphism::TypeVariable)
+          end
+
+          is_generic ||= block_type.generic? if block_type
+
+          function_class = is_generic ? Types::TyGenericFunction : Types::TyFunction
+          function_type = function_class.new(parsed_arg_types, return_type, arg_types)
+          function_type.local_typing_context = Types::TypingContext.empty_typing_context if function_type.generic?
+          function_type.with_block_type(block_type) if block_type
+          function_type
+        end
+      end
+    end
+  end
+end

data/lib/typed/runtime/type_registry.rb

@@ -0,0 +1,170 @@
+require_relative '../runtime'
+
+class BasicObject
+  class TypeRegistry
+    class << self
+      include TypedRb::Runtime::Normalization
+
+      ts '.clear_parsing_registries / -> unit'
+      def clear_parsing_registries
+        generic_types_parser_registry.clear
+        parser_registry.clear
+      end
+
+      ts '.clear / -> unit'
+      def clear
+        generic_types_registry.clear
+        registry.clear
+        clear_parsing_registries
+      end
+
+      ts '.register_type_information / Symbol -> String -> String -> Object -> unit'
+      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
+
+      ts '.register_generic_type_information / Hash[Object][Object] -> Hash[Object][Object] -> unit'
+      def register_generic_type_information(generic_type_information, generic_super_type_information)
+        unless generic_type_information.is_a?(String) # TODO: String when super annotations for non-generic types
+          generic_type_information[:super_type] = generic_super_type_information
+          if generic_types_parser_registry[generic_type_information[:type]]
+            fail ::TypedRb::Types::TypeParsingError,
+            "Duplicated generic type definition for #{generic_type_information[:type]}"
+          else
+            generic_types_parser_registry[generic_type_information[:type]] = generic_type_information
+          end
+        end
+      end
+
+      def find_existential_type(type)
+        existential_type = existential_types_registry[type]
+        if existential_type.nil?
+          existential_type = TypedRb::Types::TyExistentialType.new(type)
+          @existential_types_registry[type] = existential_type
+        end
+        existential_type
+      end
+
+      ts '.find_generic_type / Class -> TypedRb::Types::TyGenericSingletonObject'
+      def find_generic_type(type)
+        @generic_types_registry[type]
+      end
+
+      ts '.type_vars_for / Class -> Array[TypedRb::Types::Polymorphism::TypeVariable]'
+      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
+
+      ts '.type_var? / Class -> String -> Boolean'
+      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
+
+      # TODO: Generic types are retrieved without enforcing type constraints
+      # because they haven't been materialised.
+      ts '.find / Symbol -> Class -> String -> Array[TypedRb::Types::TyFunction]'
+      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
+
+      ts '.registered? / Class -> Boolean'
+      def registered?(klass)
+        registered_classes = registry.keys.map(&:last)
+        registered_classes.include?(klass)
+      end
+
+      ts '.normalize_types! / -> unit'
+      def normalize_types!
+        normalize_generic_types!
+        normalize_methods!
+      end
+
+      def registry=(registry)
+        @registry = registry
+      end
+
+      def generic_types_registry=(registry)
+        @generic_types_registry = registry
+      end
+
+      def existential_types_registry=(registry)
+        @existential_types_registry = registry
+      end
+
+      protected
+
+      ts '.registry / -> Hash[ Array[Object] ][ Hash[String][TypedRb::Types::TyFunction] ]'
+      def registry
+        @registry ||= {}
+        @registry
+      end
+
+      def existential_types_registry
+        @existential_types_registry ||= {}
+      end
+
+      ts '.generic_types_registry / -> Hash[Class][ TypedRb::Types::TyGenericSingletonObject ]'
+      def generic_types_registry
+        @generic_types_registry ||= {}
+        @generic_types_registry
+      end
+
+      ts '.parser_registry / -> Hash[ String ][ Hash[String][Object] ]'
+      def parser_registry
+        @parser_registry ||= {}
+        @parser_registry
+      end
+
+      ts '.generic_types_parser_registry / -> Hash[String][ Hash[Object][Object] ]'
+      def generic_types_parser_registry
+        @generic_types_parser_registry ||= {}
+        @generic_types_parser_registry
+      end
+
+      ts '.methods_for / Symbol -> String -> Hash[String][Object]'
+      def methods_for(kind, receiver)
+        method_registry = parser_registry[object_key(kind, receiver)] || {}
+        parser_registry[object_key(kind, receiver)] = method_registry
+        method_registry
+      end
+    end
+  end
+end