rbs-relaxed 3.9.0.1

data/sig/ancestor_builder.rbs

@@ -0,0 +1,163 @@
+module RBS
+  class DefinitionBuilder
+    # AncestorBuilder calculates the ancestors of a class or module.
+    #
+    class AncestorBuilder
+      # OneAncestors represents a list of _direct_ ancestors of a type name
+      #
+      # _Direct_ ancestors is defined as follows:
+      #
+      # * Super class is a direct ancestor
+      # * Self type constraints are direct ancestors
+      # * Mixin modules are direct ancestors
+      # * Mixin interfaces are direct ancestors
+      #
+      # The optional attributes are defined by the type of the ancestors object, one of the following five groups:
+      #
+      # 1. Instance of a class -- with super_class, included_modules, included_interfaces, and prepended_modules
+      # 2. Instance of a module -- with self_types, included_modules, included_interfaces, and prepended_modules
+      # 3. Singleton of a class or module -- with super_class, extended_modules, and extended_interfaces
+      # 4. Interface -- with included_interfaces
+      #
+      class OneAncestors
+        attr_reader type_name: TypeName
+        attr_reader params: Array[Symbol]?
+
+        # Returns super_class ancestor if specified
+        #
+        # * Always `nil` if this is not a class.
+        #
+        attr_reader super_class: Definition::Ancestor::t?
+
+        # Returns list of _self type constraints_ of a module
+        #
+        # * Returns `nil` if it is not a module instance.
+        #
+        attr_reader self_types: Array[Definition::Ancestor::Instance]?
+
+        # Returns the list of included modules
+        #
+        # * Returns `nil` if it is an interface or it is a singleton.
+        #
+        attr_reader included_modules: Array[Definition::Ancestor::Instance]?
+
+        # Returns the list of included interfaces
+        #
+        # * Returns `nil` it it is a singleton.
+        #
+        attr_reader included_interfaces: Array[Definition::Ancestor::Instance]?
+
+        # Returns the list of prepended modules
+        #
+        # * Returns `nil` if it is an interface or it is a singleton.
+        #
+        attr_reader prepended_modules: Array[Definition::Ancestor::Instance]?
+
+        # Returns the list of extended modules
+        #
+        # * Returns `nil` if it is an interface or it is an instance.
+        #
+        attr_reader extended_modules: Array[Definition::Ancestor::Instance]?
+
+        # Returns the list of extended interfaces
+        #
+        # * Returns `nil` if it is an interface or it is an instance.
+        #
+        attr_reader extended_interfaces: Array[Definition::Ancestor::Instance]?
+
+        def initialize: (type_name: TypeName,
+                            params: Array[Symbol]?,
+                       super_class: Definition::Ancestor::t?,
+                        self_types: Array[Definition::Ancestor::Instance]?,
+                  included_modules: Array[Definition::Ancestor::Instance]?,
+               included_interfaces: Array[Definition::Ancestor::Instance]?,
+                 prepended_modules: Array[Definition::Ancestor::Instance]?,
+                  extended_modules: Array[Definition::Ancestor::Instance]?,
+               extended_interfaces: Array[Definition::Ancestor::Instance]?) -> void
+
+        def each_ancestor: { (Definition::Ancestor::t) -> void } -> void
+                         | -> Enumerator[Definition::Ancestor::t, void]
+
+        # Returns a OneAncestors object for class instance
+        def self.class_instance: (type_name: TypeName, params: Array[Symbol], super_class: Definition::Ancestor::t?) -> instance
+
+        # Returns a OneAncestors object for module instance
+        def self.module_instance: (type_name: TypeName, params: Array[Symbol]) -> instance
+
+        # Returns a OneAncestors object for class/module singleton
+        def self.singleton: (type_name: TypeName, super_class: Definition::Ancestor::t) -> instance
+
+        # Returns a OneAncestors object for interface
+        def self.interface: (type_name: TypeName, params: Array[Symbol]) -> instance
+
+        def each_included_module: () { (Definition::Ancestor::Instance) -> void } -> void
+                                | () -> Enumerator[Definition::Ancestor::Instance, void]
+
+        def each_included_interface: () { (Definition::Ancestor::Instance) -> void } -> void
+                                   | () -> Enumerator[Definition::Ancestor::Instance, void]
+
+        def each_prepended_module: () { (Definition::Ancestor::Instance) -> void } -> void
+                                 | () -> Enumerator[Definition::Ancestor::Instance, void]
+
+        def each_extended_module: () { (Definition::Ancestor::Instance) -> void } -> void
+                                | () -> Enumerator[Definition::Ancestor::Instance, void]
+
+        def each_extended_interface: () { (Definition::Ancestor::Instance) -> void } -> void
+                                   | () -> Enumerator[Definition::Ancestor::Instance, void]
+
+        def each_self_type: () { (Definition::Ancestor::Instance) -> void } -> void
+                          | () -> Enumerator[Definition::Ancestor::Instance, void]
+      end
+
+      attr_reader env: Environment
+
+      attr_reader one_instance_ancestors_cache: Hash[TypeName, OneAncestors]
+      attr_reader instance_ancestors_cache: Hash[TypeName, Definition::InstanceAncestors]
+
+      attr_reader one_singleton_ancestors_cache: Hash[TypeName, OneAncestors]
+      attr_reader singleton_ancestors_cache: Hash[TypeName, Definition::SingletonAncestors]
+
+      attr_reader one_interface_ancestors_cache: Hash[TypeName, OneAncestors]
+      attr_reader interface_ancestors_cache: Hash[TypeName, Definition::InstanceAncestors]
+
+      def initialize: (env: Environment) -> void
+
+      def instance_ancestors: (TypeName, ?building_ancestors: Array[Definition::Ancestor::t]) -> Definition::InstanceAncestors
+
+      def singleton_ancestors: (TypeName, ?building_ancestors: Array[Definition::Ancestor::t]) -> Definition::SingletonAncestors
+
+      def interface_ancestors: (TypeName, ?building_ancestors: Array[Definition::Ancestor::t]) -> Definition::InstanceAncestors
+
+      def one_instance_ancestors: (TypeName) -> OneAncestors
+
+      def one_singleton_ancestors: (TypeName) -> OneAncestors
+
+      def one_interface_ancestors: (TypeName) -> OneAncestors
+
+      private
+
+      def validate_super_class!: (TypeName, Environment::ClassEntry) -> void
+
+      def mixin_ancestors: (Environment::ClassEntry | Environment::ModuleEntry,
+                            TypeName,
+                            included_modules: Array[Definition::Ancestor::Instance]?,
+                         included_interfaces: Array[Definition::Ancestor::Instance]?,
+                           prepended_modules: Array[Definition::Ancestor::Instance]?,
+                            extended_modules: Array[Definition::Ancestor::Instance]?,
+                         extended_interfaces: Array[Definition::Ancestor::Instance]?) -> void
+
+      def mixin_ancestors0: (AST::Declarations::Class | AST::Declarations::Module | AST::Declarations::Interface,
+                             TypeName,
+                             align_params: Substitution?,
+                         included_modules: Array[Definition::Ancestor::Instance]?,
+                      included_interfaces: Array[Definition::Ancestor::Instance]?,
+                        prepended_modules: Array[Definition::Ancestor::Instance]?,
+                         extended_modules: Array[Definition::Ancestor::Instance]?,
+                      extended_interfaces: Array[Definition::Ancestor::Instance]?) -> void
+
+      # Fill `#source` of instance ancestor if `ancestor.name == name` and its `source` is `nil`
+      #
+      def fill_ancestor_source: (Definition::Ancestor::t, name: TypeName, source: Definition::Ancestor::Instance::source)  -> Definition::Ancestor::t
+    end
+  end
+end

