rbs 2.8.4 → 3.8.1

data/sig/environment.rbs

@@ -13,9 +13,11 @@ module RBS
     end
 
     module ContextUtil
-      def calculate_context: (Array[_NamedDecl]) -> Array[Namespace]
+      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
@@ -25,9 +27,9 @@ module RBS
 
         include ContextUtil
 
-        @context: Array[Namespace]
+        @context: Resolver::context
 
-        def context: () -> Array[Namespace]
+        def context: () -> Resolver::context
       end
 
       attr_reader name: TypeName
@@ -55,6 +57,8 @@ module RBS
     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
@@ -64,36 +68,70 @@ module RBS
 
       include ContextUtil
 
-      @context: Array[Namespace]
+      @context: Resolver::context
+
+      def context: () -> Resolver::context
+    end
+
+    class ModuleAliasEntry < SingleEntry[TypeName, AST::Declarations::ModuleAlias]
+    end
+
+    class ClassAliasEntry < SingleEntry[TypeName, AST::Declarations::ClassAlias]
+    end
+
+    class InterfaceEntry < SingleEntry[TypeName, AST::Declarations::Interface]
+    end
+
+    class TypeAliasEntry < SingleEntry[TypeName, AST::Declarations::TypeAlias]
+    end
 
-      def context: () -> Array[Namespace]
+    class ConstantEntry < SingleEntry[TypeName, AST::Declarations::Constant]
     end
 
-    # Top level declarations.
+    class GlobalEntry < SingleEntry[Symbol, AST::Declarations::Global]
+    end
+
+    # Top level declarations
     attr_reader declarations: Array[AST::Declarations::t]
 
+    # Class declarations
     attr_reader class_decls: Hash[TypeName, ModuleEntry | ClassEntry]
-    attr_reader interface_decls: Hash[TypeName, SingleEntry[TypeName, AST::Declarations::Interface]]
-    attr_reader alias_decls: Hash[TypeName, SingleEntry[TypeName, AST::Declarations::Alias]]
-    attr_reader constant_decls: Hash[TypeName, SingleEntry[TypeName, AST::Declarations::Constant]]
-    attr_reader global_decls: Hash[Symbol, SingleEntry[Symbol, AST::Declarations::Global]]
+
+    attr_reader class_alias_decls: Hash[TypeName, ModuleAliasEntry | ClassAliasEntry]
+
+    # Interface declarations
+    attr_reader interface_decls: Hash[TypeName, InterfaceEntry]
+
+    # Type alias declarations
+    attr_reader type_alias_decls: Hash[TypeName, TypeAliasEntry]
+
+    # Constant declarations
+    attr_reader constant_decls: Hash[TypeName, ConstantEntry]
+
+    # 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
 
+    # Construct an environment from EnvironmentLoader
+    #
     def self.from_loader: (EnvironmentLoader) -> Environment
 
-    def cache_name: [N, D] (Hash[N, SingleEntry[N, D]] cache, name: N, decl: D, outer: Array[module_decl]) -> SingleEntry[N, D]
-
-    def insert_decl: (AST::Declarations::t, outer: Array[module_decl], namespace: Namespace) -> void
+    def add_signature: (buffer: Buffer, directives: Array[AST::Directives::t], decls: Array[AST::Declarations::t]) -> void
 
-    # Insert a toplevel declaration into the env.
+    # Insert a toplevel declaration into the environment
     #
     def <<: (AST::Declarations::t decl) -> self
 
