rbs-relaxed 3.9.0.1

data/sig/prototype/rb.rbs

@@ -0,0 +1,96 @@
+module RBS
+  module Prototype
+    class RB
+      include Helpers
+
+      class Context
+        type method_kind = :singleton | :singleton_instance | :instance
+
+        attr_accessor module_function: bool
+
+        attr_accessor singleton: bool
+
+        attr_accessor namespace: Namespace
+
+        attr_accessor in_def: bool
+
+        def initialize: (module_function: bool, singleton: bool, namespace: Namespace, in_def: bool) -> void
+
+        def method_kind: () -> method_kind
+
+        def attribute_kind: () -> (:singleton | :instance)
+
+        def enter_namespace: (Namespace) -> Context
+
+        def update: (?module_function: bool, ?singleton: bool, ?in_def: bool) -> Context
+
+        def self.initial: (?namespace: Namespace) -> Context
+      end
+
+      type decl = AST::Declarations::t | AST::Members::t
+
+      attr_reader source_decls: Array[decl]
+
+      def initialize: () -> void
+
+      def decls: () -> Array[AST::Declarations::t]
+
+      def parse: (String) -> void
+
+      def process: (untyped node, decls: Array[AST::Declarations::t | AST::Members::t], comments: Hash[Integer, AST::Comment], context: Context) -> void
+
+      def process_children: (RubyVM::AbstractSyntaxTree::Node node, decls: Array[decl], comments: Hash[Integer, AST::Comment], context: Context) -> void
+
+      # Returns a type name that represents the name of the constant.
+      # `node` must be _constant_ node, `CONST`, `COLON2`, or `COLON3` node.
+      #
+      def const_to_name!: (RubyVM::AbstractSyntaxTree::Node node, ?context: Context?) -> TypeName
+
+      # Returns a type name that represents the name of the constant.
+      # `node` can be `SELF` for `extend self` pattern.
+      #
+      def const_to_name: (RubyVM::AbstractSyntaxTree::Node? node, context: Context) -> TypeName?
+
+      def literal_to_symbol: (RubyVM::AbstractSyntaxTree::Node node) -> Symbol?
+
+      def function_type_from_body: (RubyVM::AbstractSyntaxTree::Node node, Symbol def_name) -> Types::Function
+
+      def function_return_type_from_body: (RubyVM::AbstractSyntaxTree::Node node) -> Types::t
+
+      def body_type: (RubyVM::AbstractSyntaxTree::Node node) -> Types::t
+
+      def if_unless_type: (RubyVM::AbstractSyntaxTree::Node node) -> Types::t
+
+      def block_type: (RubyVM::AbstractSyntaxTree::Node node) -> Types::t
+
+      def literal_to_type: (RubyVM::AbstractSyntaxTree::Node node) -> Types::t
+
+      def types_to_union_type: (Array[Types::t] types) -> Types::t
+
+      def range_element_type: (Array[Types::t] types) -> Types::t
+
+      def param_type: (RubyVM::AbstractSyntaxTree::Node node, ?default: Types::Bases::Any) -> Types::t
+
+      # backward compatible
+      alias node_type param_type
+
+      def private: () -> AST::Members::Private
+
+      @private: AST::Members::Private?
+
+      def public: () -> AST::Members::Public
+
+      @public: AST::Members::Public?
+
+      def current_accessibility: (Array[decl] decls, ?Integer index) -> (AST::Members::Private | AST::Members::Public)
+
+      def remove_unnecessary_accessibility_methods!: (Array[decl]) -> void
+
+      def is_accessibility?: (decl) -> bool
+
+      def find_def_index_by_name: (Array[decl] decls, Symbol name) -> [Integer, AST::Members::MethodDefinition | AST::Members::AttrReader | AST::Members::AttrWriter]?
+
+      def sort_members!: (Array[decl] decls) -> void
+    end
+  end
+end