data/sig/ancestor_graph.rbs

@@ -0,0 +1,60 @@
+module RBS
+  # AncestorGraph is a utility class that helps iterating through ancestors and descendants of a class/module
+  #
+  # ```ruby
+  # graph = AncestorGraph.new(env: env, ancestor_builder: ancestor_builder)
+  #
+  # graph.each_parent(AncestorGraph::InstanceNode.new(type_name: TypeName.parse("::Object")))
+  # graph.each_ancestor(AncestorGraph::InstanceNode.new(type_name: TypeName.parse("::Object")))
+  #
+  # graph.each_child(AncestorGraph::InstanceNode.new(type_name: TypeName.parse("::Object")))
+  # graph.each_descendant(AncestorGraph::InstanceNode.new(type_name: TypeName.parse("::Object")))
+  # ```
+  #
+  # Note that the class works for class/module declarations.
+  # All of the *alias* classes/modules are ignored.
+  #
+  # * Alias classes/modules doesn't count as a parent nor child
+  # * Passing alias classes/modules to the method doesn't yield anything
+  #
+  class AncestorGraph
+    class InstanceNode
+      attr_reader type_name: TypeName
+      def initialize: (type_name: TypeName) -> void
+    end
+
+    class SingletonNode
+      attr_reader type_name: TypeName
+      def initialize: (type_name: TypeName) -> void
+    end
+
+    type node = InstanceNode | SingletonNode
+
+    attr_reader env: Environment
+    attr_reader ancestor_builder: DefinitionBuilder::AncestorBuilder
+    attr_reader parents: Hash[node, Set[node]]
+    attr_reader children: Hash[node, Set[node]]
+
+    def initialize: (env: Environment, ?ancestor_builder: DefinitionBuilder::AncestorBuilder) -> void
+
+    def each_parent: (node) { (node) -> void } -> void
+                   | (node) -> Enumerator[node, void]
+
+    def each_ancestor: (node, ?yielded: Set[node]) { (node) -> void } -> void
+                     | (node) -> Enumerator[node, void]
+
+    def each_child: (node) { (node) -> void } -> void
+                  | (node) -> Enumerator[node, void]
+
+    def each_descendant: (node, ?yielded: Set[node]) { (node) -> void } -> void
+                       | (node) -> Enumerator[node, void]
+
+    private
+
+    def build: () -> void
+
+    def build_ancestors: (node, DefinitionBuilder::AncestorBuilder::OneAncestors) -> void
+
+    def register: (parent: node, child: node) -> void
+  end
+end

