rbs 3.9.4 → 4.1.1

data/sig/cli.rbs

@@ -46,41 +46,41 @@ module RBS
 
     def has_parser?: () -> bool
 
-    def run: (Array[String] args) -> void
+    def run: (Array[String] args) -> Integer
 
-    def run_ast: (Array[String], LibraryOptions) -> void
+    def run_ast: (Array[String], LibraryOptions) -> Integer
 
-    def run_list: (Array[String], LibraryOptions) -> void
+    def run_list: (Array[String], LibraryOptions) -> Integer
 
-    def run_ancestors: (Array[String], LibraryOptions) -> void
+    def run_ancestors: (Array[String], LibraryOptions) -> Integer
 
-    def run_methods: (Array[String], LibraryOptions) -> void
+    def run_methods: (Array[String], LibraryOptions) -> Integer
 
-    def run_method: (Array[String], LibraryOptions) -> void
+    def run_method: (Array[String], LibraryOptions) -> Integer
 
-    def run_validate: (Array[String], LibraryOptions) -> void
+    def run_validate: (Array[String], LibraryOptions) -> Integer
 
-    def run_constant: (Array[String], LibraryOptions) -> void
+    def run_constant: (Array[String], LibraryOptions) -> Integer
 
-    def run_paths: (Array[String], LibraryOptions) -> void
+    def run_paths: (Array[String], LibraryOptions) -> Integer
 
-    def run_prototype: (Array[String], LibraryOptions) -> void
+    def run_prototype: (Array[String], LibraryOptions) -> Integer
 
-    def run_prototype_file: (String format, Array[String]) -> void
+    def run_prototype_file: (String format, Array[String]) -> Integer
 
-    def run_vendor: (Array[String], LibraryOptions) -> void
+    def run_vendor: (Array[String], LibraryOptions) -> Integer
 
-    def run_parse: (Array[String], LibraryOptions) -> void
+    def run_parse: (Array[String], LibraryOptions) -> Integer
 
-    def run_test: (Array[String], LibraryOptions) -> void
+    def run_test: (Array[String], LibraryOptions) -> Integer
 
-    def run_collection: (Array[String], LibraryOptions) -> void
+    def run_collection: (Array[String], LibraryOptions) -> Integer
 
-    def run_annotate: (Array[String], top) -> void
+    def run_annotate: (Array[String], top) -> Integer
 
-    def run_subtract: (Array[String], top) -> void
+    def run_subtract: (Array[String], top) -> Integer
 
-    def run_diff: (Array[String], LibraryOptions) -> void
+    def run_diff: (Array[String], LibraryOptions) -> Integer
 
     def test_opt: (LibraryOptions) -> String?
 

data/sig/collection/config/lockfile_generator.rbs

@@ -6,6 +6,8 @@ module RBS
         #
         ALUMNI_STDLIBS: Hash[String, String?]
 
+        NONGEM_STDLIBS: Set[String]
+
         class GemfileLockMismatchError < StandardError
           @expected: Pathname
 

data/sig/definition.rbs

@@ -12,6 +12,10 @@ module RBS
                   | AST::Members::InstanceVariable
                   | AST::Members::ClassVariable
                   | AST::Members::ClassInstanceVariable
+                  | AST::Ruby::Members::AttrReaderMember
+                  | AST::Ruby::Members::AttrWriterMember
+                  | AST::Ruby::Members::AttrAccessorMember
+                  | AST::Ruby::Members::InstanceVariableMember
       attr_reader source: source
 
       def initialize: (parent_variable: Variable?, type: Types::t, declared_in: TypeName, source: source) -> void
@@ -21,6 +25,7 @@ module RBS
 
     class Method
       type method_member = AST::Members::MethodDefinition | AST::Members::AttrReader | AST::Members::AttrAccessor | AST::Members::AttrWriter
+                         | AST::Ruby::Members::DefMember | AST::Ruby::Members::AttrReaderMember | AST::Ruby::Members::AttrWriterMember | AST::Ruby::Members::AttrAccessorMember
 
       class TypeDef
         attr_reader type: MethodType
