steep 0.16.0 → 0.16.1

data/vendor/ruby-signature/lib/rbs/constant.rb

@@ -1,26 +0,0 @@
-module RBS
-  class Constant
-    attr_reader :name
-    attr_reader :type
-    attr_reader :declaration
-
-    def initialize(name:, type:, declaration:)
-      @name = name
-      @type = type
-      @declaration = declaration
-    end
-
-    def ==(other)
-      other.is_a?(Constant) &&
-        other.name == name &&
-        other.type == type &&
-        other.declaration == declaration
-    end
-
-    alias eql? ==
-
-    def hash
-      self.class.hash ^ name.hash ^ type.hash ^ declaration.hash
-    end
-  end
-end

data/vendor/ruby-signature/lib/rbs/constant_table.rb

@@ -1,150 +0,0 @@
-module RBS
-  class ConstantTable
-    attr_reader :definition_builder
-    attr_reader :constant_scopes_cache
-
-    def env
-      definition_builder.env
-    end
-
-    def initialize(builder:)
-      @definition_builder = builder
-      @constant_scopes_cache = {}
-    end
-
-    def name_to_constant(name)
-      case
-      when env.name_to_constant.key?(name)
-        decl = env.name_to_constant[name]
-        type = env.absolute_type(decl.type, namespace: name.namespace) {|type| type.name.absolute! }
-        Constant.new(name: name, type: type, declaration: decl)
-      when env.class?(name)
-        decl = env.name_to_decl[name]
-        type = Types::ClassSingleton.new(name: name, location: nil)
-        Constant.new(name: name, type: type, declaration: decl)
-      end
-    end
-
-    def split_name(name)
-      name.namespace.path + [name.name]
-    end
-
-    def resolve_constant_reference(name, context:)
-      head, *tail = split_name(name)
-
-      head_constant = case
-                      when name.absolute?
-                        name_to_constant(TypeName.new(name: head, namespace: Namespace.root))
-                      when !context || context.empty?
-                        name_to_constant(TypeName.new(name: head, namespace: Namespace.root))
-                      else
-                        resolve_constant_reference_context(head, context: context) ||
-                          resolve_constant_reference_inherit(head,
-                                                             scopes: constant_scopes(context.to_type_name))
-                      end
-
-      if head_constant
-        tail.inject(head_constant) do |constant, name|
-          resolve_constant_reference_inherit name,
-                                             scopes: constant_scopes(constant.name),
-                                             no_object: constant.name != BuiltinNames::Object.name
-        end
-      end
-    end
-
-    def resolve_constant_reference_context(name, context:)
-      if context.empty?
-        nil
-      else
-        name_to_constant(TypeName.new(name: name, namespace: context)) ||
-          resolve_constant_reference_context(name, context: context.parent)
-      end
-    end
-
-    def resolve_constant_reference_inherit(name, scopes:, no_object: false)
-      scopes.each do |context|
-        if context.path == [:Object]
-          unless no_object
-            constant = name_to_constant(TypeName.new(name: name, namespace: context)) ||
-              name_to_constant(TypeName.new(name: name, namespace: Namespace.root))
-          end
-        else
-          constant = name_to_constant(TypeName.new(name: name, namespace: context))
-        end
-
-        return constant if constant
-      end
-
-      nil
-    end
-
-    def constant_scopes(name)
-      constant_scopes_cache[name] ||= constant_scopes0(name, scopes: [])
-    end
-
-    def constant_scopes_module(name, scopes:)
-      decl = env.find_class(name)
-      namespace = name.to_namespace
-
-      decl.members.each do |member|
-        case member
-        when AST::Members::Include
-          constant_scopes_module absolute_type_name(member.name, namespace: namespace),
-                                 scopes: scopes
-        end
-      end
-
-      scopes.unshift namespace
-    end
-
-    def constant_scopes0(name, scopes: [])
-      decl = env.find_class(name)
-      namespace = name.to_namespace
-
-      case decl
-      when AST::Declarations::Module
-        constant_scopes0 BuiltinNames::Module.name, scopes: scopes
-        constant_scopes_module name, scopes: scopes
-
-      when AST::Declarations::Class
-        unless name == BuiltinNames::BasicObject.name
-          super_name = decl.super_class&.yield_self {|super_class|
-            absolute_type_name(super_class.name, namespace: namespace)
-          } || BuiltinNames::Object.name
-
-          constant_scopes0 super_name, scopes: scopes
-        end
-
-        decl.members.each do |member|
-          case member
-          when AST::Members::Include
-            constant_scopes_module absolute_type_name(member.name, namespace: namespace),
-                                   scopes: scopes
-          end
-        end
-
-        scopes.unshift namespace
-      else
-        raise "Unexpected declaration: #{name}"
-      end
-
-      env.each_extension(name).sort_by {|e| e.extension_name.to_s }.each do |extension|
-        extension.members.each do |member|
-          case member
-          when AST::Members::Include
-            constant_scopes_module absolute_type_name(member.name, namespace: namespace),
-                                   scopes: []
-          end
-        end
-      end
-
-      scopes
-    end
-
-    def absolute_type_name(name, namespace:)
-      env.absolute_type_name(name, namespace: namespace) do
-        raise
-      end
-    end
-  end
-end