data/sig/annotate/annotations.rbs

@@ -0,0 +1,102 @@
+module RBS
+  module Annotate
+    class Annotations
+      type t = Skip | Source | Copy
+
+      def self.parse: (AST::Annotation) -> t?
+
+      attr_reader items: Array[t]
+
+      def initialize: (Array[t]) -> void
+
+      def skip?: () -> bool
+
+      def skip_all?: () -> bool
+
+      def test_path: (String path) -> bool
+
+      def test_path_string: (String pattern, String path) -> bool
+
+      def copy_annotation: -> Copy?
+
+      # Skip annotation allows skipping generating annotation of a subject.
+      #
+      #     %a{annotate:rdoc:skip}
+      #     %a{annotate:rdoc:skip:all}
+      #
+      class Skip
+        attr_reader annotation: AST::Annotation
+
+        attr_reader skip_children: bool
+
+        def initialize: (annotation: AST::Annotation, skip_children: bool) -> void
+
+        def hash: () -> Integer
+
+        def ==: (untyped) -> bool
+
+        alias eql? ==
+      end
+
+      # Source annotation allows where the documents are copied from.
+      #
+      # It allows specifying two directions: the source to read from, and the source to skip.
+      #
+      #     %a{annotate:rdoc:source:from=ext/pathname}
+      #     %a{annotate:rdoc:source:skip=ext/pathname/doc}
+      #
+      # When you want to specify several paths, repeat writing the Source annotation.
+      #
+      class Source
+        attr_reader annotation: AST::Annotation
+
+        attr_reader include_source: String?
+        attr_reader skip_source: String?
+
+        def initialize: (annotation: AST::Annotation, include: String) -> void
+                      | (annotation: AST::Annotation, skip: String) -> void
+
+        def hash: () -> Integer
+
+        def ==: (untyped) -> bool
+
+        alias eql? ==
+      end
+
+      # Copy annotation allows copying the doc from another subject.
+      # This helps working with incorrect RDoc annotations.
+      #
+      #     %a{annotate:rdoc:copy:Bar#baz}
+      #     %a{annotate:rdoc:copy:Bar.baz}
+      #     %a{annotate:rdoc:copy:Bar::Baz}
+      #
+      class Copy
+        attr_reader annotation: AST::Annotation
+
+        attr_reader source: String
+
+        def initialize: (annotation: AST::Annotation, source: String) -> void
+
+        # Returns a tuple of:
+        #
+        # - Type name
+        # - A pair of:
+        #   - Boolean which holds if it is singleton
+        #   - Name of method
+        def partition: () -> [TypeName, [bool, Symbol]?]
+
+        def type_name: () -> TypeName
+
+        def method_name: () -> Symbol?
+
+        def singleton?: () -> bool
+
+        def hash: () -> Integer
+
+        def ==: (untyped) -> bool
+
+        alias eql? ==
+      end
+    end
+  end
+end