@@ -154,6 +159,7 @@ module RBS
         type source = :super     # Inheritance
                     | nil        # Itself
                     | AST::Members::Include | AST::Members::Extend | AST::Members::Prepend  # AST
+                    | AST::Ruby::Members::IncludeMember | AST::Ruby::Members::ExtendMember | AST::Ruby::Members::PrependMember  # Ruby AST
                     | AST::Declarations::Module::Self
 
         attr_reader name: TypeName

data/sig/definition_builder.rbs

@@ -97,13 +97,15 @@ module RBS
     #
     def interface_methods: (Array[Definition::Ancestor::Instance] interface_ancestors) -> interface_methods
 
+    def special_accessibility: (bool, Symbol) -> Definition::accessibility?
+
     def try_cache: (TypeName, cache: Hash[TypeName, Definition | false | nil]) { () -> Definition } -> Definition
 
     def validate_params_with: (Array[AST::TypeParam], result: VarianceCalculator::Result) { (AST::TypeParam) -> void } -> void
 
     def validate_type_params: (Definition, ancestors: AncestorBuilder::OneAncestors, methods: MethodBuilder::Methods) -> void
 
-    def source_location: (Definition::Ancestor::Instance::source, AST::Declarations::t) -> Location[untyped, untyped]?
+    def source_location: (Definition::Ancestor::Instance::source, AST::Declarations::t | AST::Ruby::Declarations::t) -> Location[untyped, untyped]?
 
     def validate_variable: (Definition::Variable) -> void
 

data/sig/environment/class_entry.rbs

@@ -0,0 +1,50 @@
+module RBS
+  class Environment
+    # Represents a class entry in the environment
+    #
+    # ```rb
+    # entry = ClassEntry.new(TypeName.parse("::String"))
+    # entry << [nil, declaration]
+    # entry << [[nil, TypeName.parse("::Kernel")], declaration]
+    # ```
+    class ClassEntry
+      attr_reader name: TypeName
+
+      type declaration = AST::Declarations::Class | AST::Ruby::Declarations::ClassDecl
+
+      type context_decl = [Resolver::context, declaration]
+
+      attr_reader context_decls: Array[context_decl]
+
+      @primary_decl: declaration?
+
+      def initialize: (TypeName) -> void
+
+      def <<: (context_decl) -> self
+
+      def each_decl: { (declaration) -> void } -> void
+                   | () -> Enumerator[declaration]
+
+      # Returns true if the entry doesn't have any declaration
+      #
+      def empty?: () -> bool
+
+      # Find the *primary* declaration of the class
+      #
+      # * Returns the first declaration with super class
+      # * Returns the first declaration if the declaration doesn't have super class
+      #
+      %a{pure} def primary_decl: () -> declaration
+
+      # Returns the generics declaration
+      #
+      def type_params: () -> Array[AST::TypeParam]
+
+      # Confirms if the type parameters in the declaration are compatible
+      #
+      # * Raises `GenericParameterMismatchError` if incompatible declaration is detected.
+      #
+      def validate_type_params: () -> void
+    end
+  end
+end

data/sig/environment/module_entry.rbs

