rbs 3.10.4 → 4.0.0

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
-
-      include ContextUtil
-
-      @context: Resolver::context
+      attr_reader 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
     #
@@ -315,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
 
@@ -323,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
 

data/sig/inline_parser/comment_association.rbs

@@ -0,0 +1,71 @@
+use RBS::AST::Ruby::CommentBlock
+
+module RBS
+  class InlineParser
+    # CommentAssociation manages the association between `Prism::Node` and `CommentBlock`
+    #
+    class CommentAssociation
+      attr_reader blocks: Array[CommentBlock]
+
+      attr_reader start_line_map: Hash[Integer, CommentBlock]
+
+      attr_reader end_line_map: Hash[Integer, CommentBlock]
+
+      # CommentBlocks that are already associated to a node, which cannot be associated to another node again
+      #
+      attr_reader associated_blocks: Set[CommentBlock]
+
+      def self.build: (Buffer, Prism::Result) -> instance
+
+      def initialize: (Array[CommentBlock]) -> void
+
+      class Reference
+        attr_reader block: CommentBlock
+
+        @associated_blocks: Set[CommentBlock]
+
+        def initialize: (CommentBlock, Set[CommentBlock]) -> void
+
+        def associate!: () -> self
+
+        def associated?: () -> bool
+      end
+
+      # Returns an unassociated CommentBlock that can be associated to given node
+      #
+      # Automatically updates association status.
+      #
+      def leading_block!: (Prism::Node) -> CommentBlock?
+
+      # Returns a Reference that is associated to given node
+      #
+      # Updates association explicitly through the reference.
+      #
+      def leading_block: (Prism::Node) -> Reference?
+
+      # Returns a CommentBlock that is associated to given node, or by its location
+      #
+      # Update association status.
+      #
+      def trailing_block!: (Prism::Node | Prism::Location) -> CommentBlock?
+
+      # Returns a Reference that is associated to given node, or by its location
+      #
+      # Updates association explicitly through the reference.
+      #
+      def trailing_block: (Prism::Node | Prism::Location) -> Reference?
+
+      # Yields leading CommentBlocks that is enclosed in the given node
+      #
+      # Note that `enclosed_blocks` works only after all of the *leading* blocks inside the node is associated.
+      #
+      # Update association status.
+      #
+      def each_enclosed_block: (Prism::Node) { (CommentBlock) -> void } -> void
+                             | (Prism::Node) -> Enumerator[CommentBlock]
+
+      def each_unassociated_block: () { (CommentBlock) -> void } -> void
+                                 | () -> Enumerator[CommentBlock]
+    end
+  end
+end

data/sig/inline_parser.rbs