-    # Runs generics type params validation over each class definitions.
-    def validate_type_params: () -> void
+    # Insert a declaration into the environment
+    #
+    private def insert_decl: (AST::Declarations::t, outer: Array[module_decl], 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.
@@ -103,29 +141,137 @@ module RBS
     #
     def resolve_type_names: (?only: Set[AST::Declarations::t]?) -> Environment
 
-    def resolve_declaration: (TypeNameResolver resolver, AST::Declarations::t decl, outer: Array[module_decl], prefix: Namespace) -> AST::Declarations::t
+    def inspect: () -> String
+
+    def buffers: () -> Array[Buffer]
+
+    # Remove declarations and directives that are loaded from `buffers`
+    #
+    def unload: (Set[Buffer] buffers) -> Environment
 
-    def resolve_member: (TypeNameResolver, AST::Members::t, context: Array[Namespace]) -> AST::Members::t
+    # Returns true if an interface with the type name is defined
+    #
+    def interface_name?: (TypeName) -> bool
 
-    def resolve_method_type: (TypeNameResolver, RBS::MethodType, context: Array[Namespace]) -> RBS::MethodType
+    # Returns true if a type alias with the type name is defined
+    #
+    def type_alias_name?: (TypeName) -> bool
 
-    def resolve_type_params: (TypeNameResolver resolver, Array[AST::TypeParam], context: Array[Namespace]) ->  Array[AST::TypeParam]
+    # Returns true if a module or class with the type name is defined
+    #
+    def module_name?: (TypeName) -> bool
 
-    def absolute_type: (TypeNameResolver, Types::t, context: Array[Namespace]) -> Types::t
+    # Returns true if the type name is defined
+    #
+    def type_name?: (TypeName) -> bool
 
-    def absolute_type_name: (TypeNameResolver, TypeName, context: Array[Namespace]) -> TypeName
+    # Returns if a constant of the name is defined
+    #
+    def constant_name?: (TypeName) -> bool
 
-    def inspect: () -> String
+    # Returns true if the type name is defined by constant declaration
+    #
+    def constant_decl?: (TypeName) -> bool
 
-    @buffers: Array[Buffer]
+    # Returns true if the type name is defined by class declaration
+    #
+    def class_decl?: (TypeName) -> bool
 
-    def buffers: () -> Array[Buffer]
+    # Returns true if the type name is defined by module declaration
+    #
+    def module_decl?: (TypeName) -> bool
 
-    def buffers_decls: () -> Hash[Buffer, Array[AST::Declarations::t]]
+    # Returns true if the type name is a module alias
+    #
+    def module_alias?: (TypeName) -> bool
+
+    # Returns true if the type name is a class alias
+    def class_alias?: (TypeName) -> bool
+
+    def class_entry: (TypeName) -> (ClassEntry | ClassAliasEntry | nil)
+
+    # Returns ClassEntry if the class definition is found, normalized in case of alias
+    #
+    def normalized_class_entry: (TypeName) -> ClassEntry?
+
+    def module_entry: (TypeName) -> (ModuleEntry | ModuleAliasEntry | nil)
+
+    # Returns ModuleEntry if the module definition is found, normalized in case of alias
+    #
+    def normalized_module_entry: (TypeName) -> ModuleEntry?
+
+    def constant_entry: (TypeName) -> (ClassEntry | ClassAliasEntry | ModuleEntry | ModuleAliasEntry | ConstantEntry | nil)
+
+    def module_class_entry: (TypeName) -> (ClassEntry | ClassAliasEntry | ModuleEntry | ModuleAliasEntry | nil)
+
+    def normalized_module_class_entry: (TypeName) -> (ClassEntry | ModuleEntry | nil)
+
+    @normalize_module_name_cache: Hash[TypeName, TypeName | false | nil]
+
+    # Returns the original module name that is defined with `module` declaration
+    #
+    # * Calls `#absolute!` for relative module names
+    # * Returns `nil` if the rhs name cannot be found
+    # * Returns `false` if the name is cyclic
+    #
+    def normalize_module_name?: (TypeName) -> (TypeName | nil | false)
+
+    # Returns the original module name that is defined with `module` declaration
+    #
+    # * Raises an error if given type name is not module
+    # * Calls `#absolute!` for relative module names
+    # * Returns the name itself if the name cannot be normalized to a class/module
+    #
+    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
+    #
+    def normalize_type_name?: (TypeName) -> (TypeName | nil | false)
+
+    # Normalize the type name or raises an error
+    #
+    def normalize_type_name!: (TypeName) -> TypeName
+
+    # Returns a normalized module/class name or a type name with a normalized namespace
+    #
+    # * Calls `#absolute!` for relative module names
+    # * Returns the typename itself if the name cannot be normalized
+    #
+    def normalize_type_name: (TypeName) -> TypeName
+
+    # Returns `true` if given type name is normalized
+    #
+    def normalized_type_name?: (TypeName) -> bool
+
+    # Returns the given type name if it's normalized, or raises
+    #
+    def normalized_type_name!: (TypeName) -> TypeName
 
-    # Construct new environment without declarations tested `true` by block.
-    # Construction of new environment is done with `<<` so that nested declarations will work well.
+    # Runs generics type params validation over each class definitions
+    def validate_type_params: () -> void
+
+    private
+
+    # Returns a context for inside given decls
     #
-    def reject: () { (AST::Declarations::t) -> boolish } -> Environment
+    def resolver_context: (*module_decl) -> Resolver::context
+
+    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_member: (Resolver::TypeNameResolver, UseMap map, AST::Members::t, context: Resolver::context) -> AST::Members::t
+
+    def resolve_method_type: (Resolver::TypeNameResolver, UseMap map, RBS::MethodType, context: Resolver::context) -> RBS::MethodType
+
+    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 absolute_type_name: (Resolver::TypeNameResolver, UseMap map, TypeName, context: Resolver::context) -> TypeName
   end
 end

data/sig/environment_loader.rbs

@@ -3,23 +3,25 @@ module RBS
   #
   # Set up your configuration through repository and `#add` method.
   #
-  #   # Set up the repository to load library RBSs from.
-  #   repo = RBS::Repository.default
-  #   repo.add(Pathname("vendor/rbs/gem-rbs"))
-  #   repo.add(Pathname("vendor/rbs/internal-rbs"))
+  # ```ruby
+  # # Set up the repository to load library RBSs from.
+  # repo = RBS::Repository.default
+  # repo.add(Pathname("vendor/rbs/gem-rbs"))
+  # repo.add(Pathname("vendor/rbs/internal-rbs"))
   #
-  #   loader = RBS::EnvironmentLoader.new(repository: repo)
+  # loader = RBS::EnvironmentLoader.new(repository: repo)
   #
-  #   # Add libraries to load RBS files.
-  #   loader.add(library: "minitest")
-  #   loader.add(library: "rbs", version: "1.0.0")
+  # # Add libraries to load RBS files.
+  # loader.add(library: "minitest")
+  # loader.add(library: "rbs", version: "1.0.0")
   #
-  #   # Add dirs to load RBS files from.
-  #   loader.add(path: Pathname("sig"))
+  # # Add dirs to load RBS files from.
+  # loader.add(path: Pathname("sig"))
   #
-  #   # Load RBSs into an environment.
-  #   environment = RBS::Environment.new()
-  #   loader.load(env: environment)
+  # # Load RBSs into an environment.
+  # environment = RBS::Environment.new()
+  # loader.load(env: environment)
+  # ```
   #
   class EnvironmentLoader
     class UnknownLibraryError < StandardError
@@ -28,13 +30,15 @@ module RBS
       def initialize: (lib: Library) -> void
     end
 
-    class Library < Struct[String | String?]
+    class Library
       attr_reader name: String
       attr_reader version: String?
 
       def initialize: (name: String, version: String?) -> void
     end
 
+    include FileFinder
+
     DEFAULT_CORE_ROOT: Pathname
 
     attr_reader core_root: Pathname?
@@ -81,7 +85,7 @@ module RBS
     def resolve_dependencies: (library: String, version: String?) -> void
 
     # Add repository path and libraries via rbs_collection.lock.yaml.
-    def add_collection: (Collection::Config collection_config) -> void
+    def add_collection: (Collection::Config::Lockfile lockfile) -> void
 
     # This is helper function to test if RBS for a library is available or not.
     #
@@ -100,10 +104,8 @@ module RBS
     #
     def self.gem_sig_path: (String name, String? version) -> [Gem::Specification, Pathname]?
 
-    def each_decl: () { (AST::Declarations::t, Buffer, source, Pathname) -> void } -> void
+    def each_signature: () { (source, Pathname, Buffer, Array[AST::Declarations::t], Array[AST::Directives::t]) -> void } -> void
 
     def each_dir: { (source, Pathname) -> void } -> void
-
-    def each_file: (Pathname path, immediate: boolish, skip_hidden: boolish) { (Pathname) -> void } -> void
   end
 end

data/sig/errors.rbs

@@ -16,9 +16,19 @@ module RBS
   class BaseError < StandardError
   end
 
+  interface _Location
+    %a{pure} def location: () -> Location[untyped, untyped]?
+  end
+
+  module DetailedMessageable : _Location, Exception
+    def detailed_message: (?highlight: boolish, **untyped) -> String
+  end
+
   # Error class for errors raised during parsing.
   #
   class ParsingError < BaseError
+    include DetailedMessageable
+
     attr_reader location: Location[untyped, untyped]
     attr_reader error_message: String
     attr_reader token_type: String
@@ -50,11 +60,14 @@ module RBS
     attr_reader type_name: TypeName
     attr_reader args: Array[Types::t]
     attr_reader params: Array[Symbol]
+    attr_reader type_params: Array[AST::TypeParam]
     attr_reader location: Location[untyped, untyped]?
 
-    def initialize: (type_name: TypeName, args: Array[Types::t], params: Array[Symbol], location: Location[untyped, untyped]?) -> void
+    def initialize: (type_name: TypeName, args: Array[Types::t], params: Array[AST::TypeParam], location: Location[untyped, untyped]?) -> void
+
+    def self.check!: (type_name: TypeName, args: Array[Types::t], params: Array[AST::TypeParam], location: Location[untyped, untyped]?) -> void
 
-    def self.check!: (type_name: TypeName, args: Array[Types::t], params: Array[Symbol], location: Location[untyped, untyped]?) -> void
+    def self.check2!: (env: Environment, type_name: TypeName, args: Array[Types::t], location: Location[untyped, untyped]?) -> void
   end
 
   class RecursiveAncestorError < DefinitionError
@@ -67,6 +80,8 @@ module RBS
   end
 
   class NoTypeFoundError < DefinitionError
+    include DetailedMessageable
+
     attr_reader type_name: TypeName
     attr_reader location: Location[untyped, untyped]?
 
@@ -85,15 +100,21 @@ module RBS
   end
 
   class NoSelfTypeFoundError < DefinitionError
+    include DetailedMessageable
+
     attr_reader type_name: TypeName
     attr_reader location: Location[untyped, untyped]?
 
     def initialize: (type_name: TypeName, location: Location[untyped, untyped]?) -> void
 
+    # The type name in `self` is automatically normalized
+    #
     def self.check!: (AST::Declarations::Module::Self, env: Environment) -> void
   end
 
   class NoMixinFoundError < DefinitionError
+    include DetailedMessageable
+
     attr_reader type_name: TypeName
     attr_reader member: AST::Members::t
 
@@ -105,6 +126,8 @@ module RBS
   end
 
   class DuplicatedMethodDefinitionError < DefinitionError
+    include DetailedMessageable
+
     type ty = Types::ClassSingleton | Types::ClassInstance | Types::Interface
     type original = DefinitionBuilder::MethodBuilder::Methods::Definition::original
 
@@ -123,7 +146,26 @@ module RBS
     def other_locations: () -> Array[Location[untyped, untyped]?]
   end
 
+  # An interface mixin causes a duplication of a method definition
+  #
+  # ```rbs
+  # interface _Foo1
+  #   def foo: () -> void
+  # end
+  #
+  # interface _Foo2
+  #   def foo: () -> void
+  # end
+  #
+  # class Foo
+  #   include _Foo1
+  #   include _Foo2    # <= The error will be reported here (or the line of _Foo1)
+  # end
+  # ```
+  #
   class DuplicatedInterfaceMethodDefinitionError < DefinitionError
+    include DetailedMessageable
+
     type ty = Types::ClassSingleton | Types::ClassInstance | Types::Interface
     type mixin_member = AST::Members::Include | AST::Members::Extend
 
@@ -136,9 +178,15 @@ module RBS
     def type_name: () -> TypeName
 
     def qualified_method_name: () -> String
+
+    def location: () -> AST::Members::Mixin::loc?
   end
 
+  # The `alias` member declares an alias from unknown method
+  #
   class UnknownMethodAliasError < DefinitionError
+    include DetailedMessageable
+
     attr_reader type_name: TypeName
     attr_reader original_name: Symbol
     attr_reader aliased_name: Symbol
@@ -154,13 +202,19 @@ module RBS
     def initialize: (name: TypeName, entry: Environment::ClassEntry) -> void
   end
 
+  # The *overloading* method definition cannot find *non-overloading* method definition
+  #
   class InvalidOverloadMethodError < DefinitionError
+    include DetailedMessageable
+
     attr_reader type_name: TypeName
     attr_reader method_name: Symbol
     attr_reader kind: :instance | :singleton
     attr_reader members: Array[AST::Members::MethodDefinition]
 
     def initialize: (type_name: TypeName, method_name: Symbol, kind: :instance | :singleton, members: Array[AST::Members::MethodDefinition]) -> void
+
+    def location: () -> AST::Members::MethodDefinition::loc?
   end
 
   class GenericParameterMismatchError < LoadingError
@@ -178,6 +232,8 @@ module RBS
   end
 
   class InvalidVarianceAnnotationError < DefinitionError
+    include DetailedMessageable
+
     attr_reader type_name: TypeName
     attr_reader param: AST::TypeParam
     attr_reader location: Location[untyped, untyped]?
@@ -186,6 +242,8 @@ module RBS
   end
 
   class RecursiveAliasDefinitionError < DefinitionError
+    include DetailedMessageable
+
     type ty = Types::ClassInstance | Types::ClassSingleton | Types::Interface
     type defn = DefinitionBuilder::MethodBuilder::Methods::Definition
 
@@ -200,6 +258,8 @@ module RBS
   # MixinClassError is raised if a include/prepend/extend has a class (not a module) to mix-in
   #
   class MixinClassError < DefinitionError
+    include DetailedMessageable
+
     type member = AST::Members::Include | AST::Members::Prepend | AST::Members::Extend
 
     attr_reader type_name: TypeName
@@ -217,16 +277,24 @@ module RBS
   # InheritModuleError is raised if a class definition inherits a module (not a class)
   #
   class InheritModuleError < DefinitionError
+    include DetailedMessageable
+
     attr_reader super_decl: AST::Declarations::Class::Super
 
     def initialize: (AST::Declarations::Class::Super) -> void
 
     def location: () -> Location[untyped, untyped]?
 
+    # Confirms if `super` inherits specifies a class
+    #
+    # Automatically normalize the name of super.
+    #
     def self.check!: (AST::Declarations::Class::Super, env: Environment) -> void
   end
 
   class RecursiveTypeAliasError < BaseError
+    include DetailedMessageable
+
     attr_reader alias_names: Array[TypeName]
     attr_reader location: Location[untyped, untyped]?
 
@@ -236,6 +304,8 @@ module RBS
   end
 
   class NonregularTypeAliasError < BaseError
+    include DetailedMessageable
+
     # Diagnostic reported from `TypeAliasRegularity`.
     attr_reader diagnostic: TypeAliasRegularity::Diagnostic
 
@@ -246,6 +316,8 @@ module RBS
   end
 
   class CyclicTypeParameterBound < BaseError
+    include DetailedMessageable
+
     attr_reader location: Location[untyped, untyped]?
 
     # Array of parameters which contains cyclic dependencies.
@@ -259,4 +331,53 @@ module RBS
 
     def initialize: (type_name: TypeName, method_name: Symbol?, params: Array[AST::TypeParam], location: Location[untyped, untyped]?) -> void
   end
+
+  # A module/class alias declaration has inconsistent right-hand-side
+  #
+  # ```rbs
+  # module Foo = Object     # Error
+  # class Bar = Kernel      # Error
+  # ```
+  #
+  class InconsistentClassModuleAliasError < BaseError
+    include DetailedMessageable
+
+    attr_reader alias_entry: Environment::ModuleAliasEntry | Environment::ClassAliasEntry
+
+    def initialize: (Environment::ModuleAliasEntry | Environment::ClassAliasEntry) -> void
+
+    def location: () -> AST::Declarations::AliasDecl::loc?
+  end
+
+  # A module/class alias declaration is cyclic
+  #
+  class CyclicClassAliasDefinitionError < BaseError
+    include DetailedMessageable
+
+    attr_reader alias_entry: Environment::ModuleAliasEntry | Environment::ClassAliasEntry
+
+    def initialize: (Environment::ModuleAliasEntry | Environment::ClassAliasEntry) -> void
+
+    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
+
+    attr_reader type_param: AST::TypeParam
+
+    def initialize: (AST::TypeParam, location: Location[untyped, untyped]?) -> void
+
+    attr_reader location: Location[untyped, untyped]?
+
+    def self.check!: (Array[AST::TypeParam]) -> void
+  end
 end

data/sig/file_finder.rbs

@@ -0,0 +1,28 @@
+module RBS
+  module FileFinder
+    # Enumerate RBS files under path
+    #
+    # When `path` is a file, it yields the path.
+    #
+    # ```rb
+    # FileFinder.each_file(Pathname("foo.rbs")) {} # => yields `foo.rbs`
+    # ```
+    #
+    # When `path` is a directory, it yields all `.rbs` files under the directory, recursively.
+    #
+    # * Skips files under directory starting with `_`, if `skip_hidden` is `true`
+    # * Yields files under directory starting with `_` even if `skip_hidden` is true, when the `_` directory is given explicitly, and `immediate:` is `true`
+    #
+    # ```rb
+    # FileFinder.each_file(Pathname("sig"), skip_hidden: false) {} # => yields all `.rbs` files under `sig`
+    # FileFinder.each_file(Pathname("sig"), skip_hidden: true) {} # => yields all `.rbs` files under `sig`, skips `_` directories
+    #
+    # FileFinder.each_file(Pathname("_hidden"), skip_hidden: true) {}  # => yields all `.rbs` files under `_hidden`, skips other `_` directories
+    # ```
+    #
+    # `immediate` keyword is unused and left for API compatibility.
+    # 
+    def self?.each_file: (Pathname path, ?immediate: top, skip_hidden: boolish) { (Pathname) -> void } -> void
+                        | (Pathname path, ?immediate: top, skip_hidden: boolish) -> Enumerator[Pathname, void]
+  end
+end

data/sig/location.rbs

@@ -99,9 +99,6 @@ module RBS
 
     private
 
-    def _start_loc: () -> Buffer::loc?
-    def _end_loc: () -> Buffer::loc?
-
     def _add_required_child: (RequiredChildKeys name, Integer start_pos, Integer end_pos) -> void
     def _add_optional_child: (OptionalChildKeys name, Integer start_pos, Integer end_pos) -> void
     def _add_optional_no_child: (OptionalChildKeys name) -> void

data/sig/locator.rbs

@@ -10,14 +10,22 @@ module RBS
                    | AST::TypeParam
                    | AST::Declarations::Class::Super
                    | AST::Declarations::Module::Self
+                   | AST::Directives::t
+                   | AST::Directives::Use::clause
+
+    # The buffer the location points to
+    #
+    attr_reader buffer: Buffer
 
     # Array of _top-level_ declarations.
     #
     attr_reader decls: Array[AST::Declarations::t]
 
-    def initialize: (decls: Array[AST::Declarations::t]) -> void
+    # Array of directives.
+    #
+    attr_reader dirs: Array[AST::Directives::t]
 
-    def buffer: () -> Buffer
+    def initialize: (buffer: Buffer, decls: Array[AST::Declarations::t], dirs: Array[AST::Directives::t]) -> void
 
     # Returns list of components.
     # Inner component comes first.
@@ -29,6 +37,10 @@ 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
 
     def find_in_member: (Integer pos, member: AST::Members::t, array: Array[component]) -> bool

data/sig/manifest.yaml

@@ -1,6 +1,5 @@
 dependencies:
   - name: logger
-  - name: set
   - name: pathname
   - name: json
   - name: optparse