data/sig/annotate/formatter.rbs

@@ -0,0 +1,24 @@
+module RBS
+  module Annotate
+    class Formatter
+      attr_reader buffer: String
+
+      @pending_separator: String?
+
+      def initialize: () -> void
+
+      def <<: (String | RDoc::Markup::Document | nil) -> self
+
+      def margin: (?separator: String) -> self
+
+      def empty?: () -> bool
+
+      def format: (newline_at_end: bool) -> String
+
+      def self.translate: (RDoc::Markup::Document) -> String?
+
+      def self.each_part: (RDoc::Markup::Document | RDoc::Comment | String) { (RDoc::Markup::Document) -> void } -> void
+                        | (RDoc::Markup::Document | RDoc::Comment | String) -> Enumerator[RDoc::Markup::Document, void]
+    end
+  end
+end

data/sig/annotate/rdoc_annotater.rbs

@@ -0,0 +1,82 @@
+module RBS
+  module Annotate
+    class RDocAnnotator
+      attr_reader source: RDocSource
+
+      attr_accessor include_arg_lists: bool
+      attr_accessor include_filename: bool
+
+      def initialize: (source: RDocSource) -> void
+
+      def annotate_file: (Pathname, preserve: bool) -> void
+
+      def annotate_decls: (Array[AST::Declarations::t], ?outer: Array[Namespace]) -> void
+
+      interface _PathTester
+        def test_path: (String) -> bool
+      end
+
+      interface _WithRDocComment
+        def comment: () -> (RDoc::Markup::Document | RDoc::Comment | String)
+      end
+
+      def each_part: (Array[Object & _WithRDocComment], tester: _PathTester) { ([RDoc::Markup::Document, Object & _WithRDocComment]) -> void } -> void
+                   | (Array[Object & _WithRDocComment], tester: _PathTester) -> Enumerator[[RDoc::Markup::Document, Object & _WithRDocComment], void]
+
+      def join_docs: (Array[String?], ?separator: String) -> String?
+
+      def doc_for_class: (TypeName, tester: _PathTester) -> String?
+
+      # Returns the formatted document of given method.
+      #
+      # Expands attribute documents, or alias documents if needed.
+      #
+      def doc_for_method: (TypeName, instance_method: Symbol, tester: _PathTester) -> String?
+                        | (TypeName, singleton_method: Symbol, tester: _PathTester) -> String?
+
+
+      def doc_for_method0: (TypeName, instance_method: Symbol, tester: _PathTester) -> String?
+                         | (TypeName, singleton_method: Symbol, tester: _PathTester) -> String?
+
+      # Having `require: nil` means any attribute is okay.
+      # Having `require: "R"` means _read attr_ is required.
+      # Having `require: "W"` means write attr_ is required.
+      #
+      def doc_for_attribute: (TypeName, Symbol, singleton: bool, ?require: nil | "R" | "W", tester: _PathTester) -> String?
+
+      def doc_for_alias: (TypeName, name: Symbol, singleton: bool, tester: _PathTester) -> String?
+
+      def doc_for_constant: (TypeName, tester: _PathTester) -> String?
+
+      def resolve_doc_source: (Annotations::Copy?, tester: _PathTester) { () -> String? } -> String?
+
+      def annotate_class: (AST::Declarations::Class | AST::Declarations::Module, outer: Array[Namespace]) -> void
+
+      def annotate_constant: (AST::Declarations::Constant, outer: Array[Namespace]) -> void
+
+      def annotate_method: (TypeName, AST::Members::MethodDefinition) -> void
+
+      def annotate_alias: (TypeName, AST::Members::Alias) -> void
+
+      def annotate_attribute: (TypeName, AST::Members::AttrReader | AST::Members::AttrWriter | AST::Members::AttrAccessor) -> void
+
+      def annotations: (_Annotated) -> Annotations
+
+      interface _Annotated
+        def annotations: -> Array[AST::Annotation]
+      end
+
+      # - If a string is given as `comment`, the content is attached to the object as a comment.
+      # - If empty string is given as `comment`, it deletes the original comment.
+      # - If `nil` is given as `comment`, it keeps the original comment.
+      #
+      def replace_comment: (Object & _Commented, String? comment) -> void
+
+      interface _Commented
+        def comment: () -> AST::Comment?
+      end
+
+      def resolve_name: (TypeName, outer: Array[Namespace]) -> TypeName
+    end
+  end
+end