data/sig/prototype/rbi.rbs

@@ -0,0 +1,75 @@
+module RBS
+  module Prototype
+    class RBI
+      include Helpers
+      
+      attr_reader decls: Array[AST::Declarations::t]
+
+      type module_decl = AST::Declarations::Class | AST::Declarations::Module
+
+      # A stack representing the module nesting structure in the Ruby code
+      attr_reader modules: Array[module_decl]
+
+      # Last subsequent `sig` calls
+      attr_reader last_sig: Array[RubyVM::AbstractSyntaxTree::Node]?
+
+      def initialize: () -> void
+
+      def parse: (String) -> void
+
+      def nested_name: (RubyVM::AbstractSyntaxTree::Node name) -> TypeName
+
+      def current_namespace: () -> Namespace
+
+      def push_class: (
+        RubyVM::AbstractSyntaxTree::Node name,
+        RubyVM::AbstractSyntaxTree::Node super_class,
+        comment: AST::Comment?
+      ) { () -> void } -> void
+
+      def push_module: (RubyVM::AbstractSyntaxTree::Node name, comment: AST::Comment?) { () -> void } -> void
+
+      # The inner most module/class definition, returns `nil` on toplevel
+      def current_module: () -> module_decl?
+
+      # The inner most module/class definition, raises on toplevel
+      def current_module!: () -> module_decl
+
+      # Put a `sig` call to current list.
+      def push_sig: (RubyVM::AbstractSyntaxTree::Node node) -> void
+
+      # Clear the `sig` call list
+      def pop_sig: () -> Array[RubyVM::AbstractSyntaxTree::Node]?
+
+      def join_comments: (Array[RubyVM::AbstractSyntaxTree::Node] nodes, Hash[Integer, AST::Comment] comments) -> AST::Comment
+
+      def process: (RubyVM::AbstractSyntaxTree::Node node, comments: Hash[Integer, AST::Comment], ?outer: Array[RubyVM::AbstractSyntaxTree::Node]) -> void
+
+      def method_type: (RubyVM::AbstractSyntaxTree::Node? args_node, RubyVM::AbstractSyntaxTree::Node? type_node, variables: Array[AST::TypeParam], overloads: Integer) -> MethodType?
+
+      def parse_params: (RubyVM::AbstractSyntaxTree::Node args_node, RubyVM::AbstractSyntaxTree::Node args, MethodType method_type, variables: Array[AST::TypeParam], overloads: Integer) -> MethodType
+
+      def type_of: (RubyVM::AbstractSyntaxTree::Node type_node, variables: Array[AST::TypeParam]) -> Types::t
+
+      def type_of0: (RubyVM::AbstractSyntaxTree::Node type_node, variables: Array[AST::TypeParam]) -> Types::t
+
+      def proc_type?: (RubyVM::AbstractSyntaxTree::Node type_node) -> bool
+
+      def call_node?: (RubyVM::AbstractSyntaxTree::Node node, name: Symbol, ?receiver: ^(RubyVM::AbstractSyntaxTree::Node) -> bool, ?args: ^(RubyVM::AbstractSyntaxTree::Node) -> bool) -> bool
+
+      # Receives a constant node and returns `TypeName` instance
+      def const_to_name: (RubyVM::AbstractSyntaxTree::Node node) -> TypeName
+
+      # Receives `:ARRAY` or `:LIST` node and yields the child nodes.
+      def each_arg: (RubyVM::AbstractSyntaxTree::Node array) { (RubyVM::AbstractSyntaxTree::Node) -> void } -> void
+                  | (RubyVM::AbstractSyntaxTree::Node array) -> Enumerator[RubyVM::AbstractSyntaxTree::Node, void]
+
+      # Receives node and yields the child nodes.
+      def each_child: (RubyVM::AbstractSyntaxTree::Node node) { (RubyVM::AbstractSyntaxTree::Node) -> void } -> void
+                    | (RubyVM::AbstractSyntaxTree::Node node) -> Enumerator[RubyVM::AbstractSyntaxTree::Node, void]
+
+      # Receives a keyword `:HASH` node and returns hash instance.
+      def node_to_hash: (RubyVM::AbstractSyntaxTree::Node node) -> Hash[Symbol, RubyVM::AbstractSyntaxTree::Node]?
+    end
+  end
+end