@@ -0,0 +1,124 @@
+use RBS::AST::Ruby::Declarations
+
+module RBS
+  class InlineParser
+    class Result
+      attr_reader buffer: Buffer
+      attr_reader prism_result: Prism::ParseResult
+      attr_reader declarations: Array[AST::Ruby::Declarations::t]
+      attr_reader diagnostics: Array[Diagnostic::t]
+
+      def initialize: (Buffer, Prism::ParseResult) -> void
+
+      def type_fingerprint: () -> untyped
+    end
+
+    module Diagnostic
+      class Base
+        attr_reader message: String
+
+        attr_reader location: Location
+
+        def initialize: (Location, String) -> void
+      end
+
+      class NotImplementedYet < Base
+      end
+
+      class NonConstantClassName < Base
+      end
+
+      class NonConstantModuleName < Base
+      end
+
+      class NonConstantSuperClassName < Base
+      end
+
+      class TopLevelMethodDefinition < Base
+      end
+
+      class TopLevelAttributeDefinition < Base
+      end
+
+      class UnusedInlineAnnotation < Base
+      end
+
+      class AnnotationSyntaxError < Base
+      end
+
+      class MixinMultipleArguments < Base
+      end
+
+      class MixinNonConstantModule < Base
+      end
+
+      class AttributeNonSymbolName < Base
+      end
+
+      class NonConstantConstantDeclaration < Base
+      end
+
+      class ClassModuleAliasDeclarationMissingTypeName < Base
+      end
+
+      type t = NotImplementedYet
+             | NonConstantClassName | NonConstantModuleName | NonConstantSuperClassName
+             | TopLevelMethodDefinition | TopLevelAttributeDefinition
+             | UnusedInlineAnnotation | AnnotationSyntaxError
+             | MixinMultipleArguments | MixinNonConstantModule
+             | AttributeNonSymbolName
+             | NonConstantConstantDeclaration
+             | ClassModuleAliasDeclarationMissingTypeName
+    end
+
+    def self.parse: (Buffer, Prism::ParseResult) -> Result
+
+    class Parser < Prism::Visitor
+      type module_context = Declarations::ClassDecl | Declarations::ModuleDecl
+
+      include AST::Ruby::Helpers::ConstantHelper
+
+      include AST::Ruby::Helpers::LocationHelper
+
+      attr_reader comments: CommentAssociation
+
+      attr_reader result: Result
+
+      attr_reader module_nesting: Array[module_context]
+
+      def initialize: (Result) -> void
+
+      def buffer: () -> Buffer
+
+      %a{pure} def current_module: () -> module_context?
+
+      %a{pure} def current_module!: () -> module_context
+
+      def diagnostics: () -> Array[Diagnostic::t]
+
+      def push_module_nesting: [T] (module_context) { () -> T } -> T
+
+      # Returns `true` if the node is a comment block including `@rbs skip` annotation
+      #
+      # Doesn't update the `association` flag if returning `false`.
+      #
+      def skip_node?: (Prism::Node) -> bool
+
+      def insert_declaration: (module_context) -> void
+
+      def report_unused_annotation: (*AST::Ruby::Annotations::t | nil | AST::Ruby::CommentBlock::AnnotationSyntaxError) -> void
+
+      def report_unused_block: (AST::Ruby::CommentBlock) -> void
+
+      private
+
+      def parse_mixin_call: (Prism::CallNode) -> void
+
+      def parse_attribute_call: (Prism::CallNode) -> void
+
+      def parse_constant_declaration: (Prism::ConstantWriteNode | Prism::ConstantPathWriteNode) -> void
+
+      def parse_super_class: (Prism::node, Prism::Location) -> Declarations::ClassDecl::SuperClass?
+    end
+  end
+end

data/sig/location.rbs

@@ -4,14 +4,20 @@ module RBS
   #
   # A location can have _child_ locations.
   #
-  class Location[in RequiredChildKeys, in OptionalChildKeys]
+  class Location[in RequiredChildKeys = untyped, in OptionalChildKeys = untyped]
     # The buffer this location points on.
     attr_reader buffer (): Buffer
 
-    # The index of character the range starts from.
+    # The absolute start index of character the range starts from
+    #
+    # It returns the index in the `buffer.top_buffer`.
+    #
     attr_reader start_pos (): Integer
 
-    # The index of character the range ends at.
+    # The absolute end index of character the range ends at
+    #
+    # It returns the index in the `buffer.top_buffer`.
+    #
     attr_reader end_pos (): Integer
 
     def initialize: (Buffer, Integer start_pos, Integer end_pos) -> void
@@ -24,26 +30,37 @@ module RBS
     # Returns the name of the buffer.
     def name: () -> untyped
 
-    # Line of the `start_pos` (1 origin)
+    # The *raw* index of character the range starts from.
+    attr_reader _start_pos (): Integer
+
+    # The *raw* index of character the range ends at.
+    attr_reader _end_pos (): Integer
+
+    # Line of the `start_pos` (1 origin, absolute)
     attr_reader start_line (): Integer
 
-    # Column of the `start_pos` (0 origin)
+    # Column of the `start_pos` (0 origin, absolute)
     attr_reader start_column (): Integer
 
-    # Line of the `end_pos` (1 origin)
+    # Line of the `end_pos` (1 origin, absolute)
     attr_reader end_line (): Integer
 
-    # Column of the `end_pos` (0 origin)
+    # Column of the `end_pos` (0 origin, absolute)
     attr_reader end_column (): Integer
 
+    # The absolute line-column pair of the start position
+    #
     attr_reader start_loc (): Buffer::loc
 
     @start_loc: Buffer::loc?
 
