class RBS::DefinitionBuilder::MethodBuilder

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/lib/rbs/definition_builder/method_builder.rb, line 91
def initialize(env:)
  @env = env

  @instance_methods = {}
  @singleton_methods = {}
  @interface_methods = {}
end

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/lib/rbs/definition_builder/method_builder.rb, line 211
def build_alias(methods, type, member:)
  defn = methods.methods[member.new_name] ||= Methods::Definition.empty(type: type, name: member.new_name)
  defn.originals << member
end

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/lib/rbs/definition_builder/method_builder.rb, line 216
def build_attribute(methods, type, member:, accessibility:)
  if member.is_a?(AST::Members::AttrReader) || member.is_a?(AST::Members::AttrAccessor)
    defn = methods.methods[member.name] ||= Methods::Definition.empty(type: type, name: member.name)

    defn.accessibilities << accessibility
    defn.originals << member
  end

  if member.is_a?(AST::Members::AttrWriter) || member.is_a?(AST::Members::AttrAccessor)
    defn = methods.methods[:"#{member.name}="] ||= Methods::Definition.empty(type: type, name: :"#{member.name}=")

    defn.accessibilities << accessibility
    defn.originals << member
  end
end

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/lib/rbs/definition_builder/method_builder.rb, line 99
def build_instance(type_name)
  instance_methods[type_name] ||=
    begin
      entry = env.class_decls[type_name]
      args = entry.type_params.map {|param| Types::Variable.new(name: param.name, location: param.location) }
      type = Types::ClassInstance.new(name: type_name, args: args, location: nil)
      Methods.new(type: type).tap do |methods|
        entry.each_decl do |decl|
          subst = Substitution.build(decl.type_params.each.map(&:name), args)
          case decl
          when AST::Declarations::Base
            each_rbs_member_with_accessibility(decl.members) do |member, accessibility|
              case member
              when AST::Members::MethodDefinition
                case member.kind
                when :instance
                  build_method(
                    methods,
                    type,
                    member: member.update(overloads: member.overloads.map {|overload| overload.sub(subst) }),
                    accessibility: member.visibility || accessibility
                  )
                when :singleton_instance
                  build_method(
                    methods,
                    type,
                    member: member.update(overloads: member.overloads.map {|overload| overload.sub(subst) }),
                    accessibility: :private
                  )
                end
              when AST::Members::AttrReader, AST::Members::AttrWriter, AST::Members::AttrAccessor
                if member.kind == :instance
                  build_attribute(methods,
                                  type,
                                  member: member.update(type: member.type.sub(subst)),
                                  accessibility: member.visibility || accessibility)
                end
              when AST::Members::Alias
                if member.kind == :instance
                  build_alias(methods, type, member: member)
                end
              end
            end
          when AST::Ruby::Declarations::Base
            decl.members.each do |member|
              case member
              when AST::Ruby::Members::DefMember
                build_method(
                  methods,
                  type,
                  member: member,
                  accessibility: :public
                )
              when AST::Ruby::Members::AttrReaderMember, AST::Ruby::Members::AttrWriterMember, AST::Ruby::Members::AttrAccessorMember
                build_ruby_attribute(methods, type, member: member, accessibility: :public)
              end
            end
          end
        end
      end.validate!
    end
end

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/lib/rbs/definition_builder/method_builder.rb, line 191
def build_interface(type_name)
  interface_methods[type_name] ||=
    begin
      entry = env.interface_decls[type_name]
      args = Types::Variable.build(entry.decl.type_params.each.map(&:name))
      type = Types::Interface.new(name: type_name, args: args, location: nil)

      Methods.new(type: type).tap do |methods|
        entry.decl.members.each do |member|
          case member
          when AST::Members::MethodDefinition
            build_method(methods, type, member: member, accessibility: :public)
          when AST::Members::Alias
            build_alias(methods, type, member: member)
          end
        end
      end.validate!
    end
end

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/lib/rbs/definition_builder/method_builder.rb, line 250
def build_method(methods, type, member:, accessibility:)
  defn = methods.methods[member.name] ||= Methods::Definition.empty(type: type, name: member.name)

  if member.overloading?
    defn.overloads << member
  else
    defn.accessibilities << accessibility
    defn.originals << member
  end
end

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/lib/rbs/definition_builder/method_builder.rb, line 232
def build_ruby_attribute(methods, type, member:, accessibility:)
  member.names.each do |name|
    if member.is_a?(AST::Ruby::Members::AttrReaderMember) || member.is_a?(AST::Ruby::Members::AttrAccessorMember)
      defn = methods.methods[name] ||= Methods::Definition.empty(type: type, name: name)

      defn.accessibilities << accessibility
      defn.originals << member
    end

    if member.is_a?(AST::Ruby::Members::AttrWriterMember) || member.is_a?(AST::Ruby::Members::AttrAccessorMember)
      defn = methods.methods[:"#{name}="] ||= Methods::Definition.empty(type: type, name: :"#{name}=")

      defn.accessibilities << accessibility
      defn.originals << member
    end
  end
end

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/lib/rbs/definition_builder/method_builder.rb, line 162
def build_singleton(type_name)
  singleton_methods[type_name] ||=
    begin
      entry = env.class_decls[type_name]
      type = Types::ClassSingleton.new(name: type_name, location: nil)

      Methods.new(type: type).tap do |methods|
        entry.each_decl do |decl|
          decl.members.each do |member|
            case member
            when AST::Members::MethodDefinition
              if member.singleton?
                build_method(methods, type, member: member, accessibility: member.visibility || :public)
              end
            when AST::Members::AttrReader, AST::Members::AttrWriter, AST::Members::AttrAccessor
              if member.kind == :singleton
                build_attribute(methods, type, member: member, accessibility: member.visibility || :public)
              end
            when AST::Members::Alias
              if member.kind == :singleton
                build_alias(methods, type, member: member)
              end
            end
          end
        end
      end.validate!
    end
end

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/lib/rbs/definition_builder/method_builder.rb, line 261
def each_rbs_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

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/lib/rbs/definition_builder/method_builder.rb, line 274
def update(env:, except:)
  MethodBuilder.new(env: env).tap do |copy|
    copy.instance_methods.merge!(instance_methods)
    copy.singleton_methods.merge!(singleton_methods)
    copy.interface_methods.merge!(interface_methods)

    except.each do |type_name|
      copy.instance_methods.delete(type_name)
      copy.singleton_methods.delete(type_name)
      copy.interface_methods.delete(type_name)
    end
  end
end