data/sig/prototype/runtime.rbs

@@ -0,0 +1,182 @@
+module RBS
+  module Prototype
+    class Runtime
+      module Reflection
+        self.@object_class: UnboundMethod
+        def self.object_class: (Module value) -> Class
+
+        self.@constants_of: UnboundMethod
+        def self.constants_of: (Module mod, ?bool inherit) -> Array[Symbol]
+      end
+
+      module Helpers
+        @module_name_method: UnboundMethod
+        @untyped: Types::Bases::Any
+
+        private
+
+        def const_name: (Module const) -> String?
+
+        def const_name!: (Module const) -> String
+
+        # Returns the exact name & not compactly declared name
+        def only_name: (Module mod) -> String
+
+        def to_type_name: (String name, ?full_name: bool) -> TypeName
+
+        def untyped: () -> Types::Bases::Any
+      end
+
+      class ValueObjectBase
+        include Helpers
+
+        # @target_class stores the singleton object of `Data` or `Struct` subclass
+        @target_class: untyped
+
+        def build_decl: () -> AST::Declarations::Class
+
+        private
+
+        def build_member_accessors: (untyped ast_members_class) -> untyped
+
+        def build_s_members: () -> Array[AST::Members::MethodDefinition]
+
+        def build_super_class: () -> AST::Declarations::Class::Super
+
+        def add_decl_members: (AST::Declarations::Class) -> void
+
+        def initialize: (Class target_class) -> void
+      end
+
+      class StructGenerator < ValueObjectBase
+        def self.generatable?: (Class target) -> bool
+
+        private
+
+        def add_decl_members: (AST::Declarations::Class decl) -> void
+
+        def build_overload_for_keyword_arguments: () -> AST::Members::MethodDefinition::Overload
+
+        def build_overload_for_positional_arguments: () -> AST::Members::MethodDefinition::Overload
+
+        def build_s_keyword_init_p: () -> Array[AST::Members::MethodDefinition]
+
+        def build_s_new: () -> Array[AST::Members::MethodDefinition]
+
+        def build_super_class: () -> AST::Declarations::Class::Super
+
+        CAN_CALL_KEYWORD_INIT_P: bool
+      end
+
+      class DataGenerator < ValueObjectBase
+        def self.generatable?: (Class target) -> bool
+
+        private
+
+        def add_decl_members: (AST::Declarations::Class decl) -> void
+
+        def build_s_new: () -> Array[AST::Members::MethodDefinition]
+
+        def build_super_class: () -> AST::Declarations::Class::Super
+      end
+
+      class Todo
+        @builder: DefinitionBuilder
+
+        @mixin_decls_cache: Hash[TypeName, Array[untyped]]
+
+        def initialize: (builder: DefinitionBuilder) -> void
+
+        def skip_mixin?: (type_name: TypeName, module_name: TypeName, mixin_class: mixin_class) -> bool
+
+        def skip_singleton_method?: (module_name: TypeName, method: UnboundMethod, accessibility: Definition::accessibility) -> bool
+
+        def skip_instance_method?: (module_name: TypeName, method: UnboundMethod, accessibility: Definition::accessibility) -> bool
+
+        def skip_constant?: (module_name: String, name: Symbol) -> bool
+
+        private def mixin_decls: (TypeName type_name) -> Array[AST::Members::Include | AST::Members::Extend | AST::Members::Prepend]
+      end
+
+      type mixin_class = singleton(AST::Members::Include) | singleton(AST::Members::Prepend) | singleton(AST::Members::Extend)
+
+      @decls: Array[AST::Declarations::t]?
+
+      @modules: Hash[String, Module]
+
+      @builder: DefinitionBuilder
+
+      @module_name_method: UnboundMethod
+      @object_class: UnboundMethod
+
+      @todo_object: Todo?
+
+      include Helpers
+
+      attr_reader patterns: Array[String]
+
+      attr_reader env: Environment
+
+      attr_reader merge: bool
+
+      attr_reader todo: bool
+
+      attr_accessor outline: bool
+
+      attr_reader owners_included: Array[Module]
+
+      def initialize: (patterns: Array[String], env: Environment, merge: bool, ?todo: bool, ?owners_included: Array[Symbol]) -> void
+
+      def target?: (Module const) -> bool
+
+      def todo_object: () -> Todo?
+
+      def builder: () -> DefinitionBuilder
+
+      def parse: (String file) -> void
+
+      def decls: () -> Array[AST::Declarations::t]
+
+      def each_mixined_module: (TypeName type_name, Module mod) { (TypeName, TypeName, mixin_class) -> void } -> void
+
+      def each_mixined_module_one: (TypeName type_name, Module mod) { (TypeName, TypeName, bool) -> void } -> void
+
+      def method_type: (UnboundMethod method) -> MethodType
+
+      def merge_rbs: [A] (TypeName module_name, Array[AST::Declarations::Class::member] members, singleton: Symbol) { () -> A } -> A?
+                   | [A] (TypeName module_name, Array[AST::Declarations::Class::member] members, instance: Symbol) { () -> A } -> A?
+
+      def target_method?: (Module mod, instance: Symbol) -> bool
+                        | (Module mod, singleton: Symbol) -> bool
+
+      def generate_methods: (Module mod, TypeName module_name, Array[AST::Declarations::Class::member] members) -> void
+
+      def generate_constants: (Module mod, Array[AST::Declarations::Class::member] decls) -> void
+
+      def generate_super_class: (Class mod) -> AST::Declarations::Class::Super?
+
+      def generate_class: (Class mod) -> void
+
+      def generate_module: (Module mod) -> void
+
+      def generate_mixin: (Module mod, AST::Declarations::Class | AST::Declarations::Module, TypeName, TypeName) -> void
+
+      # Generate/find outer module declarations
+      # This is broken down into another method to comply with `DRY`
+      # This generates/finds declarations in nested form & returns the last array of declarations
+      def ensure_outer_module_declarations: (Module mod) -> Array[AST::Declarations::Class::member]
+
+      def object_class: (untyped) -> untyped
+
+      def type_args: (TypeName type_name) -> Array[Types::t]
+
+      def block_from_ast_of: (UnboundMethod method) -> Types::Block?
+
+      def block_from_body: (RubyVM::AbstractSyntaxTree::Node) -> Types::Block?
+
+      def can_alias?: (Module, UnboundMethod) -> bool
+
+      def type_params: (Module) -> Array[AST::TypeParam]
+    end
+  end
+end