data/sig/annotate/rdoc_source.rbs

@@ -0,0 +1,30 @@
+module RBS
+  module Annotate
+    class RDocSource
+      attr_accessor with_system_dir: bool
+      attr_accessor with_gems_dir: bool
+      attr_accessor with_site_dir: bool
+      attr_accessor with_home_dir: bool
+
+      attr_reader extra_dirs: Array[Pathname]
+
+      attr_reader stores: Array[RDoc::Store]
+
+      def initialize: () -> void
+
+      def load: () -> void
+
+      # Extract documents from `CodeObject`s
+      def docs: () { () -> Array[RDoc::CodeObject]? } -> Array[RDoc::Markup::Document]?
+
+      def find_class: (TypeName) -> Array[RDoc::ClassModule]?
+
+      def find_const: (TypeName) -> Array[RDoc::Constant]?
+
+      def find_method: (TypeName, instance_method: Symbol) -> Array[RDoc::AnyMethod]?
+                     | (TypeName, singleton_method: Symbol) -> Array[RDoc::AnyMethod]?
+
+      def find_attribute: (TypeName, Symbol, singleton: bool) -> Array[RDoc::Attr]?
+    end
+  end
+end

data/sig/annotation.rbs

@@ -0,0 +1,27 @@
+module RBS
+  module AST
+    # RBS allows writing annotations of declarations and members.
+    #
+    # ```rbs
+    # %a{annotation_here}
+    # class Hello
+    #   %a{rbs:test:skip}
+    #   def foo: () -> void
+    # end
+    # ```
+    class Annotation
+      attr_reader string: String
+      attr_reader location: Location[untyped, untyped]?
+
+      def initialize: (string: String, location: Location[untyped, untyped]?) -> void
+
+      def ==: (untyped other) -> bool
+
+      alias eql? ==
+
+      def hash: () -> Integer
+
+      include _ToJson
+    end
+  end
+end

data/sig/buffer.rbs

@@ -0,0 +1,32 @@
+module RBS
+  class Buffer
+    # Location in a buffer.
+    # A pair of line number (1 origin) and column number (0 origin).
+    #
+    type loc = [Integer, Integer]
+
+    # Name to identify Buffer.
+    attr_reader name: untyped
+
+    # The content of the buffer.
+    attr_reader content: String
+
+    @lines: Array[String]
+
+    @ranges: Array[Range[Integer]]
+
+    def initialize: (name: untyped name, content: String content) -> void
+
+    def lines: () -> Array[String]
+
+    def ranges: () -> Array[Range[Integer]]
+
+    # Translate position to location.
+    def pos_to_loc: (Integer pos) -> loc
+
+    # Translate location to position.
+    def loc_to_pos: (loc loc) -> Integer
+
+    def last_position: () -> Integer
+  end
+end

