[ksss]

This PR implements proposal 1 of #1334: singleton(C) is allowed as a module self type constraint, so that a module extended to a class (e.g. Rails' ClassMethods pattern) can declare the class methods it depends on without copying them into an interface.

class Model
  def self.find: (Integer) -> instance
end

module ClassMethods : singleton(Model)
  def find_or_raise: (Integer) -> Model   # can call `find` of `singleton(Model)`
end

class User < Model
  extend ClassMethods
end

Changes

• Syntax: module Foo : singleton(Bar) and singleton(Bar)[T] (type arguments are optional, as in the class singleton type). Documented in docs/syntax.md.
• AST: new node RBS::AST::Declarations::Module::SingletonSelf (name, args, location). Module::Self is unchanged, so existing consumers keep working. Module#self_types is now Array[Module::Self | Module::SingletonSelf]. Both classes get #update.
• Ancestors: singleton self types become Definition::Ancestor::Singleton (with a new optional source attribute) in OneAncestors#self_types. The recursive ancestor check goes through singleton_ancestors, consistent with the existing check for class instance self types (module M : Foo + class Foo; include M is an error today, and so is module M : singleton(C) + class C; extend M).
• Definitions: build_instance(Foo) merges build_singleton(Bar) (methods and class instance variables). Methods defined in Foo take precedence. Method types are taken as written: instance/class/self are not rewritten, consistent with class instance self types, and resolving them is left to the type checker.
• Validation: singleton(_Interface) is rejected by the parser and by NoSelfTypeFoundError.check!.

Not included

Proposal 2 of #1334 (singleton(M) < singleton(C) when module M : singleton(C)) is intentionally not included. The self inside the body of M is a Module object at runtime and does not respond to the class methods of C, so treating singleton(M) as a subtype of singleton(C) would be unsound.

Also out of scope: the inline # @rbs module-self: annotation, and the Steep side (type_construction.rb converts module_entry.self_types to types by name.interface?/name.class?, so it needs a branch for SingletonSelf → Types::ClassSingleton).

🤖 Generated with Claude Code