data/sig/rbs.rbs

@@ -0,0 +1,21 @@
+module RBS
+  def self.logger: () -> Logger
+
+  def self.logger_level: () -> Integer?
+
+  def self.logger_level=: (Integer?) -> Integer?
+
+  %a{pure} def self.logger_output: () -> IO?
+
+  def self.logger_output=: (IO) -> IO
+
+  def self.print_warning: () { () -> String } -> void
+
+  self.@logger: Logger?
+
+  self.@logger_output: IO?
+
+  self.@logger_level: Integer?
+
+  self.@warnings: Set[String]
+end

data/sig/rdoc/rbs.rbs

@@ -0,0 +1,67 @@
+module RDoc
+  class Parser
+    class RBS < Parser
+    end
+  end
+end
+
+module RBS
+  module RDocPlugin
+    class Parser
+      @top_level: RDoc::TopLevel
+
+      @content: String
+
+      type allowed_decls = RBS::AST::Declarations::Class
+                         | RBS::AST::Declarations::Module
+                         | RBS::AST::Declarations::Constant
+
+      def initialize: (RDoc::TopLevel top_level, String content) -> void
+
+      def scan: () -> RDoc::TopLevel
+
+      def parse_member: (decl: RBS::AST::Declarations::t | RBS::AST::Members::t, context: RDoc::Context, ?outer_name: RBS::TypeName?) -> void
+
+      def parse_class_decl: (decl: RBS::AST::Declarations::Class, context: RDoc::Context, ?outer_name: RBS::TypeName?) -> void
+
+      def parse_module_decl: (decl: RBS::AST::Declarations::Module | RBS::AST::Declarations::Interface, context: RDoc::Context, ?outer_name: RBS::TypeName?) -> void
+
+      def parse_constant_decl: (decl: RBS::AST::Declarations::Constant, context: RDoc::Context, ?outer_name: RBS::TypeName?) -> void
+
+      def parse_method_decl: (decl: RBS::AST::Members::MethodDefinition, context: RDoc::Context, ?outer_name: RBS::TypeName?) -> void
+
+      def parse_method_alias_decl: (decl: RBS::AST::Members::Alias, context: RDoc::Context, ?outer_name: RBS::TypeName?) -> void
+
+      def parse_attr_decl: (decl: RBS::AST::Members::AttrReader | RBS::AST::Members::AttrAccessor | RBS::AST::Members::AttrWriter, context: RDoc::Context, ?outer_name: RBS::TypeName?) -> void
+
+      def parse_include_decl: (decl: RBS::AST::Members::Include, context: RDoc::Context, ?outer_name: RBS::TypeName?) -> void
+
+      def parse_extend_decl: (decl: RBS::AST::Members::Extend, context: RDoc::Context, ?outer_name: RBS::TypeName?) -> void
+
+      private
+
+      def construct_comment: (context: RDoc::Context, comment: String) -> RDoc::Comment
+
+      # _DeclWithComment is a utility interface that has `#comment`
+      #
+      interface _DeclWithComment
+        def comment: () -> ::RBS::AST::Comment?
+      end
+
+      # Extract comment string from a declaration with comment
+      #
+      # * If `#comment" returns a Comment object, it returns its `#string` value
+      # * If `#comment` returns `nil`, it raises an error
+      #
+      # Note that you have to confirm if the `#comment` of given declaration exists.
+      #
+      # ```ruby
+      # comment = construct_comment(context: context, comment: comment_string(decl)) if decl.comment
+      # ```
+      #
+      def comment_string: (_DeclWithComment) -> String
+
+      def fully_qualified_name: (outer_name: RBS::TypeName?, decl: allowed_decls) -> RBS::TypeName
+    end
+  end
+end