@@ -0,0 +1,50 @@
+module RBS
+  class Environment
+    # Represents a class entry in the environment
+    #
+    # ```rb
+    # entry = ModuleEntry.new(TypeName.parse("::Kernel"))
+    # entry << [nil, declaration]
+    # entry << [[nil, TypeName.parse("::Object")], declaration]
+    # ```
+    #
+    class ModuleEntry
+      attr_reader name: TypeName
+
+      type declaration = AST::Declarations::Module | AST::Ruby::Declarations::ModuleDecl
+
+      type context_decl = [Resolver::context, declaration]
+
+      attr_reader context_decls: Array[context_decl]
+
+      def initialize: (TypeName) -> void
+
+      def <<: (context_decl) -> self
+
+      def each_decl: { (declaration) -> void } -> void
+                   | () -> Enumerator[declaration]
+
+      # Returns true if the entry doesn't have any declaration
+      #
+      def empty?: () -> bool
+
+      # Returns the first declaration
+      #
+      # This method helps using the class with `ClassEntry` objects.
+      #
+      def primary_decl: () -> declaration
+
+      # Returns the generics declaration
+      #
+      def type_params: () -> Array[AST::TypeParam]
+
+      # Confirms if the type parameters in the declaration are compatible
+      #
+      # * Raises `GenericParameterMismatchError` if incompatible declaration is detected.
+      #
+      def validate_type_params: () -> void
+
+      def self_types: () -> Array[AST::Declarations::Module::Self]
+    end
+  end
+end

data/sig/environment.rbs

@@ -2,81 +2,20 @@ module RBS
   class Environment
     type module_decl = AST::Declarations::Class | AST::Declarations::Module
 
-    interface _ModuleOrClass
-      def name: () -> TypeName
-
-      def type_params: () -> Array[AST::TypeParam]
-    end
-
-    interface _NamedDecl
-      def name: () -> TypeName
-    end
-
-    module ContextUtil
-      def calculate_context: (Array[_NamedDecl]) -> Resolver::context
-    end
-
-    # Name of object, it's (multiple) declarations with the outer module declarations
-    #
-    class MultiEntry[M < _ModuleOrClass]
-      class D[M < _ModuleOrClass]
-        attr_reader decl: M
-        attr_reader outer: Array[module_decl]
-
-        def initialize: (decl: M, outer: Array[module_decl]) -> void
-
-        include ContextUtil
-
-        @context: Resolver::context
-
-        def context: () -> Resolver::context
-      end
-
-      attr_reader name: TypeName
-      attr_reader decls: Array[D[M]]
-
-      @primary: D[M]?
-
-      def initialize: (name: TypeName) -> void
-
-      def insert: (decl: M, outer: Array[module_decl]) -> void
-
-      def validate_type_params: () -> void
-
-      def compatible_params?: (Array[AST::TypeParam], Array[AST::TypeParam]) -> boolish
-
-      def type_params: () -> Array[AST::TypeParam]
-
-      def primary: () -> D[M]
-    end
-
-    class ModuleEntry < MultiEntry[AST::Declarations::Module]
-      def self_types: () -> Array[AST::Declarations::Module::Self]
-    end
-
-    class ClassEntry < MultiEntry[AST::Declarations::Class]
-    end
-
     # Name of object, it's (single) declaration, and the outer module declarations
     #
     class SingleEntry[N, D]
       attr_reader name: N
       attr_reader decl: D
-      attr_reader outer: Array[module_decl]
-
-      def initialize: (name: N, decl: D, outer: Array[module_decl]) -> void
+      attr_reader context: Resolver::context
 
-      include ContextUtil
-
-      @context: Resolver::context
-
-      def context: () -> Resolver::context
+      def initialize: (name: N, decl: D, context: Resolver::context) -> void
     end
 
-    class ModuleAliasEntry < SingleEntry[TypeName, AST::Declarations::ModuleAlias]
+    class ModuleAliasEntry < SingleEntry[TypeName, AST::Declarations::ModuleAlias | AST::Ruby::Declarations::ClassModuleAliasDecl]
     end
 
-    class ClassAliasEntry < SingleEntry[TypeName, AST::Declarations::ClassAlias]
+    class ClassAliasEntry < SingleEntry[TypeName, AST::Declarations::ClassAlias | AST::Ruby::Declarations::ClassModuleAliasDecl]
     end
 
     class InterfaceEntry < SingleEntry[TypeName, AST::Declarations::Interface]
@@ -85,14 +24,18 @@ module RBS
     class TypeAliasEntry < SingleEntry[TypeName, AST::Declarations::TypeAlias]
     end
 