data/vendor/ruby-signature/lib/rbs/definition.rb

@@ -1,170 +0,0 @@
-module RBS
-  class Definition
-    class Variable
-      attr_reader :parent_variable
-      attr_reader :type
-      attr_reader :declared_in
-
-      def initialize(parent_variable:, type:, declared_in:)
-        @parent_variable = parent_variable
-        @type = type
-        @declared_in = declared_in
-      end
-    end
-
-    class Method
-      attr_reader :super_method
-      attr_reader :method_types
-      attr_reader :defined_in
-      attr_reader :implemented_in
-      attr_reader :accessibility
-      attr_reader :attributes
-      attr_reader :annotations
-      attr_reader :comment
-
-      def initialize(super_method:, method_types:, defined_in:, implemented_in:, accessibility:, attributes:, annotations:, comment:)
-        @super_method = super_method
-        @method_types = method_types
-        @defined_in = defined_in
-        @implemented_in = implemented_in
-        @accessibility = accessibility
-        @attributes = attributes
-        @annotations = annotations
-        @comment = comment
-      end
-
-      def public?
-        @accessibility == :public
-      end
-
-      def private?
-        @accessibility == :private
-      end
-
-      def sub(s)
-        self.class.new(
-          super_method: super_method&.sub(s),
-          method_types: method_types.map {|ty| ty.sub(s) },
-          defined_in: defined_in,
-          implemented_in: implemented_in,
-          accessibility: @accessibility,
-          attributes: attributes,
-          annotations: annotations,
-          comment: comment
-        )
-      end
-
-      def map_type(&block)
-        self.class.new(
-          super_method: super_method&.map_type(&block),
-          method_types: method_types.map do |ty|
-            ty.map_type(&block)
-          end,
-          defined_in: defined_in,
-          implemented_in: implemented_in,
-          accessibility: @accessibility,
-          attributes: attributes,
-          annotations: annotations,
-          comment: comment
-        )
-      end
-    end
-
-    module Ancestor
-      Instance = Struct.new(:name, :args, keyword_init: true)
-      Singleton = Struct.new(:name, keyword_init: true)
-      ExtensionInstance = Struct.new(:name, :extension_name, :args, keyword_init: true)
-      ExtensionSingleton = Struct.new(:name, :extension_name, keyword_init: true)
-    end
-
-    attr_reader :declaration
-    attr_reader :self_type
-    attr_reader :methods
-    attr_reader :instance_variables
-    attr_reader :class_variables
-    attr_reader :ancestors
-
-    def initialize(declaration:, self_type:, ancestors:)
-      unless declaration.is_a?(AST::Declarations::Class) ||
-        declaration.is_a?(AST::Declarations::Module) ||
-        declaration.is_a?(AST::Declarations::Interface) ||
-        declaration.is_a?(AST::Declarations::Extension)
-        raise "Declaration should be a class, module, or interface: #{declaration.name}"
-      end
-
-      unless (self_type.is_a?(Types::ClassSingleton) || self_type.is_a?(Types::Interface) || self_type.is_a?(Types::ClassInstance)) && self_type.name == declaration.name.absolute!
-        raise "self_type should be the type of declaration: #{self_type}"
-      end
-
-      @self_type = self_type
-      @declaration = declaration
-      @methods = {}
-      @instance_variables = {}
-      @class_variables = {}
-      @ancestors = ancestors
-    end
-
-    def name
-      declaration.name
-    end
-
-    def class?
-      declaration.is_a?(AST::Declarations::Class)
-    end
-
-    def module?
-      declaration.is_a?(AST::Declarations::Module)
-    end
-
-    def class_type?
-      @self_type.is_a?(Types::ClassSingleton)
-    end
-
-    def instance_type?
-      @self_type.is_a?(Types::ClassInstance)
-    end
-
-    def interface_type?
-      @self_type.is_a?(Types::Interface)
-    end
-
-    def type_params
-      @self_type.args.map(&:name)
-    end
-
-    def type_params_decl
-      case declaration
-      when AST::Declarations::Extension
-        nil
-      else
-        declaration.type_params
-      end
-    end
-
-    def each_type(&block)
-      if block_given?
-        methods.each_value do |method|
-          if method.defined_in == self.declaration
-            method.method_types.each do |method_type|
-              method_type.each_type(&block)
-            end
-          end
-        end
-
-        instance_variables.each_value do |var|
-          if var.declared_in == self.declaration
-            yield var.type
-          end
-        end
-
-        class_variables.each_value do |var|
-          if var.declared_in == self.declaration
-            yield var.type
-          end
-        end
-      else
-        enum_for :each_type
-      end
-    end
-  end
-end