data/sig/repository.rbs

@@ -0,0 +1,85 @@
+module RBS
+  # Set of RBS repositories.
+  #
+  # A repository object can handle multiple repository roots.
+  #
+  # ```ruby
+  # repo = RBS::Repository.new()
+  # repo.add(Pathname("vendor/rbs/gem-rbs"))
+  # repo.add(Pathname("vendor/rbs/internal-rbs"))
+  # repo.add(Pathname("vendor/rbs/definitely-rbs"))
+  #
+  # repo.lookup("minitest", "2.1.3") # => Pathname or nil
+  # ```
+  #
+  # If one gem version can resolve to several directories, the last added dir wins.
+  #
+  class Repository
+    class GemRBS
+      attr_reader name: String
+
+      # Array of gem dirs.
+      # Gem dir contains directories for each version.
+      attr_reader paths: Array[Pathname]
+
+      # Hash from a version to VersionPath object.
+      attr_reader versions(): Hash[Gem::Version, VersionPath]
+
+      @versions: Hash[Gem::Version, VersionPath]?
+
+      def initialize: (name: String) -> void
+
+      def load!: () -> void
+
+      def version_names: () -> Array[Gem::Version]
+
+      def oldest_version: () -> VersionPath
+
+      def latest_version: () -> VersionPath
+
+      def find_best_version: (Gem::Version?) -> VersionPath
+
+      # Returns true if versions is empty.
+      def empty?: () -> bool
+    end
+
+    class VersionPath
+      attr_reader gem: GemRBS
+      attr_reader version: Gem::Version
+      attr_reader path: Pathname
+
+      def initialize: (gem: GemRBS, version: Gem::Version, path: Pathname) -> void
+    end
+
+    DEFAULT_STDLIB_ROOT: Pathname
+
+    # Array of _root dir_s of repositories.
+    #
+    attr_reader dirs: Array[Pathname]
+
+    attr_reader gems: Hash[String, GemRBS]
+
+    def self.default: () -> instance
+
+    def self.find_best_version: (Gem::Version? version, Array[Gem::Version] candidates) -> Gem::Version
+
+    # An optional keyword argument `no_stdlib` is to skip adding directory for stdlib classes.
+    # Passing truthy value will skip loading stdlib. (You can add the stdlib root by yourself.)
+    #
+    def initialize: (?no_stdlib: bool) -> void
+
+    # Add new _root dir_ to the repository set.
+    # If two repository dirs have exactly same gem-version definitions, the latter overwrites the prior.
+    #
+    def add: (Pathname dir) -> void
+
+    # Returns a directory for given `gem` name and `version`.
+    # `version` can be `nil` for _any version_.
+    #
+    # If the given gem cannot be found, it returns `nil`.
+    #
+    def lookup: (String gem, String? version) -> Pathname?
+
+    def lookup_path: (String gem, String? version) -> [GemRBS, VersionPath]?
+  end
+end