-    class ConstantEntry < SingleEntry[TypeName, AST::Declarations::Constant]
+    class ConstantEntry < SingleEntry[TypeName, AST::Declarations::Constant | AST::Ruby::Declarations::ConstantDecl]
     end
 
     class GlobalEntry < SingleEntry[Symbol, AST::Declarations::Global]
     end
 
     # Top level declarations
-    attr_reader declarations: Array[AST::Declarations::t]
+    def declarations: () -> Array[AST::Ruby::Declarations::t | AST::Declarations::t]
+
+    # Array of source objects loaded in the environment
+    #
+    attr_reader sources: Array[Source::t]
 
     # Class declarations
     attr_reader class_decls: Hash[TypeName, ModuleEntry | ClassEntry]
@@ -111,10 +54,6 @@ module RBS
     # Global declarations
     attr_reader global_decls: Hash[Symbol, GlobalEntry]
 
-    # A hash from Buffer to it's contents
-    #
-    attr_reader signatures: Hash[Buffer, [Array[AST::Directives::t], Array[AST::Declarations::t]]]
-
     def initialize: () -> void
 
     def initialize_copy: (Environment) -> void
@@ -123,15 +62,21 @@ module RBS
     #
     def self.from_loader: (EnvironmentLoader) -> Environment
 
-    def add_signature: (buffer: Buffer, directives: Array[AST::Directives::t], decls: Array[AST::Declarations::t]) -> void
+    def add_source: (Source::t) -> void
+
+    def each_rbs_source: () { (Source::RBS) -> void } -> void
+                      | () -> Enumerator[Source::RBS]
 
-    # Insert a toplevel declaration into the environment
+    def each_ruby_source: () { (Source::Ruby) -> void } -> void
+                        | () -> Enumerator[Source::Ruby]
+
+    # Insert a declaration into the environment
     #
-    def <<: (AST::Declarations::t decl) -> self
+    private def insert_rbs_decl: (AST::Declarations::t, context: Resolver::context, namespace: Namespace) -> void
 
     # Insert a declaration into the environment
     #
-    private def insert_decl: (AST::Declarations::t, outer: Array[module_decl], namespace: Namespace) -> void
+    private def insert_ruby_decl: (AST::Ruby::Declarations::t, context: Resolver::context, namespace: Namespace) -> void
 
     # Resolve all type names in the environment to absolute type names.
     # Relative type name will be left if absolute type name cannot be found.
@@ -139,9 +84,15 @@ module RBS
     # When `only` is given, it skips other _top-level_ declarations not included in the collection.
     # This helps running resolution faster in the case of _partial updates_.
     #
-    def resolve_type_names: (?only: Set[AST::Declarations::t]?) -> Environment
+    def resolve_type_names: (?only: Set[AST::Declarations::t | AST::Ruby::Declarations::t]?) -> Environment
 
-    def resolve_signature: (Resolver::TypeNameResolver, UseMap::Table, Array[AST::Directives::t], Array[AST::Declarations::t], ?only: Set[AST::Declarations::t]?) -> [Array[AST::Directives::t], Array[AST::Declarations::t]]
+    def resolve_signature: (
+      Resolver::TypeNameResolver,
+      UseMap::Table,
+      Array[AST::Directives::t],
+      Array[AST::Declarations::t],
+      ?only: Set[AST::Declarations::t | AST::Ruby::Declarations::t]?
+    ) -> [Array[AST::Directives::t], Array[AST::Declarations::t]]
 
     def inspect: () -> String
 
@@ -149,7 +100,8 @@ module RBS
 
     # Remove declarations and directives that are loaded from `buffers`
     #
-    def unload: (Set[Buffer] buffers) -> Environment
+    def unload: (Set[Pathname] paths) -> Environment
+              | %a{deprecated: Use pathname version} (Set[Buffer] buffers) -> Environment
 
     # Returns true if an interface with the type name is defined
     #
@@ -190,22 +142,58 @@ module RBS
     # Returns true if the type name is a class alias
     def class_alias?: (TypeName) -> bool
 
