class RBS::DefinitionBuilder

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.decls[0].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.decls.each do |d|
        d.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