data/sig/resolver/constant_resolver.rbs

@@ -0,0 +1,92 @@
+module RBS
+  module Resolver
+    class ConstantResolver
+      # Table stores the set of immediate child constants of a module.
+      #
+      # ```rb
+      # table = RBS::ConstantResolver::Table.new(env)
+      #
+      # table.children(TypeName.parse("::Object"))                # -> { ... }  Returns a hash of name and constants.
+      # table.children(TypeName.parse("::File::PATH_SEPARATOR"))  # -> nil      Returns nil because the constant is not a module.
+      #
+      # table.toplevel                                      # -> { ... }  Returns a hash of top level constants.
+      # ```
+      #
+      # The `#toplevel` is incompatible with Ruby.
+      # All constants in Ruby are defined under `Object`, and they are accessed with `::` (Colon3) operator.
+      # RBS is different.
+      # `::` constants are _toplevel_ constants, and they are not defined under `::Object`.
+      #
+      # The behavior is simulated in `ConstantResolver`.
+      #
+      class Table
+        attr_reader children_table: Hash[TypeName, Hash[Symbol, Constant]?]
+        attr_reader constants_table: Hash[TypeName, Constant]
+        attr_reader toplevel: Hash[Symbol, Constant]
+
+        def initialize: (Environment) -> void
+
+        def constant: (TypeName constant_name) -> Constant?
+
+        # Returns a set of constants defined under `module_name`.
+        # Returns `nil` if there is no module with given `module_name`.
+        #
+        def children: (TypeName module_name) -> Hash[Symbol, Constant]?
+
+        private
+
+        def constant_of_module: (TypeName name, Environment::ClassEntry | Environment::ModuleEntry) -> Constant
+
+        def constant_of_constant: (TypeName name, Environment::ConstantEntry) -> Constant
+      end
+
+      attr_reader builder: DefinitionBuilder
+      attr_reader table: Table
+      attr_reader context_constants_cache: Hash[context, Hash[Symbol, Constant]?]
+      attr_reader child_constants_cache: Hash[TypeName, Hash[Symbol, Constant]]
+
+      def initialize: (builder: DefinitionBuilder) -> void
+
+      # Resolves to `Constant` with given constant name `name` and `context`.
+      # Returns `nil` if the constant cannot be resolved from the context.
+      #
+      def resolve: (Symbol name, context: context) -> Constant?
+
+      # Returns the available all constants from `context`.
+      #
+      # Returns `nil` when the `context` is invalid.
+      def constants: (context) -> Hash[Symbol, Constant]?
+
+      # Resolves the module_name and constant name to `Constant`
+      #
+      # ```ruby
+      # A::B
+      # ^     <- module_name
+      #    ^  <- constant_name
+      # ```
+      #
+      def resolve_child: (TypeName module_name, Symbol constant_name) -> Constant?
+
+      # Returns the table of all constants accessible with `::` (colon2) operator.
+      #
+      # * The constants under the module are included.
+      # * The constants under the ancestor modules are included.
+      #   * The constants under the `::Object` class are not included.
+      #   * The top level constants are not included.
+      #
+      def children: (TypeName module_name) -> Hash[Symbol, Constant]
+
+      private
+
+      def load_context_constants: (context) -> void
+
+      def load_child_constants: (TypeName) -> void
+
+      def constants_from_context: (context, constants: Hash[Symbol, Constant]) -> bool
+
+      def constants_from_ancestors: (TypeName, constants: Hash[Symbol, Constant]) -> void
+
+      def constants_itself: (context, constants: Hash[Symbol, Constant]) -> void
+    end
+  end
+end