-    def class_entry: (TypeName) -> (ClassEntry | ClassAliasEntry | nil)
+    # Returns the entry for the class name
+    #
+    # Returns `nil` when:
+    #
+    # * The type name is not found
+    # * The type name is not a class
+    #
+    # It normalizes when `normalized: true` is given -- returns `ClassEntry` or `nil`.
+    #
+    def class_entry: (TypeName, normalized: true) -> ClassEntry?
+                   | (TypeName, ?normalized: bool) -> (ClassEntry | ClassAliasEntry | nil)
 
     # Returns ClassEntry if the class definition is found, normalized in case of alias
     #
+    %a{deprecated: Use `class_entry(type_name, normalized: true)` instead. }
     def normalized_class_entry: (TypeName) -> ClassEntry?
 
-    def module_entry: (TypeName) -> (ModuleEntry | ModuleAliasEntry | nil)
+    # Returns the entry for the module name
+    #
+    # Returns `nil` when:
+    #
+    # * The type name is not found
+    # * The type name is not a module
+    #
+    # It normalizes when `normalized: true` is given -- returns `ModuleEntry` or `nil`.
+    #
+    def module_entry: (TypeName, normalized: true) -> ModuleEntry?
+                    | (TypeName, ?normalized: bool) -> (ModuleEntry | ModuleAliasEntry | nil)
 
     # Returns ModuleEntry if the module definition is found, normalized in case of alias
     #
+    %a{deprecated: Use `module_entry(type_name, normalized: true)` instead. }
     def normalized_module_entry: (TypeName) -> ModuleEntry?
 
-    def constant_entry: (TypeName) -> (ClassEntry | ClassAliasEntry | ModuleEntry | ModuleAliasEntry | ConstantEntry | nil)
+    # Returns the entry for the type name
+    #
+    # The entry is one of ClassEntry, ModuleEntry, ConstantEntry, ClassAliasEntry, or ModuleAliasEntry.
+    # When `normalized: true` is given, it returns normalized entry -- one of ClassEntry, ModuleEntry, or ConstantEntry.
+    #
+    # Returns `nil` if not found.
+    #
+    def constant_entry: (TypeName, normalized: true) -> (ClassEntry | ModuleEntry | ConstantEntry | nil)
+                      | (TypeName, ?normalized: bool) -> (ClassEntry | ClassAliasEntry | ModuleEntry | ModuleAliasEntry | ConstantEntry | nil)
 
-    def module_class_entry: (TypeName) -> (ClassEntry | ClassAliasEntry | ModuleEntry | ModuleAliasEntry | nil)
+    # Returns ClassEntry or ModuleEntry if the class/module definition is found
+    #
+    # Normalizes when `normalized: true` is given.
+    #
+    def module_class_entry: (TypeName, normalized: true) -> (ClassEntry | ModuleEntry | nil)
+                          | (TypeName, ?normalized: bool) -> (ClassEntry | ClassAliasEntry | ModuleEntry | ModuleAliasEntry | nil)
 
+    %a{deprecated: Use `module_class_entry(type_name, normalized: true)` instead. }
     def normalized_module_class_entry: (TypeName) -> (ClassEntry | ModuleEntry | nil)
 
     @normalize_module_name_cache: Hash[TypeName, TypeName | false | nil]
@@ -216,26 +204,39 @@ module RBS
     # * Returns `nil` if the rhs name cannot be found
     # * Returns `false` if the name is cyclic
     #
+    # Note that this method assumes the declarations have resolved type names.
+    #
     def normalize_module_name?: (TypeName) -> (TypeName | nil | false)
 
-    # Returns the original module name that is defined with `module` declaration
+    # Returns the original module name that is defined with `module`/`class` declaration
     #
-    # * Raises an error if given type name is not module
+    # * Raises an error if given type name is not module/class
     # * Calls `#absolute!` for relative module names
     # * Returns the name itself if the name cannot be normalized to a class/module
     #
