pigeonhole-db 1.1.0

data/vendor/bundle/ruby/3.4.0/gems/rbs-4.2.0/sig/errors.rbs

@@ -0,0 +1,408 @@
+module RBS
+  interface _MethodName
+    def kind: () -> (:instance | :singleton)
+
+    def type_name: () -> TypeName
+
+    def method_name: () -> Symbol
+  end
+
+  module MethodNameHelper : _MethodName
+    def method_name_string: () -> String
+  end
+
+  # Error class for errors defined in 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
+
+    def initialize: (Location[untyped, untyped], String error_message, String token_type) -> void
+
+    def error_value: () -> String
+
+    def token_str: () -> String
+  end
+
+  class Parser
+    SemanticsError: singleton(ParsingError)
+    SyntaxError: singleton(ParsingError)
+    LexerError: singleton(ParsingError)
+  end
+
+  # Error class for errors raised during loading environments.
+  #
+  class LoadingError < BaseError
+  end
+
+  # Error class for errors raised during building definitions.
+  #
+  class DefinitionError < BaseError
+  end
+
+  class InvalidTypeApplicationError < DefinitionError
+    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[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.check2!: (env: Environment, type_name: TypeName, args: Array[Types::t], location: Location[untyped, untyped]?) -> void
+  end
+
+  class RecursiveAncestorError < DefinitionError
+    attr_reader ancestors: Array[Definition::Ancestor::t]
+    attr_reader location: Location[untyped, untyped]?
+
+    def initialize: (ancestors: Array[Definition::Ancestor::t], location: Location[untyped, untyped]?) -> void
+
+    def self.check!: (Definition::Ancestor::t, ancestors: Array[Definition::Ancestor::t], location: Location[untyped, untyped]?) -> void
+  end
+
+  class NoTypeFoundError < DefinitionError
+    include DetailedMessageable
+
+    attr_reader type_name: TypeName
+    attr_reader location: Location[untyped, untyped]?
+
+    def initialize: (type_name: TypeName, location: Location[untyped, untyped]?) -> void
+
+    def self.check!: (TypeName, env: Environment, location: Location[untyped, untyped]?) -> TypeName
+  end
+
+  class NoSuperclassFoundError < DefinitionError
+    attr_reader type_name: TypeName
+    attr_reader location: Location[untyped, untyped]?
+
+    def initialize: (type_name: TypeName, location: Location[untyped, untyped]?) -> void
+
+    def self.check!: (TypeName, env: Environment, location: Location[untyped, untyped]?) -> void
+  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
+
+    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: member
+
+    def initialize: (type_name: TypeName, member: member) -> void
+
+    def location: () -> Location[untyped, untyped]?
+
+    def self.check!: (TypeName, env: Environment, member: member) -> void
+  end
+
+  class DuplicatedMethodDefinitionError < DefinitionError
+    include DetailedMessageable
+
+    type ty = Types::ClassSingleton | Types::ClassInstance | Types::Interface
+    type original = DefinitionBuilder::MethodBuilder::Methods::Definition::original
+
+    attr_reader type: ty
+    attr_reader method_name: Symbol
+    attr_reader members: Array[original]
+
+    def initialize: (type: ty, method_name: Symbol, members: Array[original]) -> void
+
+    def type_name: () -> TypeName
+
+    def qualified_method_name: () -> String
+
+    def location: () -> Location[untyped, untyped]?
+
+    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
+
+    attr_reader type: ty
+    attr_reader method_name: Symbol
+    attr_reader member: mixin_member
+
+    def initialize: (type: ty, method_name: Symbol, member: mixin_member) -> void
+
+    def type_name: () -> TypeName
+
+    def qualified_method_name: () -> String
+
+    def location: () -> AST::Members::Mixin::loc?
+  end
+
+  class VariableDuplicationError < DefinitionError
+    include DetailedMessageable
+
+    attr_reader type_name: TypeName
+    attr_reader variable_name: Symbol
+    attr_reader location: Location[untyped, untyped]?
+
+    def initialize: (type_name: TypeName, variable_name: Symbol, location: Location[untyped, untyped]?) -> void
+    def kind: () -> String
+  end
+
+  class InstanceVariableDuplicationError < VariableDuplicationError
+    def kind: () -> String
+  end
+
+  class ClassInstanceVariableDuplicationError < VariableDuplicationError
+    def kind: () -> String
+  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
+    attr_reader location: Location[untyped, untyped]?
+
+    def initialize: (type_name: TypeName, original_name: Symbol, aliased_name: Symbol, location: Location[untyped, untyped]?) -> void
+  end
+
+  class SuperclassMismatchError < DefinitionError
+    attr_reader name: TypeName
+    attr_reader entry: Environment::ClassEntry
+
+    def initialize: (name: TypeName, entry: Environment::ClassEntry) -> void
+  end
+
+  # The *overloading* method definition cannot find *non-overloading* method definition
+  #
+  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[member]
+
+    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: decl
+
+    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[declaration]
+
+    def initialize: (TypeName | Symbol, *declaration) -> void
+  end
+
+  class InvalidVarianceAnnotationError < DefinitionError
+    include DetailedMessageable
+
+    attr_reader type_name: TypeName
+    attr_reader param: AST::TypeParam
+    attr_reader location: Location[untyped, untyped]?
+
+    def initialize: (type_name: TypeName, param: AST::TypeParam, location: Location[untyped, untyped]?) -> void
+  end
+
+  class RecursiveAliasDefinitionError < DefinitionError
+    include DetailedMessageable
+
+    type ty = Types::ClassInstance | Types::ClassSingleton | Types::Interface
+    type defn = DefinitionBuilder::MethodBuilder::Methods::Definition
+
+    attr_reader type: ty
+    attr_reader defs: Array[defn]
+
+    def initialize: (type: ty, defs: Array[defn]) -> void
+
+    def location: () -> Location[untyped, untyped]?
+  end
+
+  # 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
+                | AST::Ruby::Members::IncludeMember | AST::Ruby::Members::PrependMember | AST::Ruby::Members::ExtendMember
+
+    attr_reader type_name: TypeName
+    attr_reader member: member
+
+    def initialize: (type_name: TypeName, member: member) -> void
+
+    def location: () -> Location[untyped, untyped]?
+
+    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: super_class
+
+    def initialize: (super_class) -> void
+
+    def location: () -> Location[untyped, untyped]?
+
+    # Confirms if `super` inherits specifies a class
+    #
+    # Automatically normalize the name of super.
+    #
+    def self.check!: (super_class, env: Environment) -> void
+  end
+
+  class RecursiveTypeAliasError < BaseError
+    include DetailedMessageable
+
+    attr_reader alias_names: Array[TypeName]
+    attr_reader location: Location[untyped, untyped]?
+
+    def initialize: (alias_names: Array[TypeName], location: Location[untyped, untyped]?) -> void
+
+    def name: () -> String
+  end
+
+  class NonregularTypeAliasError < BaseError
+    include DetailedMessageable
+
+    # Diagnostic reported from `TypeAliasRegularity`.
+    attr_reader diagnostic: TypeAliasRegularity::Diagnostic
+
+    # Location of the definition.
+    attr_reader location: Location[untyped, untyped]?
+
+    def initialize: (diagnostic: TypeAliasRegularity::Diagnostic, location: Location[untyped, untyped]?) -> void
+  end
+
+  class CyclicTypeParameterBound < BaseError
+    include DetailedMessageable
+
+    attr_reader location: Location[untyped, untyped]?
+
+    # Array of parameters which contains cyclic dependencies.
+    attr_reader params: Array[AST::TypeParam]
+
+    # Type name
+    attr_reader type_name: TypeName
+
+    # Method name
+    attr_reader method_name: Symbol?
+
+    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 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/vendor/bundle/ruby/3.4.0/gems/rbs-4.2.0/sig/factory.rbs

@@ -0,0 +1,5 @@
+module RBS
+  class Factory
+    def type_name: (String) -> TypeName
+  end
+end

data/vendor/bundle/ruby/3.4.0/gems/rbs-4.2.0/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/vendor/bundle/ruby/3.4.0/gems/rbs-4.2.0/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/vendor/bundle/ruby/3.4.0/gems/rbs-4.2.0/sig/inline_parser.rbs

@@ -0,0 +1,126 @@
+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
+
+      def visit_class_or_module_body: (module_context, Prism::ClassNode | Prism::ModuleNode) -> 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