pigeonhole-db 1.1.0

data/vendor/bundle/ruby/3.4.0/gems/rbs-4.2.0/lib/rbs/definition_builder.rb

@@ -0,0 +1,1057 @@
+# frozen_string_literal: true
+
+module RBS
+  class DefinitionBuilder
+    attr_reader :env
+    attr_reader :ancestor_builder
+    attr_reader :method_builder
+
+    attr_reader :instance_cache
+    attr_reader :singleton_cache
+    attr_reader :singleton0_cache
+    attr_reader :interface_cache
+
+    def initialize(env:, ancestor_builder: nil, method_builder: nil)
+      @env = env
+      @ancestor_builder = ancestor_builder || AncestorBuilder.new(env: env)
+      @method_builder = method_builder || MethodBuilder.new(env: env)
+
+      @instance_cache = {}
+      @singleton_cache = {}
+      @singleton0_cache = {}
+      @interface_cache = {}
+    end
+
+    def ensure_namespace!(namespace, location:)
+      namespace.ascend do |ns|
+        unless ns.empty?
+          NoTypeFoundError.check!(ns.to_type_name, env: env, location: location)
+        end
+      end
+    end
+
+    def define_interface(definition, type_name, subst)
+      included_interfaces = ancestor_builder.interface_ancestors(type_name).ancestors #: Array[Definition::Ancestor::Instance]
+      included_interfaces = included_interfaces.reject {|ancestor| ancestor.source == nil }
+
+      interface_methods = interface_methods(included_interfaces)
+      methods = method_builder.build_interface(type_name)
+
+      import_methods(definition, type_name, methods, interface_methods, subst, nil)
+    end
+
+    def build_interface(type_name)
+      try_cache(type_name, cache: interface_cache) do
+        entry = env.interface_decls[type_name] or raise "Unknown name for build_interface: #{type_name}"
+        declaration = entry.decl
+        ensure_namespace!(type_name.namespace, location: declaration.location)
+
+        type_params = declaration.type_params.each.map(&:name)
+        type_args = Types::Variable.build(type_params)
+        self_type = Types::Interface.new(name: type_name, args: type_args, location: nil)
+
+        subst = Substitution.build(type_params, type_args)
+
+        ancestors = ancestor_builder.interface_ancestors(type_name)
+        Definition.new(type_name: type_name, entry: entry, self_type: self_type, ancestors: ancestors).tap do |definition|
+          methods = method_builder.build_interface(type_name)
+          one_ancestors = ancestor_builder.one_interface_ancestors(type_name)
+          validate_type_params(definition, methods: methods, ancestors: one_ancestors)
+
+          define_interface(definition, type_name, subst)
+        end
+      end
+    end
+
+    def tapp_subst(name, args)
+      params =
+        case
+        when name.interface?
+          entry = env.interface_decls[name] or raise "Unknown interface name: #{name}"
+          entry.decl.type_params
+        when name.alias?
+          entry = env.type_alias_decls[name] or raise "Unknown alias name: #{name}"
+          entry.decl.type_params
+        when name.class?
+          entry = env.class_decls[name] or raise "Unknown module name: #{name}"
+          entry.type_params
+        else
+          raise
+        end
+
+      AST::TypeParam.application(params, args) || Substitution.new()
+    end
+
+    def define_instance(definition, type_name, subst, define_class_vars:)
+      one_ancestors = ancestor_builder.one_instance_ancestors(type_name)
+      methods = method_builder.build_instance(type_name)
+
+      self_type_methods = one_ancestors.each_self_type.with_object({}) do |self_type, hash| #$ Hash[Symbol, Definition::Method]
+        self_type.args.each do |arg|
+          validate_type_presence(arg)
+        end
+
+        self_type_defn = self_type.name.interface? ? build_interface(self_type.name) : build_instance(self_type.name)
+
+        s = subst + tapp_subst(self_type.name, self_type.args)
+        self_type_defn.methods.each do |method_name, method_def|
+          hash[method_name] = method_def.sub(s)
+        end
+      end
+
+      one_ancestors.each_included_module do |mod|
+        mod.args.each do |arg|
+          validate_type_presence(arg)
+        end
+
+        define_instance(definition, mod.name, subst + tapp_subst(mod.name, mod.args), define_class_vars: define_class_vars)
+      end
+
+      all_interfaces = one_ancestors.each_included_interface.flat_map do |interface|
+        other_interfaces = ancestor_builder.interface_ancestors(interface.name).ancestors #: Array[Definition::Ancestor::Instance]
+        other_interfaces = other_interfaces.select {|ancestor| ancestor.source }
+        [interface, *other_interfaces]
+      end
+      interface_methods = interface_methods(all_interfaces)
+      import_methods(definition, type_name, methods, interface_methods, subst, self_type_methods)
+
+      one_ancestors.each_prepended_module do |mod|
+        mod.args.each do |arg|
+          validate_type_presence(arg)
+        end
+
+        define_instance(definition, mod.name, subst + tapp_subst(mod.name, mod.args), define_class_vars: define_class_vars)
+      end
+
+      entry = env.class_decls[type_name] or raise "Unknown name for build_instance: #{type_name}"
+
+      entry.each_decl do |decl|
+        if align_params = entry.align_params(decl)
+          subst_ = subst + align_params
+        else
+          subst_ = subst
+        end
+
+        decl.members.each do |member|
+          case member
+          when AST::Members::AttrReader, AST::Members::AttrAccessor, AST::Members::AttrWriter
+            if member.kind == :instance
+              ivar_name = case member.ivar_name
+                          when false
+                            nil
+                          else
+                            member.ivar_name || :"@#{member.name}"
+                          end
+
+              if ivar_name
+                insert_variable(
+                  type_name,
+                  definition.instance_variables,
+                  name: ivar_name,
+                  type: member.type.sub(subst_),
+                  source: member
+                )
+              end
+            end
+
+          when AST::Ruby::Members::AttrReaderMember, AST::Ruby::Members::AttrWriterMember, AST::Ruby::Members::AttrAccessorMember
+            member.names.each do |name|
+              ivar_name = :"@#{name}"
+              attr_type = member.type || Types::Bases::Any.new(location: nil)
+
+              insert_variable(
+                type_name,
+                definition.instance_variables,
+                name: ivar_name,
+                type: attr_type,
+                source: member
+              )
+            end
+
+          when AST::Ruby::Members::InstanceVariableMember
+            insert_variable(
+              type_name,
+              definition.instance_variables,
+              name: member.name,
+              type: member.type,
+              source: member
+            )
+
+          when AST::Members::InstanceVariable
+            insert_variable(
+              type_name,
+              definition.instance_variables,
+              name: member.name,
+              type: member.type.sub(subst_),
+              source: member
+            )
+
+          when AST::Members::ClassVariable
+            if define_class_vars
+              insert_variable(type_name, definition.class_variables, name: member.name, type: member.type, source: member)
+            end
+          end
+        end
+      end
+    end
+
+    def build_instance(type_name)
+      type_name = env.normalize_module_name(type_name)
+
+      try_cache(type_name, cache: instance_cache) do
+        entry = env.class_decls[type_name] or raise "Unknown name for build_instance: #{type_name}"
+        ensure_namespace!(type_name.namespace, location: entry.primary_decl.location)
+
+        ancestors = ancestor_builder.instance_ancestors(type_name)
+        args = entry.type_params.map {|param| Types::Variable.new(name: param.name, location: param.location) }
+        self_type = Types::ClassInstance.new(name: type_name, args: args, location: nil)
+
+        Definition.new(type_name: type_name, entry: entry, self_type: self_type, ancestors: ancestors).tap do |definition|
+          one_ancestors = ancestor_builder.one_instance_ancestors(type_name)
+          methods = method_builder.build_instance(type_name)
+
+          validate_type_params definition, methods: methods, ancestors: one_ancestors
+
+          if entry.is_a?(Environment::ClassEntry)
+            if super_class = one_ancestors.super_class
+              super_class.is_a?(Definition::Ancestor::Instance) or raise
+
+              build_instance(super_class.name).tap do |defn|
+                unless super_class.args.empty?
+                  super_class.args.each do |arg|
+                    validate_type_presence(arg)
+                  end
+
+                  subst = tapp_subst(super_class.name, super_class.args)
+                  defn = defn.sub(subst)
+                end
+
+                definition.methods.merge!(defn.methods)
+                definition.instance_variables.merge!(defn.instance_variables)
+                definition.class_variables.merge!(defn.class_variables)
+              end
+            end
+          end
+
+          if entry.is_a?(Environment::ModuleEntry)
+            if self_types = one_ancestors.self_types
+              self_types.each do |ans|
+                ans.args.each do |arg|
+                  validate_type_presence(arg)
+                end
+
+                subst = tapp_subst(ans.name, ans.args)
+                if ans.name.interface?
+                  define_interface(definition, ans.name, subst)
+                else
+                  define_instance(definition, ans.name, subst, define_class_vars: true)
+                end
+              end
+            end
+          end
+
+          define_instance(definition, type_name, Substitution.new, define_class_vars: true)
+        end
+      end
+    end
+
+    # Builds a definition for singleton without .new method.
+    #
+    def build_singleton0(type_name)
+      try_cache type_name, cache: singleton0_cache do
+        entry = env.class_decls[type_name] or raise "Unknown name for build_singleton0: #{type_name}"
+        ensure_namespace!(type_name.namespace, location: entry.primary_decl.location)
+
+        ancestors = ancestor_builder.singleton_ancestors(type_name)
+        self_type = Types::ClassSingleton.new(name: type_name, location: nil)
+
+        Definition.new(type_name: type_name, entry: entry, self_type: self_type, ancestors: ancestors).tap do |definition|
+          one_ancestors = ancestor_builder.one_singleton_ancestors(type_name)
+          methods = method_builder.build_singleton(type_name)
+
+          if super_class = one_ancestors.super_class
+            case super_class
+            when Definition::Ancestor::Instance
+              defn = build_instance(super_class.name)
+            when Definition::Ancestor::Singleton
+              defn = build_singleton0(super_class.name)
+            end
+
+            definition.methods.merge!(defn.methods)
+            definition.instance_variables.merge!(defn.instance_variables)
+          end
+
+          one_ancestors.each_extended_module do |mod|
+            mod.args.each do |arg|
+              validate_type_presence(arg)
+            end
+
+            subst = tapp_subst(mod.name, mod.args)
+            define_instance(definition, mod.name, subst, define_class_vars: false)
+          end
+
+          all_interfaces = one_ancestors.each_extended_interface.flat_map do |interface|
+            other_interfaces = ancestor_builder.interface_ancestors(interface.name).ancestors #: Array[Definition::Ancestor::Instance]
+            other_interfaces = other_interfaces.select {|ancestor| ancestor.source }
+            [interface, *other_interfaces]
+          end
+          interface_methods = interface_methods(all_interfaces)
+          import_methods(definition, type_name, methods, interface_methods, Substitution.new, nil)
+
+          entry.each_decl do |decl|
+            decl.members.each do |member|
+              case member
+              when AST::Members::AttrReader, AST::Members::AttrAccessor, AST::Members::AttrWriter
+                if member.kind == :singleton
+                  ivar_name = case member.ivar_name
+                              when false
+                                nil
+                              else
+                                member.ivar_name || :"@#{member.name}"
+                              end
+
+                  if ivar_name
+                    insert_variable(type_name, definition.instance_variables, name: ivar_name, type: member.type, source: member)
+                  end
+                end
+
+              when AST::Members::ClassInstanceVariable
+                insert_variable(type_name, definition.instance_variables, name: member.name, type: member.type, source: member)
+              end
+            end
+          end
+
+          instance_definition = build_instance(type_name)
+          definition.class_variables.replace(instance_definition.class_variables)
+        end
+      end
+    end
+
+    def build_singleton(type_name)
+      type_name = env.normalize_module_name(type_name)
+
+      try_cache type_name, cache: singleton_cache do
+        entry = env.class_decls[type_name] or raise "Unknown name for build_singleton: #{type_name}"
+        ensure_namespace!(type_name.namespace, location: entry.primary_decl.location)
+
+        ancestors = ancestor_builder.singleton_ancestors(type_name)
+        self_type = Types::ClassSingleton.new(name: type_name, location: nil)
+
+        Definition.new(type_name: type_name, entry: entry, self_type: self_type, ancestors: ancestors).tap do |definition|
+          definition0 = build_singleton0(type_name)
+          definition.methods.merge!(definition0.methods)
+          definition.instance_variables.merge!(definition0.instance_variables)
+          definition.class_variables.merge!(definition0.class_variables)
+
+          if entry.is_a?(Environment::ClassEntry)
+            new_method = definition.methods[:new]
+
+            if new_method.defs.all? {|d| d.defined_in == BuiltinNames::Class.name }
+              # The method is _untyped new_.
+
+              alias_methods = definition.methods.each.with_object([]) do |entry, array|
+                # @type var method: Definition::Method?
+                name, method = entry
+                while method
+                  if method.alias_of == new_method
+                    array << name
+                    break
+                  end
+                  method = method.alias_of
+                end
+              end
+
+              instance = build_instance(type_name)
+              initialize = instance.methods[:initialize]
+
+              if initialize
+                class_params = entry.type_params
+
+                # Inject a virtual _typed new_.
+                initialize_defs = initialize.defs
+                typed_new = Definition::Method.new(
+                  super_method: new_method,
+                  defs: initialize_defs.map do |initialize_def|
+                    method_type = initialize_def.type
+
+                    class_type_param_vars = Set.new(class_params.map(&:name))
+                    method_type_param_vars = Set.new(method_type.type_params.map(&:name))
+
+                    if class_type_param_vars.intersect?(method_type_param_vars)
+                      new_method_param_names = method_type.type_params.map do |method_param|
+                        if class_type_param_vars.include?(method_param.name)
+                          Types::Variable.fresh(method_param.name).name
+                        else
+                          method_param.name
+                        end
+                      end
+
+                      sub = Substitution.build(
+                        method_type.type_params.map(&:name),
+                        Types::Variable.build(new_method_param_names)
+                      )
+
+                      method_params = class_params + AST::TypeParam.rename(method_type.type_params, new_names: new_method_param_names)
+                      method_type = method_type
+                        .update(type_params: [])
+                        .sub(sub)
+                        .update(type_params: method_params)
+                    else
+                      method_type = method_type
+                        .update(type_params: class_params + method_type.type_params)
+                    end
+
+                    method_type = method_type.map_type do |type|
+                      case type
+                      when Types::Bases::Self
+                        Types::ClassInstance.new(
+                          name: type_name,
+                          args: entry.type_params.map {|param| Types::Variable.new(name: param.name, location: param.location) },
+                          location: nil
+                        )
+                      else
+                        type
+                      end
+                    end
+
+                    method_type = method_type.update(
+                      type: method_type.type.with_return_type(
+                        Types::ClassInstance.new(
+                          name: type_name,
+                          args: entry.type_params.map {|param| Types::Variable.new(name: param.name, location: param.location) },
+                          location: nil
+                        )
+                      )
+                    )
+
+                    Definition::Method::TypeDef.new(
+                      type: method_type,
+                      member: initialize_def.member,
+                      defined_in: initialize_def.defined_in,
+                      implemented_in: initialize_def.implemented_in
+                    ).tap do |type_def|
+                      type_def.overload_annotations.replace(initialize_def.overload_annotations)
+                    end
+                  end,
+                  accessibility: :public,
+                  alias_of: nil,
+                  alias_member: nil
+                )
+
+                definition.methods[:new] = typed_new
+
+                alias_methods.each do |alias_name|
+                  definition.methods[alias_name] = definition.methods[alias_name].update(
+                    alias_of: typed_new,
+                    defs: typed_new.defs
+                  )
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+
+    def interface_methods(interface_ancestors)
+      interface_methods = {} #: interface_methods
+
+      interface_ancestors.each do |mod|
+        source =
+          case mod.source
+          when AST::Members::Include, AST::Members::Extend
+            mod.source
+          else
+            raise "Interface mixin must be include/extend: #{mod.source.inspect}"
+          end
+
+        methods = method_builder.build_interface(mod.name)
+
+        interface_methods[mod] = [methods, source]
+      end
+
+      interface_methods
+    end
+
+    def validate_params_with(type_params, result:)
+      type_params.each do |param|
+        unless param.unchecked?
+          unless result.compatible?(param.name, with_annotation: param.variance)
+            yield param
+          end
+        end
+      end
+    end
+
+    def source_location(source, decl)
+      case source
+      when nil
+        decl.location
+      when :super
+        case decl
+        when AST::Declarations::Class
+          decl.super_class&.location
+        when AST::Ruby::Declarations::ClassDecl
+          nil
+        else
+          raise "Unexpected `:super` source location with #{decl.class}"
+        end
+      else
+        source.location
+      end
+    end
+
+    def validate_type_params(definition, ancestors:, methods:)
+      type_params = definition.type_params_decl
+
+      calculator = VarianceCalculator.new(builder: self)
+      param_names = type_params.each.map(&:name)
+
+      ancestors.each_ancestor do |ancestor|
+        case ancestor
+        when Definition::Ancestor::Instance
+          result = calculator.in_inherit(name: ancestor.name, args: ancestor.args, variables: param_names)
+          validate_params_with(type_params, result: result) do |param|
+            decl = case entry = definition.entry
+                   when Environment::ModuleEntry, Environment::ClassEntry
+                     entry.primary_decl
+                   when Environment::SingleEntry
+                     entry.decl
+                   end
+
+            raise InvalidVarianceAnnotationError.new(
+              type_name: definition.type_name,
+              param: param,
+              location: source_location(ancestor.source, decl)
+            )
+          end
+        end
+      end
+
+      methods.each do |defn|
+        next if defn.name == :initialize
+
+        method_types = case original = defn.original
+                       when AST::Members::MethodDefinition
+                         original.overloads.map(&:method_type)
+                       when AST::Members::AttrWriter, AST::Members::AttrReader, AST::Members::AttrAccessor
+                         if defn.name.to_s.end_with?("=")
+                           [
+                             MethodType.new(
+                               type_params: [],
+                               type: Types::Function.empty(original.type).update(
+                                 required_positionals: [
+                                   Types::Function::Param.new(type: original.type, name: original.name)
+                                 ]
+                               ),
+                               block: nil,
+                               location: original.location
+                             )
+                           ]
+                         else
+                           [
+                             MethodType.new(
+                               type_params: [],
+                               type: Types::Function.empty(original.type),
+                               block: nil,
+                               location: original.location
+                             )
+                           ]
+                         end
+                       when AST::Members::Alias
+                         nil
+                       when nil
+                         nil
+                       end
+
+        if method_types
+          method_types.each do |method_type|
+            merged_params = type_params
+              .reject {|param| method_type.type_param_names.include?(param.name) }
+              .concat(method_type.type_params)
+
+            result = calculator.in_method_type(method_type: method_type, variables: param_names)
+            validate_params_with(merged_params, result: result) do |param|
+              raise InvalidVarianceAnnotationError.new(
+                type_name: definition.type_name,
+                param: param,
+                location: method_type.location
+              )
+            end
+          end
+        end
+      end
+    end
+
+    def insert_variable(type_name, variables, name:, type:, source:)
+      variables[name] = Definition::Variable.new(
+        parent_variable: variables[name],
+        type: type,
+        declared_in: type_name,
+        source: source
+      )
+
+      validate_variable(variables[name])
+    end
+
+    def validate_variable(var)
+      return unless var.parent_variable
+
+      # Ignore attrs
+      variables = [] #: Array[Definition::Variable]
+      tmp_var = var
+      while tmp_var
+        case tmp_var.source
+        when AST::Members::AttrReader, AST::Members::AttrWriter, AST::Members::AttrAccessor
+          # nop
+        when AST::Ruby::Members::AttrReaderMember, AST::Ruby::Members::AttrWriterMember, AST::Ruby::Members::AttrAccessorMember
+          # nop
+        else
+          variables << tmp_var
+        end
+
+        tmp_var = tmp_var.parent_variable
+      end
+
+      # Duplicates should be eliminated, so there can't be more than 3.
+      return unless variables.length == 2
+
+      l, r = variables #: [Definition::Variable, Definition::Variable]
+
+      case l.source
+      when AST::Members::InstanceVariable
+        if r.source.instance_of?(AST::Members::InstanceVariable) && l.declared_in == r.declared_in
+          raise InstanceVariableDuplicationError.new(type_name: l.declared_in, variable_name: l.source.name, location: l.source.location)
+        end
+      when AST::Members::ClassInstanceVariable
+        if r.source.instance_of?(AST::Members::ClassInstanceVariable) && l.declared_in == r.declared_in
+          raise ClassInstanceVariableDuplicationError.new(type_name: l.declared_in, variable_name: l.source.name, location: l.source.location)
+        end
+      when AST::Ruby::Members::InstanceVariableMember
+        if l.declared_in == r.declared_in
+          raise InstanceVariableDuplicationError.new(type_name: l.declared_in, variable_name: l.source.name, location: l.source.location)
+        end
+      end
+    end
+
+    def import_methods(definition, module_name, module_methods, interfaces_methods, subst, self_type_methods)
+      new_methods = {} #: Hash[Symbol, Definition::Method]
+      interface_method_duplicates = Set[] #: Set[Symbol]
+
+      interfaces_methods.each do |interface, (methods, member)|
+        unless interface.args.empty?
+          methods.type.is_a?(Types::Interface) or raise
+
+          interface.args.each do |arg|
+            validate_type_presence(arg)
+          end
+
+          type_params = env.interface_decls.fetch(interface.name).decl.type_params
+          if s = AST::TypeParam.application(type_params, interface.args)
+            subst_ = subst + s
+          else
+            subst_ = subst
+          end
+        else
+          subst_ = subst
+        end
+
+        methods.each do |method|
+          if interface_method_duplicates.include?(method.name)
+            (member.is_a?(AST::Members::Include) || member.is_a?(AST::Members::Extend)) or raise
+
+            raise DuplicatedInterfaceMethodDefinitionError.new(
+              type: definition.self_type,
+              method_name: method.name,
+              member: member
+            )
+          end
+
+          interface_method_duplicates << method.name
+          define_method(
+            new_methods,
+            definition,
+            method,
+            subst_,
+            nil,
+            defined_in: interface.name,
+            implemented_in: module_name
+          )
+        end
+      end
+
+      module_methods.each do |method|
+        define_method(
+          new_methods,
+          definition,
+          method,
+          subst,
+          self_type_methods,
+          defined_in: module_name,
+          implemented_in: module_name.interface? ? nil : module_name
+        )
+      end
+
+      definition.methods.merge!(new_methods)
+    end
+
+    def define_method(methods, definition, method, subst, self_type_methods, defined_in:, implemented_in: defined_in)
+      existing_method = methods[method.name] || definition.methods[method.name]
+
+      case original = method.original
+      when AST::Members::Alias
+        original_method = methods[original.old_name] || definition.methods[original.old_name] || self_type_methods&.fetch(original.old_name, nil)
+
+        unless original_method
+          raise UnknownMethodAliasError.new(
+            type_name: definition.type_name,
+            original_name: original.old_name,
+            aliased_name: original.new_name,
+            location: original.location
+          )
+        end
+
+        accessibility = special_accessibility(original.instance?, original.new_name) || original_method.accessibility
+
+        method_definition = Definition::Method.new(
+          super_method: existing_method,
+          defs: original_method.defs.map do |defn|
+            defn.update(defined_in: defined_in, implemented_in: implemented_in)
+          end,
+          accessibility: accessibility,
+          alias_of: original_method,
+          alias_member: original
+        )
+
+        method_definition.annotations.replace(original.annotations)
+      when AST::Members::MethodDefinition
+        if duplicated_method = methods[method.name]
+          raise DuplicatedMethodDefinitionError.new(
+            type: definition.self_type,
+            method_name: method.name,
+            members: [original, *duplicated_method.members]
+          )
+        end
+
+        defs = original.overloads.map do |overload|
+          Definition::Method::TypeDef.new(
+            type: subst.empty? ? overload.method_type : overload.method_type.sub(subst),
+            member: original,
+            defined_in: defined_in,
+            implemented_in: implemented_in
+          ).tap do |type_def|
+            # Keep the original annotations given to overloads.
+            type_def.overload_annotations.replace(overload.annotations)
+          end
+        end
+
+        # Respect the visibility of the original method definition.
+        accessibility = original.visibility || special_accessibility(original.instance?, method.name) || method.accessibility
+
+        # Skip setting up `super_method` if `implemented_in` is `nil`, that means the type doesn't have implementation.
+        # This typically happens if the type is an interface.
+        if implemented_in
+          super_method = existing_method
+        end
+
+        method_definition = Definition::Method.new(
+          super_method: super_method,
+          defs: defs,
+          accessibility: accessibility,
+          alias_of: nil,
+          alias_member: nil
+        )
+
+        method_definition.annotations.replace(original.annotations)
+      when AST::Members::AttrReader, AST::Members::AttrWriter, AST::Members::AttrAccessor
+        if duplicated_method = methods[method.name]
+          raise DuplicatedMethodDefinitionError.new(
+            type: definition.self_type,
+            method_name: method.name,
+            members: [*duplicated_method.members, original]
+          )
+        end
+
+        attr_type = original.type.sub(subst)
+        method_type =
+          if method.name.to_s.end_with?("=")
+            # setter
+            MethodType.new(
+              type_params: [],
+              type: Types::Function.empty(attr_type).update(
+                required_positionals: [
+                  Types::Function::Param.new(type: attr_type, name: original.name)
+                ]
+              ),
+              block: nil,
+              location: original.location
+            )
+          else
+            # getter
+            MethodType.new(
+              type_params: [],
+              type: Types::Function.empty(attr_type),
+              block: nil,
+              location: original.location
+            )
+          end
+
+        if implemented_in
+          super_method = existing_method
+        end
+
+        # Respect the visibility of the original method definition.
+        accessibility = original.visibility || special_accessibility(original.kind == :instance, method.name) || method.accessibility
+
+        method_definition = Definition::Method.new(
+          super_method: super_method,
+          defs: [
+            Definition::Method::TypeDef.new(
+              type: method_type,
+              member: original,
+              defined_in: defined_in,
+              implemented_in: implemented_in
+            )
+          ],
+          accessibility: accessibility,
+          alias_of: nil,
+          alias_member: nil
+        )
+
+        method_definition.annotations.replace(original.annotations)
+      when AST::Ruby::Members::AttrReaderMember, AST::Ruby::Members::AttrWriterMember, AST::Ruby::Members::AttrAccessorMember
+        if duplicated_method = methods[method.name]
+          raise DuplicatedMethodDefinitionError.new(
+            type: definition.self_type,
+            method_name: method.name,
+            members: [*duplicated_method.members, original]
+          )
+        end
+
+        attr_type = original.type || Types::Bases::Any.new(location: nil)
+        method_type =
+          if method.name.to_s.end_with?("=")
+            # setter
+            MethodType.new(
+              type_params: [],
+              type: Types::Function.empty(attr_type).update(
+                required_positionals: [
+                  Types::Function::Param.new(type: attr_type, name: method.name.to_s.chomp("=").to_sym)
+                ]
+              ),
+              block: nil,
+              location: original.location
+            )
+          else
+            # getter
+            MethodType.new(
+              type_params: [],
+              type: Types::Function.empty(attr_type),
+              block: nil,
+              location: original.location
+            )
+          end
+
+        if implemented_in
+          super_method = existing_method
+        end
+
+        method_definition = Definition::Method.new(
+          super_method: super_method,
+          defs: [
+            Definition::Method::TypeDef.new(
+              type: method_type,
+              member: original,
+              defined_in: defined_in,
+              implemented_in: implemented_in
+            )
+          ],
+          accessibility: method.accessibility,
+          alias_of: nil,
+          alias_member: nil
+        )
+
+        method_definition.annotations.replace([])
+      when AST::Ruby::Members::DefMember
+        if duplicated_method = methods[method.name]
+          raise DuplicatedMethodDefinitionError.new(
+            type: definition.self_type,
+            method_name: method.name,
+            members: [original, *duplicated_method.members]
+          )
+        end
+
+        if original.method_type.empty? && existing_method
+          # Unannotated method with a parent definition → inherit from the parent, like @rbs ...
+          method_definition = Definition::Method.new(
+            super_method: existing_method,
+            defs: existing_method.defs.map { |defn| defn.update(implemented_in: implemented_in) },
+            accessibility: :public,
+            alias_of: existing_method.alias_of,
+            alias_member: nil
+          )
+
+          method_definition.annotations.replace(existing_method.annotations)
+        else
+          defs = original.overloads.map do |overload|
+            Definition::Method::TypeDef.new(
+              type: subst.empty? ? overload.method_type : overload.method_type.sub(subst),
+              member: original,
+              defined_in: defined_in,
+              implemented_in: implemented_in
+            ).tap do |type_def|
+              # Keep the original annotations given to overloads.
+              type_def.overload_annotations.replace(overload.annotations)
+            end
+          end
+
+          method_definition = Definition::Method.new(
+            super_method: existing_method,
+            defs: defs,
+            accessibility: :public,
+            alias_of: nil,
+            alias_member: nil
+          )
+
+          method_definition.annotations.replace([])
+        end
+
+      when nil
+        # Overloading method definition only
+
+        case
+        when methods.key?(method.name)
+          # The method is defined in an interface
+          super_method = methods[method.name].super_method
+        when definition.methods.key?(method.name)
+          # The method is defined in the super class
+          super_method = existing_method
+        else
+          # Cannot find any non-overloading method
+          raise InvalidOverloadMethodError.new(
+            type_name: definition.type_name,
+            method_name: method.name,
+            kind: :instance,
+            members: method.overloads
+          )
+        end
+
+        method_definition = Definition::Method.new(
+          super_method: super_method,
+          defs: existing_method.defs.map do |defn|
+            defn.update(implemented_in: implemented_in)
+          end,
+          accessibility: existing_method.accessibility,
+          alias_of: existing_method.alias_of,
+          alias_member: nil
+        )
+
+        method_definition.annotations.replace(existing_method.annotations)
+      end
+
+      method.overloads.each do |overloading_def|
+        overloading_def.overloads.reverse_each do |overload|
+          type_def = Definition::Method::TypeDef.new(
+            type: subst.empty? ? overload.method_type : overload.method_type.sub(subst),
+            member: overloading_def,
+            defined_in: defined_in,
+            implemented_in: implemented_in
+          )
+
+          type_def.overload_annotations.replace(overload.annotations)
+
+          method_definition.defs.unshift(type_def)
+        end
+
+        method_definition.annotations.concat(overloading_def.annotations)
+      end
+
+      method_definition.defs.each do |type_def|
+        type_def.member_annotations.replace(method_definition.annotations)
+      end
+
+      methods[method.name] = method_definition
+    end
+
+    def special_accessibility(is_instance, method_name)
+      if is_instance && [:initialize, :initialize_copy, :initialize_clone, :initialize_dup, :respond_to_missing?].include?(method_name)
+        :private
+      end
+    end
+
+    def try_cache(type_name, cache:)
+      cache[type_name] ||= yield
+    end
+
+    def expand_alias(type_name)
+      expand_alias2(type_name, [])
+    end
+
+    def expand_alias1(type_name)
+      type_name = env.normalize_type_name(type_name)
+      entry = env.type_alias_decls[type_name] or raise "Unknown alias name: #{type_name}"
+      as = entry.decl.type_params.each.map { Types::Bases::Any.new(location: nil) }
+      expand_alias2(type_name, as)
+    end
+
+    def expand_alias2(type_name, args)
+      type_name = env.normalize_type_name(type_name)
+      entry = env.type_alias_decls[type_name] or raise "Unknown alias name: #{type_name}"
+
+      ensure_namespace!(type_name.namespace, location: entry.decl.location)
+      params = entry.decl.type_params.each.map(&:name)
+
+      unless params.size == args.size
+        as = "[#{args.join(", ")}]" unless args.empty?
+        ps = "[#{params.join(", ")}]" unless params.empty?
+
+        raise "Invalid type application: type = #{type_name}#{as}, decl = #{type_name}#{ps}"
+      end
+
+      type = entry.decl.type
+
+      unless params.empty?
+        subst = Substitution.build(params, args)
+        type = type.sub(subst)
+      end
+
+      type
+    end
+
+    def update(env:, except:, ancestor_builder:)
+      method_builder = self.method_builder.update(env: env, except: except)
+
+      DefinitionBuilder.new(env: env, ancestor_builder: ancestor_builder, method_builder: method_builder).tap do |builder|
+        builder.instance_cache.merge!(instance_cache)
+        builder.singleton_cache.merge!(singleton_cache)
+        builder.singleton0_cache.merge!(singleton0_cache)
+        builder.interface_cache.merge!(interface_cache)
+
+        except.each do |name|
+          builder.instance_cache.delete(name)
+          builder.singleton_cache.delete(name)
+          builder.singleton0_cache.delete(name)
+          builder.interface_cache.delete(name)
+        end
+      end
+    end
+
+    def validate_type_presence(type)
+      case type
+      when Types::ClassInstance, Types::ClassSingleton, Types::Interface, Types::Alias
+        validate_type_name(type.name, type.location)
+      end
+
+      type.each_type do |type|
+        validate_type_presence(type)
+      end
+    end
+
+    def validate_type_name(name, location)
+      name = name.absolute! unless name.absolute?
+      return if env.type_name?(env.normalize_type_name(name))
+
+      raise NoTypeFoundError.new(type_name: name, location: location)
+    end
+  end
+end