+    # Note that this method assumes the declarations have resolved type names.
+    #
     def normalize_module_name: (TypeName) -> TypeName
 
+    # Returns the original module name that is defined with `module`/`class` declaration
+    #
+    # * Raises an error if given type name is not a module/class
+    def normalize_module_name!: (TypeName) -> TypeName
+
     # Returns a normalized module/class name or a type name with a normalized namespace
     #
     # * Calls `#absolute!` for relative module names
     # * Returns `nil` if the typename cannot be found
     # * Returns `false` if the name is cyclic
     #
+    # Note that this method assumes the declarations have resolved type names.
+    #
     def normalize_type_name?: (TypeName) -> (TypeName | nil | false)
 
     # Normalize the type name or raises an error
     #
+    # Note that this method assumes the declarations have resolved type names.
+    #
     def normalize_type_name!: (TypeName) -> TypeName
 
     # Returns a normalized module/class name or a type name with a normalized namespace
@@ -243,6 +244,8 @@ module RBS
     # * Calls `#absolute!` for relative module names
     # * Returns the typename itself if the name cannot be normalized
     #
+    # Note that this method assumes the declarations have resolved type names.
+    #
     def normalize_type_name: (TypeName) -> TypeName
 
     # Returns `true` if given type name is normalized
@@ -264,7 +267,7 @@ module RBS
 
     def append_context: (Resolver::context, module_decl) -> Resolver::context
 
-    def resolve_declaration: (Resolver::TypeNameResolver resolver, UseMap map, AST::Declarations::t decl, outer: Array[module_decl], prefix: Namespace) -> AST::Declarations::t
+    def resolve_declaration: (Resolver::TypeNameResolver resolver, UseMap map, AST::Declarations::t decl, context: Resolver::context, prefix: Namespace) -> AST::Declarations::t
 
     def resolve_member: (Resolver::TypeNameResolver, UseMap map, AST::Members::t, context: Resolver::context) -> AST::Members::t
 
@@ -272,8 +275,12 @@ module RBS
 
     def resolve_type_params: (Resolver::TypeNameResolver resolver, UseMap map, Array[AST::TypeParam], context: Resolver::context) ->  Array[AST::TypeParam]
 
-    def absolute_type: (Resolver::TypeNameResolver, UseMap map, Types::t, context: Resolver::context) -> Types::t
+    def resolve_ruby_decl: (Resolver::TypeNameResolver, AST::Ruby::Declarations::t, context: Resolver::context, prefix: Namespace) -> AST::Ruby::Declarations::t
+
+    def resolve_ruby_member: (Resolver::TypeNameResolver, AST::Ruby::Members::t, context: Resolver::context) -> AST::Ruby::Members::t
+
+    def absolute_type: (Resolver::TypeNameResolver, UseMap? map, Types::t, context: Resolver::context) -> Types::t
 
-    def absolute_type_name: (Resolver::TypeNameResolver, UseMap map, TypeName, context: Resolver::context) -> TypeName
+    def absolute_type_name: (Resolver::TypeNameResolver, UseMap? map, TypeName, context: Resolver::context) -> TypeName
   end
 end

data/sig/errors.rbs

@@ -115,14 +115,16 @@ module RBS
   class NoMixinFoundError < DefinitionError
     include DetailedMessageable
 
+    type member = AST::Members::t | AST::Ruby::Members::IncludeMember | AST::Ruby::Members::ExtendMember | AST::Ruby::Members::PrependMember
+
     attr_reader type_name: TypeName
-    attr_reader member: AST::Members::t
+    attr_reader member: member
 
-    def initialize: (type_name: TypeName, member: AST::Members::t) -> void
+    def initialize: (type_name: TypeName, member: member) -> void
 
     def location: () -> Location[untyped, untyped]?
 
-    def self.check!: (TypeName, env: Environment, member: AST::Members::t) -> void
+    def self.check!: (TypeName, env: Environment, member: member) -> void
   end
 
   class DuplicatedMethodDefinitionError < DefinitionError