data/vendor/ruby-signature/lib/rbs/definition_builder.rb

@@ -1,919 +0,0 @@
-module RBS
-  class DefinitionBuilder
-    attr_reader :env
-    attr_reader :instance_cache
-    attr_reader :singleton_cache
-
-    def initialize(env:)
-      @env = env
-      @instance_cache = {}
-      @singleton_cache = {}
-    end
-
-    def build_ancestors(self_ancestor, ancestors: [], building_ancestors: [], location: nil)
-      decl = env.find_class(self_ancestor.name)
-      namespace = self_ancestor.name.absolute!.to_namespace
-
-      RecursiveAncestorError.check!(self_ancestor,
-                                    ancestors: building_ancestors,
-                                    location: location || decl.location)
-      building_ancestors.push self_ancestor
-
-      case self_ancestor
-      when Definition::Ancestor::Instance
-        args = self_ancestor.args
-        param_names = decl.type_params.each.map(&:name)
-
-        InvalidTypeApplicationError.check!(
-          type_name: self_ancestor.name,
-          args: args,
-          params: decl.type_params,
-          location: location || decl.location
-        )
-
-        sub = Substitution.build(param_names, args)
-
-        case decl
-        when AST::Declarations::Class
-          unless self_ancestor.name == BuiltinNames::BasicObject.name
-            super_ancestor = decl.super_class&.yield_self do |super_class|
-              Definition::Ancestor::Instance.new(
-                name: absolute_type_name(super_class.name, namespace: namespace, location: location || decl.location),
-                args: super_class.args.map {|ty| absolute_type(ty.sub(sub), namespace: namespace) }
-              )
-            end || Definition::Ancestor::Instance.new(name: BuiltinNames::Object.name, args: [])
-
-            build_ancestors(super_ancestor, ancestors: ancestors, building_ancestors: building_ancestors)
-          end
-        end
-
-        decl.members.each do |member|
-          case member
-          when AST::Members::Include
-            if member.name.class?
-              ancestor = Definition::Ancestor::Instance.new(
-                name: absolute_type_name(member.name, namespace: namespace, location: member.location),
-                args: member.args.map {|ty| absolute_type(ty.sub(sub), namespace: namespace) }
-              )
-              build_ancestors ancestor, ancestors: ancestors, building_ancestors: building_ancestors, location: member.location
-            end
-          end
-        end
-
-        ancestors.unshift(self_ancestor)
-
-        env.each_extension(self_ancestor.name).sort_by {|e| e.extension_name.to_s }.each do |extension|
-          InvalidExtensionParameterError.check!(
-            type_name: self_ancestor.name,
-            extension_name: extension.extension_name,
-            extension_params: extension.type_params,
-            class_params: self_ancestor.args.map(&:name),
-            location: extension.location
-          )
-
-          sub = Substitution.build(extension.type_params, self_ancestor.args)
-
-          extension.members.each do |member|
-            case member
-            when AST::Members::Include
-              if member.name.class?
-                ancestor = Definition::Ancestor::Instance.new(
-                  name: absolute_type_name(member.name, namespace: namespace, location: member.location),
-                  args: member.args.map {|ty| absolute_type(ty.sub(sub), namespace: namespace) }
-                )
-                build_ancestors ancestor, ancestors: ancestors, building_ancestors: building_ancestors, location: member.location
-              end
-            end
-          end
-
-          extension_ancestor = Definition::Ancestor::ExtensionInstance.new(
-            name: extension.name.absolute!,
-            extension_name: extension.extension_name,
-            args: self_ancestor.args,
-          )
-          ancestors.unshift(extension_ancestor)
-
-          extension.members.each do |member|
-            case member
-            when AST::Members::Prepend
-              if member.name.class?
-                ancestor = Definition::Ancestor::Instance.new(
-                  name: absolute_type_name(member.name, namespace: namespace, location: member.location),
-                  args: member.args.map {|ty| absolute_type(ty.sub(sub), namespace: namespace) }
-                )
-                build_ancestors ancestor, ancestors: ancestors, building_ancestors: building_ancestors, location: member.location
-              end
-            end
-          end
-        end
-
-        decl.members.each do |member|
-          case member
-          when AST::Members::Prepend
-            ancestor = Definition::Ancestor::Instance.new(
-              name: absolute_type_name(member.name, namespace: namespace, location: member.location),
-              args: member.args.map {|ty| absolute_type(ty.sub(sub), namespace: namespace) }
-            )
-            build_ancestors ancestor, ancestors: ancestors, building_ancestors: building_ancestors, location: member.location
-          end
-        end
-      when Definition::Ancestor::Singleton
-        case decl
-        when AST::Declarations::Class
-          if self_ancestor.name == BuiltinNames::BasicObject.name
-            class_ancestor = Definition::Ancestor::Instance.new(
-              name: BuiltinNames::Class.name,
-              args: []
-            )
-            build_ancestors class_ancestor, ancestors: ancestors, building_ancestors: building_ancestors
-          else
-            super_ancestor = decl.super_class&.yield_self do |super_class|
-              Definition::Ancestor::Singleton.new(
-                name: absolute_type_name(super_class.name, namespace: namespace, location: location || decl.location)
-              )
-            end || Definition::Ancestor::Singleton.new(name: BuiltinNames::Object.name)
-
-            build_ancestors(super_ancestor, ancestors: ancestors, building_ancestors: building_ancestors)
-          end
-        when AST::Declarations::Module
-          module_ancestor = Definition::Ancestor::Instance.new(
-            name: BuiltinNames::Module.name,
-            args: []
-          )
-          build_ancestors module_ancestor, ancestors: ancestors, building_ancestors: building_ancestors
-        end
-
-        decl.members.each do |member|
-          case member
-          when AST::Members::Extend
-            if member.name.class?
-              ancestor = Definition::Ancestor::Instance.new(
-                name: absolute_type_name(member.name, namespace: namespace, location: member.location),
-                args: member.args.map {|ty| absolute_type(ty.sub(sub), namespace: namespace) }
-              )
-              build_ancestors ancestor, ancestors: ancestors, building_ancestors: building_ancestors, location: member.location
-            end
-          end
-        end
-
-        ancestors.unshift(self_ancestor)
-
-        env.each_extension(self_ancestor.name).sort_by {|e| e.extension_name.to_s }.each do |extension|
-          extension.members.each do |member|
-            case member
-            when AST::Members::Extend
-              if member.name.class?
-                ancestor = Definition::Ancestor::Instance.new(
-                  name: absolute_type_name(member.name, namespace: namespace, location: member.location),
-                  args: member.args.map {|ty| absolute_type(ty, namespace: namespace) }
-                )
-                build_ancestors ancestor, ancestors: ancestors, building_ancestors: building_ancestors, location: member.location
-              end
-            end
-          end
-
-          extension_ancestor = Definition::Ancestor::ExtensionSingleton.new(
-            name: extension.name.absolute!,
-            extension_name: extension.extension_name
-          )
-          ancestors.unshift(extension_ancestor)
-        end
-      end
-
-      building_ancestors.pop
-
-      ancestors
-    end
-
-    def each_member_with_accessibility(members, accessibility: :public)
-      members.each do |member|
-        case member
-        when AST::Members::Public
-          accessibility = :public
-        when AST::Members::Private
-          accessibility = :private
-        else
-          yield member, accessibility
-        end
-      end
-    end
-
-    def build_instance(type_name)
-      try_cache type_name, cache: instance_cache do
-        decl = env.find_class(type_name)
-        self_ancestor = Definition::Ancestor::Instance.new(name: type_name,
-                                                           args: Types::Variable.build(decl.type_params.each.map(&:name)))
-        self_type = Types::ClassInstance.new(name: type_name, args: self_ancestor.args, location: nil)
-
-        case decl
-        when AST::Declarations::Class, AST::Declarations::Module
-          ancestors = build_ancestors(self_ancestor)
-          definition_pairs = ancestors.map do |ancestor|
-            case ancestor
-            when Definition::Ancestor::Instance
-              [ancestor, build_one_instance(ancestor.name)]
-            when Definition::Ancestor::Singleton
-              [ancestor, build_one_singleton(ancestor.name)]
-            when Definition::Ancestor::ExtensionInstance
-              [ancestor, build_one_instance(ancestor.name, extension_name: ancestor.extension_name)]
-            when Definition::Ancestor::ExtensionSingleton
-              [ancestor, build_one_extension_singleton(ancestor.name, extension_name: ancestor.extension_name)]
-            end
-          end
-
-          if decl.is_a?(AST::Declarations::Module)
-            if decl.self_type
-              self_interface = absolute_type(decl.self_type, namespace: type_name.to_namespace)
-              ancestor = Definition::Ancestor::Instance.new(name: self_interface.name,
-                                                            args: self_interface.args)
-
-              definition_pairs.push [ancestor, build_one_instance(ancestor.name)]
-            end
-          end
-
-          merge_definitions(definition_pairs, decl: decl, self_type: self_type, ancestors: ancestors)
-        end
-      end
-    end
-
-    def build_singleton(type_name)
-      try_cache type_name, cache: singleton_cache do
-        decl = env.find_class(type_name)
-        self_ancestor = Definition::Ancestor::Singleton.new(name: type_name)
-        self_type = Types::ClassSingleton.new(name: type_name, location: nil)
-
-        case decl
-        when AST::Declarations::Class, AST::Declarations::Module
-          ancestors = build_ancestors(self_ancestor)
-          definition_pairs = ancestors.map do |ancestor|
-            case ancestor
-            when Definition::Ancestor::Instance
-              [ancestor, build_one_instance(ancestor.name)]
-            when Definition::Ancestor::Singleton
-              [ancestor, build_one_singleton(ancestor.name)]
-            when Definition::Ancestor::ExtensionInstance
-              [ancestor, build_one_instance(ancestor.name, extension_name: ancestor.extension_name)]
-            when Definition::Ancestor::ExtensionSingleton
-              [ancestor, build_one_singleton(ancestor.name, extension_name: ancestor.extension_name)]
-            end
-          end
-
-          if decl.is_a?(AST::Declarations::Class)
-            definition_pairs.find {|ancestor, _| ancestor == self_ancestor }.tap do |_, definition|
-              unless definition.methods[:new]&.implemented_in == decl
-                instance_definition = build_instance(type_name)
-                class_params = decl.type_params.each.map(&:name)
-                initialize_method = instance_definition.methods[:initialize]
-                method_types = initialize_method.method_types.map do |method_type|
-                  case method_type
-                  when MethodType
-                    fvs = method_type.free_variables + class_params
-                    unless fvs.empty?
-                      param_name_set = Set.new(class_params)
-                      bound_variables = method_type.type_params
-                      renamed_types = bound_variables.map do |x|
-                        if param_name_set.member?(x)
-                          Types::Variable.fresh(x)
-                        else
-                          Types::Variable.new(name: x, location: nil)
-                        end
-                      end
-                      sub = Substitution.build(bound_variables, renamed_types)
-                      method_type_params = renamed_types.unshift(*class_params)
-                    else
-                      sub = Substitution.build([], [])
-                      method_type_params = method_type.type_params
-                    end
-
-                    MethodType.new(
-                      type_params: method_type_params,
-                      type: method_type.type.sub(sub).with_return_type(instance_definition.self_type),
-                      block: method_type.block&.yield_self {|ty| ty.sub(sub) },
-                      location: method_type.location
-                    )
-                  end
-                end.compact
-
-                definition.methods[:new] = Definition::Method.new(
-                  super_method: nil,
-                  defined_in: nil,
-                  implemented_in: env.find_class(RBS::BuiltinNames::Class.name),
-                  method_types: method_types,
-                  accessibility: :public,
-                  attributes: [:incompatible],
-                  annotations: [],
-                  comment: nil
-                )
-              end
-            end
-          end
-
-          merge_definitions(definition_pairs, decl: decl, self_type: self_type, ancestors: ancestors)
-        end
-      end
-    end
-
-    def build_one_instance(type_name, extension_name: nil)
-      decl = if extension_name
-               env.each_extension(type_name).find {|ext| ext.extension_name == extension_name } or
-                 raise "Unknown extension: #{type_name} (#{extension_name})"
-             else
-               env.find_class(type_name)
-             end
-
-      case decl
-      when AST::Declarations::Interface
-        build_interface type_name, decl
-      else
-        namespace = type_name.to_namespace
-
-        case decl
-        when AST::Declarations::Class, AST::Declarations::Module
-          self_type = Types::ClassInstance.new(name: type_name,
-                                               args: Types::Variable.build(decl.type_params.each.map(&:name)),
-                                               location: nil)
-          ancestors = [Definition::Ancestor::Instance.new(name: type_name, args: self_type.args)]
-        when AST::Declarations::Extension
-          self_type = Types::ClassInstance.new(name: type_name, args: Types::Variable.build(decl.type_params), location: nil)
-          ancestors = [Definition::Ancestor::ExtensionInstance.new(name: type_name,
-                                                                   extension_name: extension_name,
-                                                                   args: self_type.args)]
-        end
-
-        Definition.new(declaration: decl, self_type: self_type, ancestors: ancestors).tap do |definition|
-          alias_members = []
-
-          each_member_with_accessibility(decl.members) do |member, accessibility|
-            case member
-            when AST::Members::MethodDefinition
-              if member.instance?
-                name = member.name
-                method_types = member.types.map do |method_type|
-                  case method_type
-                  when MethodType
-                    method_type.map_type do |type|
-                      absolute_type(type, namespace: namespace)
-                    end
-                  when :super
-                    :super
-                  end
-                end
-
-                DuplicatedMethodDefinitionError.check!(
-                  decl: decl,
-                  methods: definition.methods,
-                  name: name,
-                  location: member.location
-                )
-
-                attrs = if name == :initialize
-                          (member.attributes + [:incompatible]).uniq
-                        else
-                          member.attributes
-                        end
-
-                definition.methods[name] = Definition::Method.new(super_method: nil,
-                                                                  method_types: method_types,
-                                                                  defined_in: decl,
-                                                                  implemented_in: decl,
-                                                                  accessibility: accessibility,
-                                                                  attributes: attrs,
-                                                                  annotations: member.annotations,
-                                                                  comment: member.comment)
-              end
-            when AST::Members::AttrReader, AST::Members::AttrAccessor, AST::Members::AttrWriter
-              name = member.name
-              type = absolute_type(member.type, namespace: namespace)
-              ivar_name = case member.ivar_name
-                          when false
-                            nil
-                          else
-                            member.ivar_name || :"@#{member.name}"
-                          end
-
-              if member.is_a?(AST::Members::AttrReader) || member.is_a?(AST::Members::AttrAccessor)
-                definition.methods[name] = Definition::Method.new(
-                  super_method: nil,
-                  method_types: [
-                    MethodType.new(
-                      type_params: [],
-                      type: Types::Function.empty(type),
-                      block: nil,
-                      location: nil
-                    )
-                  ],
-                  defined_in: decl,
-                  implemented_in: decl,
-                  accessibility: accessibility,
-                  attributes: [],
-                  annotations: member.annotations,
-                  comment: member.comment
-                )
-              end
-
-              if member.is_a?(AST::Members::AttrWriter) || member.is_a?(AST::Members::AttrAccessor)
-                definition.methods[:"#{name}="] = Definition::Method.new(
-                  super_method: nil,
-                  method_types: [
-                    MethodType.new(
-                      type_params: [],
-                      type: Types::Function.new(required_positionals: [Types::Function::Param.new(name: name, type: type)],
-                                                optional_positionals: [],
-                                                rest_positionals: nil,
-                                                trailing_positionals: [],
-                                                required_keywords: {},
-                                                optional_keywords: {},
-                                                rest_keywords: nil,
-                                                return_type: type),
-                      block: nil,
-                      location: nil
-                    )
-                  ],
-                  defined_in: decl,
-                  implemented_in: decl,
-                  accessibility: accessibility,
-                  attributes: [],
-                  annotations: member.annotations,
-                  comment: member.comment
-                )
-              end
-
-              if ivar_name
-                definition.instance_variables[ivar_name] = Definition::Variable.new(
-                  parent_variable: nil,
-                  type: type,
-                  declared_in: decl
-                )
-              end
-
-            when AST::Members::Alias
-              if member.instance?
-                alias_members << member
-              end
-            when AST::Members::Include
-              if member.name.interface?
-                absolute_name = absolute_type_name(member.name, namespace: namespace, location: member.location)
-                interface_definition = build_one_instance(absolute_name)
-                absolute_args = member.args.map {|ty| absolute_type(ty, namespace: namespace) }
-
-                InvalidTypeApplicationError.check!(
-                  type_name: absolute_name,
-                  args: absolute_args,
-                  params: interface_definition.type_params_decl,
-                  location: member.location
-                )
-
-                sub = Substitution.build(interface_definition.type_params, absolute_args)
-                interface_definition.methods.each do |name, method|
-                  method_types = method.method_types.map do |method_type|
-                    method_type.sub(sub).map_type do |type|
-                      absolute_type(type, namespace: namespace)
-                    end
-                  end
-
-                  DuplicatedMethodDefinitionError.check!(
-                    decl: decl,
-                    methods: definition.methods,
-                    name: name,
-                    location: member.location
-                  )
-
-                  definition.methods[name] = Definition::Method.new(
-                    super_method: nil,
-                    method_types: method_types,
-                    defined_in: method.defined_in,
-                    implemented_in: decl,
-                    accessibility: method.accessibility,
-                    attributes: [],
-                    annotations: method.annotations,
-                    comment: member.comment
-                  )
-                end
-              end
-            when AST::Members::InstanceVariable
-              definition.instance_variables[member.name] = Definition::Variable.new(
-                type: absolute_type(member.type, namespace: namespace),
-                parent_variable: nil,
-                declared_in: decl
-              )
-            when AST::Members::ClassVariable
-              definition.class_variables[member.name] = Definition::Variable.new(
-                type: absolute_type(member.type, namespace: namespace),
-                parent_variable: nil,
-                declared_in: decl
-              )
-            end
-          end
-
-          alias_members.each do |member|
-            UnknownMethodAliasError.check!(
-              methods: definition.methods,
-              original_name: member.old_name,
-              aliased_name: member.new_name,
-              location: member.location
-            )
-
-            DuplicatedMethodDefinitionError.check!(
-              decl: decl,
-              methods: definition.methods,
-              name: member.new_name,
-              location: member.location
-            )
-
-            # FIXME: may cause a problem if #old_name has super type
-            definition.methods[member.new_name] = definition.methods[member.old_name]
-          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|
-          case method_type
-          when MethodType
-            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
-      end
-
-      unless errors.empty?
-        raise InvalidVarianceAnnotationError.new(decl: decl, errors: errors)
-      end
-    end
-
-    def build_one_singleton(type_name, extension_name: nil)
-      decl = if extension_name
-               env.each_extension(type_name).find {|ext| ext.extension_name == extension_name } or
-                 raise "Unknown extension: #{type_name} (#{extension_name})"
-             else
-               env.find_class(type_name)
-             end
-
-      namespace = type_name.to_namespace
-
-      case decl
-      when AST::Declarations::Module, AST::Declarations::Class
-        self_type = Types::ClassSingleton.new(name: type_name, location: nil)
-        ancestors = [Definition::Ancestor::Singleton.new(name: type_name)]
-      when AST::Declarations::Extension
-        self_type = Types::ClassSingleton.new(name: type_name, location: nil)
-        ancestors = [Definition::Ancestor::ExtensionSingleton.new(name: type_name, extension_name: extension_name)]
-      end
-
-      Definition.new(declaration: decl, self_type: self_type, ancestors: ancestors).tap do |definition|
-        alias_members = []
-
-        each_member_with_accessibility(decl.members) do |member, accessibility|
-          case member
-          when AST::Members::MethodDefinition
-            if member.singleton?
-              name = member.name
-              method_types = member.types.map do |method_type|
-                method_type.map_type do |type|
-                  absolute_type(type, namespace: namespace)
-                end
-              end
-
-              DuplicatedMethodDefinitionError.check!(
-                decl: decl,
-                methods: definition.methods,
-                name: name,
-                location: member.location
-              )
-
-              definition.methods[name] = Definition::Method.new(super_method: nil,
-                                                                method_types: method_types,
-                                                                defined_in: decl,
-                                                                implemented_in: decl,
-                                                                accessibility: accessibility,
-                                                                attributes: member.attributes,
-                                                                annotations: member.annotations,
-                                                                comment: member.comment)
-            end
-          when AST::Members::Alias
-            if member.singleton?
-              alias_members << member
-            end
-          when AST::Members::Extend
-            if member.name.interface?
-              absolute_name = absolute_type_name(member.name, namespace: namespace, location: member.location)
-              interface_definition = build_one_instance(absolute_name)
-              absolute_args = member.args.map {|ty| absolute_type(ty, namespace: namespace) }
-
-              InvalidTypeApplicationError.check!(
-                type_name: absolute_name,
-                args: absolute_args,
-                params: interface_definition.type_params_decl,
-                location: member.location
-              )
-
-              sub = Substitution.build(interface_definition.type_params, absolute_args)
-              interface_definition.methods.each do |name, method|
-                method_types = method.method_types.map do |method_type|
-                  method_type.sub(sub).map_type do |type|
-                    absolute_type(type, namespace: namespace)
-                  end
-                end
-
-                DuplicatedMethodDefinitionError.check!(
-                  decl: decl,
-                  methods: definition.methods,
-                  name: name,
-                  location: member.location
-                )
-
-                definition.methods[name] = Definition::Method.new(
-                  super_method: nil,
-                  method_types: method_types,
-                  defined_in: method.defined_in,
-                  implemented_in: decl,
-                  accessibility: method.accessibility,
-                  attributes: method.attributes,
-                  annotations: method.annotations,
-                  comment: member.comment
-                )
-              end
-            end
-          when AST::Members::ClassInstanceVariable
-            definition.instance_variables[member.name] = Definition::Variable.new(
-              type: absolute_type(member.type, namespace: namespace),
-              parent_variable: nil,
-              declared_in: decl
-            )
-          when AST::Members::ClassVariable
-            definition.class_variables[member.name] = Definition::Variable.new(
-              type: absolute_type(member.type, namespace: namespace),
-              parent_variable: nil,
-              declared_in: decl
-            )
-          end
-        end
-
-        alias_members.each do |member|
-          UnknownMethodAliasError.check!(
-            methods: definition.methods,
-            original_name: member.old_name,
-            aliased_name: member.new_name,
-            location: member.location
-          )
-
-          DuplicatedMethodDefinitionError.check!(
-            decl: decl,
-            methods: definition.methods,
-            name: member.new_name,
-            location: member.location
-          )
-
-          # FIXME: may cause a problem if #old_name has super type
-          definition.methods[member.new_name] = definition.methods[member.old_name]
-        end
-      end
-    end
-
-    def merge_definitions(pairs, decl:, self_type:, ancestors:)
-      Definition.new(declaration: decl, self_type: self_type, ancestors: ancestors).tap do |definition|
-        pairs.reverse_each do |(ancestor, current_definition)|
-          sub = case ancestor
-                when Definition::Ancestor::Instance, Definition::Ancestor::ExtensionInstance
-                  Substitution.build(current_definition.type_params, ancestor.args)
-                when Definition::Ancestor::Singleton, Definition::Ancestor::ExtensionSingleton
-                  Substitution.build([], [])
-                end
-          namespace = current_definition.name.absolute!.to_namespace
-
-          current_definition.methods.each do |name, method|
-            merge_method definition.methods, name, method, sub, namespace
-          end
-
-          current_definition.instance_variables.each do |name, variable|
-            merge_variable definition.instance_variables, name, variable
-          end
-
-          current_definition.class_variables.each do |name, variable|
-            merge_variable definition.class_variables, name, variable
-          end
-        end
-      end
-    end
-
-    def merge_variable(variables, name, variable)
-      super_variable = variables[name]
-
-      variables[name] = Definition::Variable.new(
-        parent_variable: super_variable,
-        type: variable.type,
-        declared_in: variable.declared_in
-      )
-    end
-
-    def merge_method(methods, name, method, sub, namespace)
-      super_method = methods[name]
-
-      methods[name] = Definition::Method.new(
-        method_types: method.method_types.flat_map do |method_type|
-          case method_type
-          when MethodType
-            [absolute_type(method_type.sub(sub), namespace: namespace)]
-          when :super
-            super_method.method_types
-          end
-        end,
-        super_method: super_method,
-        defined_in: method.defined_in,
-        implemented_in: method.implemented_in,
-        accessibility: method.accessibility,
-        attributes: method.attributes,
-        annotations: method.annotations,
-        comment: method.comment
-      )
-    end
-
-    def try_cache(type_name, cache:)
-      cached = cache[type_name]
-
-      case cached
-      when Definition
-        cached
-      when false
-        raise
-      when nil
-        cache[type_name] = false
-        begin
-          cache[type_name] = yield
-        rescue => ex
-          cache[type_name] = nil
-          raise ex
-        end
-      end
-    end
-
-    def build_interface(type_name, declaration = env.find_class(type_name))
-      self_type = Types::Interface.new(
-        name: type_name,
-        args: declaration.type_params.each.map {|p| Types::Variable.new(name: p.name, location: nil) },
-        location: nil
-      )
-
-      namespace = type_name.to_namespace
-
-      Definition.new(declaration: declaration, self_type: self_type, ancestors: []).tap do |definition|
-        alias_members = []
-
-        declaration.members.each do |member|
-          case member
-          when AST::Members::Include
-            mixin_name = env.absolute_interface_name(member.name, namespace: namespace) || member.name.absolute!
-            mixin = build_one_instance(mixin_name)
-
-            args = member.args.map {|type| absolute_type(type, namespace: namespace) }
-            type_params = mixin.declaration.type_params
-
-            InvalidTypeApplicationError.check!(
-              type_name: type_name,
-              args: args,
-              params: type_params,
-              location: member.location
-            )
-
-            sub = Substitution.build(type_params.each.map(&:name), args)
-            mixin.methods.each do |name, method|
-              definition.methods[name] = method.sub(sub)
-            end
-          end
-        end
-
-        declaration.members.each do |member|
-          case member
-          when AST::Members::MethodDefinition
-            DuplicatedMethodDefinitionError.check!(
-              decl: declaration,
-              methods: definition.methods,
-              name: member.name,
-              location: member.location
-            )
-
-            method = Definition::Method.new(
-              super_method: nil,
-              method_types: member.types.map do |method_type|
-                method_type.map_type {|ty| absolute_type(ty, namespace: namespace) }
-              end,
-              defined_in: declaration,
-              implemented_in: nil,
-              accessibility: :public,
-              attributes: member.attributes,
-              annotations: member.annotations,
-              comment: member.comment
-            )
-            definition.methods[member.name] = method
-          when AST::Members::Alias
-            alias_members << member
-          end
-        end
-
-        alias_members.each do |member|
-          UnknownMethodAliasError.check!(
-            methods: definition.methods,
-            original_name: member.old_name,
-            aliased_name: member.new_name,
-            location: member.location
-          )
-
-          DuplicatedMethodDefinitionError.check!(
-            decl: declaration,
-            methods: definition.methods,
-            name: member.new_name,
-            location: member.location
-          )
-
-          # FIXME: may cause a problem if #old_name has super type
-          definition.methods[member.new_name] = definition.methods[member.old_name]
-        end
-      end
-    end
-
-    def absolute_type(type, namespace:)
-      env.absolute_type(type, namespace: namespace) do |type|
-        NoTypeFoundError.check!(type.name.absolute!, env: env, location: type.location)
-      end
-    end
-
-    def absolute_type_name(type_name, namespace:, location:)
-      env.absolute_type_name(type_name, namespace: namespace) do |type_name|
-        NoTypeFoundError.check!(type_name.absolute!, env: env, location: location)
-      end
-    end
-
-    def expand_alias(type_name)
-      absolute_type(env.find_alias(type_name).type, namespace: type_name.namespace)
-    end
-  end
-end