data/sig/resolver/context.rbs

@@ -0,0 +1,34 @@
+module RBS
+  module Resolver
+    # `context` represents the module nesting structure.
+    #
+    # - `nil` means toplevel
+    # - A 2-tuple represents parent and the most inner module
+    #   - `TypeName` is for a module
+    #   - `false` is for unknown module
+    #
+    # Note that the `TypeName` must be an absolute type name.
+    #
+    # The following Ruby code has context of `[[nil, TypeName.parse("::Foo")], false]` where
+    #
+    # * `Foo` is a class defined in RBS file
+    # * `Bar` is not defined in RBS files
+    #
+    # ```ruby
+    # class Foo
+    #   module Bar
+    #     # Context here
+    #   end
+    # end
+    # ```
+    #
+    # The unknown module (`false`) appears only in Ruby code.
+    # RBS modules/classes are always exists (or defines new module).
+    # Nesting a unknown module cannot happen in RBS.
+    #
+    # In Ruby this happens when the module/class is not declared in RBS files.
+    #
+    type context = [context, TypeName | false]
+                 | nil
+  end
+end

data/sig/resolver/type_name_resolver.rbs

@@ -0,0 +1,35 @@
+module RBS
+  module Resolver
+    # TypeNameResolver resolves given relative type name to absolute type name under a module nesting context.
+    #
+    # The type name resolution doesn't take account of ancestors of modules.
+    # It just ignores included modules and super classes.
+    #
+    class TypeNameResolver
+      type query = [TypeName, context]
+
+      def initialize: (Environment) -> void
+
+      # Translates given type name to absolute type name.
+      # Returns `nil` if cannot find associated type name.
+      #
+      def resolve: (TypeName, context: context) -> TypeName?
+
+      private
+
+      attr_reader env: Environment
+
+      attr_reader all_names: Set[TypeName]
+
+      attr_reader cache: Hash[query, TypeName?]
+
+      def has_name?: (TypeName) -> TypeName?
+
+      def try_cache: (query) { () -> TypeName? } -> TypeName?
+
+      def resolve_in: (Symbol, context) -> TypeName?
+
+      def partition: (TypeName) -> [Symbol, TypeName?]
+    end
+  end
+end