data/sig/builtin_names.rbs

@@ -0,0 +1,44 @@
+module RBS
+  module BuiltinNames
+    class Name
+      attr_reader name: TypeName
+
+      @singleton_type: Types::t?
+
+      def initialize: (name: TypeName) -> void
+
+      def to_s: () -> String
+
+      def instance_type: (*Types::t) -> Types::ClassInstance
+
+      def instance_type?: (Types::t) -> bool
+
+      def singleton_type: () -> Types::ClassSingleton
+
+      def singleton_type?: (Types::t) -> bool
+
+      def self.define: (Symbol, ?namespace: Namespace) -> instance
+    end
+
+    BasicObject: Name
+    Object: Name
+    Kernel: Name
+    String: Name
+    Comparable: Name
+    Enumerable: Name
+    Class: Name
+    Module: Name
+    Array: Name
+    Hash: Name
+    Range: Name
+    Enumerator: Name
+    Set: Name
+    Symbol: Name
+    Integer: Name
+    Float: Name
+    Regexp: Name
+    TrueClass: Name
+    FalseClass: Name
+    Numeric: Name
+  end
+end

data/sig/cli/colored_io.rbs

@@ -0,0 +1,15 @@
+module RBS
+  class CLI
+    class ColoredIO
+      attr_reader stdout: CLI::_IO
+      def initialize: (stdout: CLI::_IO) -> void
+      def puts_green: (String) -> void
+      def puts_red: (String) -> void
+      def puts: (?String) -> void
+
+      private def can_display_colors?: () -> bool
+      private def are_colors_supported?: () -> bool
+      private def are_colors_disabled?: () -> bool
+    end
+  end
+end

data/sig/cli/diff.rbs

@@ -0,0 +1,21 @@
+module RBS
+  class CLI
+    class Diff
+      @format: String
+      @stdout: _IO
+      @stderr: _IO
+      @diff: RBS::Diff
+
+      def initialize: (
+        argv: Array[String],
+        library_options: RBS::CLI::LibraryOptions,
+        ?stdout: _IO,
+        ?stderr: _IO,
+      ) -> void
+
+      def run: () -> void
+      def run_diff: () -> void
+      def run_markdown: () -> void
+    end
+  end
+end

data/sig/cli/validate.rbs

@@ -0,0 +1,43 @@
+module RBS
+  class CLI
+    class Validate
+      class Errors
+        @limit: Integer?
+        @exit_error: boolish
+        @has_syntax_error: bool
+        @errors: Array[BaseError]
+
+        def initialize: (limit: Integer?, exit_error: boolish) -> void
+
+        def add: (BaseError) -> void
+
+        def finish: () -> void
+
+        private
+
+        def build_message: (BaseError) -> String
+      end
+
+      @env: Environment
+      @builder: RBS::DefinitionBuilder
+      @validator: RBS::Validator
+      @errors: Errors
+
+      def initialize: (args: Array[String], options: LibraryOptions) -> void
+
+      def run: () -> void
+
+      private
+
+      def validate_class_module_definition: () -> void
+      def validate_class_module_alias_definition: () -> void
+      def validate_interface: () -> void
+      def validate_constant: () -> void
+      def validate_global: () -> void
+      def validate_type_alias: () -> void
+      def no_self_type_validator: (::RBS::Types::t | ::RBS::MethodType type) -> void
+      def no_classish_type_validator: (::RBS::Types::t | ::RBS::MethodType type) -> void
+      def void_type_context_validator: (::RBS::Types::t | ::RBS::MethodType type, ?bool allowed_here) -> void
+    end
+  end
+end