@@ -226,28 +228,35 @@ module RBS
   class InvalidOverloadMethodError < DefinitionError
     include DetailedMessageable
 
+    type member = AST::Members::MethodDefinition | AST::Ruby::Members::DefMember
+
     attr_reader type_name: TypeName
     attr_reader method_name: Symbol
     attr_reader kind: :instance | :singleton
-    attr_reader members: Array[AST::Members::MethodDefinition]
+    attr_reader members: Array[member]
 
-    def initialize: (type_name: TypeName, method_name: Symbol, kind: :instance | :singleton, members: Array[AST::Members::MethodDefinition]) -> void
+    def initialize: (type_name: TypeName, method_name: Symbol, kind: :instance | :singleton, members: Array[member]) -> void
 
     def location: () -> AST::Members::MethodDefinition::loc?
   end
 
   class GenericParameterMismatchError < LoadingError
+    type decl = AST::Declarations::Class | AST::Declarations::Module
+              | AST::Ruby::Declarations::ClassDecl | AST::Ruby::Declarations::ModuleDecl
+
     attr_reader name: TypeName
-    attr_reader decl: AST::Declarations::Class | AST::Declarations::Module
+    attr_reader decl: decl
 
-    def initialize: (name: TypeName, decl: AST::Declarations::Class | AST::Declarations::Module) -> void
+    def initialize: (name: TypeName, decl: decl, ?location: Location) -> void
   end
 
   class DuplicatedDeclarationError < LoadingError
+    type declaration = AST::Declarations::t | AST::Ruby::Declarations::t
+
     attr_reader name: TypeName | Symbol
-    attr_reader decls: Array[AST::Declarations::t]
+    attr_reader decls: Array[declaration]
 
-    def initialize: (TypeName | Symbol, *AST::Declarations::t) -> void
+    def initialize: (TypeName | Symbol, *declaration) -> void
   end
 
   class InvalidVarianceAnnotationError < DefinitionError
@@ -280,6 +289,7 @@ module RBS
     include DetailedMessageable
 
     type member = AST::Members::Include | AST::Members::Prepend | AST::Members::Extend
+                | AST::Ruby::Members::IncludeMember | AST::Ruby::Members::PrependMember | AST::Ruby::Members::ExtendMember
 
     attr_reader type_name: TypeName
     attr_reader member: member
@@ -290,17 +300,21 @@ module RBS
 
     def self.check!: (type_name: TypeName, env: Environment, member: member) -> void
 
+    def member_name: (member) -> TypeName
+
     def mixin_name: () -> String
   end
 
   # InheritModuleError is raised if a class definition inherits a module (not a class)
   #
   class InheritModuleError < DefinitionError
+    type super_class = AST::Declarations::Class::Super | AST::Ruby::Declarations::ClassDecl::SuperClass
+
     include DetailedMessageable
 
-    attr_reader super_decl: AST::Declarations::Class::Super
+    attr_reader super_decl: super_class
 
-    def initialize: (AST::Declarations::Class::Super) -> void
+    def initialize: (super_class) -> void
 
     def location: () -> Location[untyped, untyped]?
 
@@ -308,7 +322,7 @@ module RBS
     #
     # Automatically normalize the name of super.
     #
-    def self.check!: (AST::Declarations::Class::Super, env: Environment) -> void
+    def self.check!: (super_class, env: Environment) -> void
   end
 
   class RecursiveTypeAliasError < BaseError
@@ -380,14 +394,6 @@ module RBS
     def location: () -> AST::Declarations::AliasDecl::loc?
   end
 
-  class WillSyntaxError < BaseError
-    include RBS::DetailedMessageable
-
-    def initialize: (String message, location: Location[untyped, untyped]?) -> void
-
-    attr_reader location: Location[untyped, untyped]?
-  end
-
   class TypeParamDefaultReferenceError < BaseError
     include DetailedMessageable