+    # The absolute line-column pair of the end position
+    #
     attr_reader end_loc (): Buffer::loc
 
     @end_loc: Buffer::loc?
 
+    # The absolute range of the start and end position
     attr_reader range (): Range[Integer]
 
     @range: Range[Integer]?
@@ -97,6 +114,14 @@ module RBS
 
     def key?: (Symbol) -> bool
 
+    # Returns the location of the buffer, but the buffer is detached from the parent buffer
+    #
+    def local_location: () -> self
+
+    # Returns the source of `#local_location`
+    # 
+    def local_source: () -> String
+
     private
 
     def _add_required_child: (RequiredChildKeys name, Integer start_pos, Integer end_pos) -> void

data/sig/locator.rbs

@@ -37,8 +37,6 @@ module RBS
     #
     def find2: (line: Integer, column: Integer) -> [Symbol?, Array[component]]?
 
-    private
-
     def find_in_directive: (Integer pos, AST::Directives::t, Array[component]) -> bool
 
     def find_in_decl: (Integer pos, decl: AST::Declarations::t, array: Array[component]) -> bool

data/sig/method_builder.rbs

@@ -16,16 +16,19 @@ module RBS
         #
         class Definition
           type original = AST::Members::MethodDefinition | AST::Members::Alias | AST::Members::AttrAccessor | AST::Members::AttrWriter | AST::Members::AttrReader
+                        | AST::Ruby::Members::DefMember | AST::Ruby::Members::AttrReaderMember | AST::Ruby::Members::AttrWriterMember | AST::Ruby::Members::AttrAccessorMember
+
+          type overloading_definition = AST::Members::MethodDefinition | AST::Ruby::Members::DefMember
 
           type accessibility = RBS::Definition::accessibility
 
           attr_reader name: Symbol
           attr_reader type: instance_type
           attr_reader originals: Array[original]
-          attr_reader overloads: Array[AST::Members::MethodDefinition]
+          attr_reader overloads: Array[overloading_definition]
           attr_reader accessibilities: Array[accessibility]
 
-          def initialize: (name: Symbol, type: instance_type, originals: Array[original], overloads: Array[AST::Members::MethodDefinition], accessibilities: Array[accessibility]) -> void
+          def initialize: (name: Symbol, type: instance_type, originals: Array[original], overloads: Array[overloading_definition], accessibilities: Array[accessibility]) -> void
 
           def original: () -> original?
 
@@ -74,9 +77,11 @@ module RBS
 
       def build_attribute: (Methods, Methods::instance_type, member: AST::Members::AttrAccessor | AST::Members::AttrReader | AST::Members::AttrWriter, accessibility: Definition::accessibility) -> void
 
-      def build_method: (Methods, Methods::instance_type, member: AST::Members::MethodDefinition, accessibility: Definition::accessibility) -> void
+      def build_ruby_attribute: (Methods, Methods::instance_type, member: AST::Ruby::Members::AttrReaderMember | AST::Ruby::Members::AttrWriterMember | AST::Ruby::Members::AttrAccessorMember, accessibility: Definition::accessibility) -> void
+
+      def build_method: (Methods, Methods::instance_type, member: AST::Members::MethodDefinition | AST::Ruby::Members::DefMember, accessibility: Definition::accessibility) -> void
 
-      def each_member_with_accessibility: (Array[AST::Members::t | AST::Declarations::t], ?accessibility: Definition::accessibility) { (AST::Members::t | AST::Declarations::t, Definition::accessibility) -> void } -> void
+      def each_rbs_member_with_accessibility: (Array[AST::Members::t | AST::Declarations::t], ?accessibility: Definition::accessibility) { (AST::Members::t | AST::Declarations::t, Definition::accessibility) -> void } -> void
 
       def update: (env: Environment, except: _Each[TypeName]) -> MethodBuilder
     end

data/sig/namespace.rbs

@@ -139,8 +139,3 @@ module RBS
               | () -> Enumerator[Namespace, void]
   end
 end
-
-module Kernel
-  # Deprecated: Use `RBS::Namespace.parse` instead
-  %a{deprecated} def Namespace: (String) -> RBS::Namespace
-end