rbs 2.6.0 → 2.7.0.pre.1

data/sig/location.rbs

@@ -4,10 +4,6 @@ module RBS
   #
   # A location can have _child_ locations.
   #
-  # ```
-  #
-  # ```
-  #
   class Location[in RequiredChildKeys, in OptionalChildKeys]
     # The buffer this location points on.
     attr_reader buffer (): Buffer
@@ -42,13 +38,21 @@ module RBS
 
     attr_reader start_loc (): Buffer::loc
 
+    @start_loc: Buffer::loc?
+
     attr_reader end_loc (): Buffer::loc
 
+    @end_loc: Buffer::loc?
+
     attr_reader range (): Range[Integer]
 
+    @range: Range[Integer]?
+
     # A substring of buffer associated to the location.
     def source: () -> String
 
+    @source: String?
+
     def to_s: () -> String
 
     # Returns a string representation suitable for terminal output.

data/sig/manifest.yaml

@@ -6,3 +6,4 @@ dependencies:
   - name: optparse
   - name: rubygems
   - name: tsort
+  - name: rdoc

data/sig/members.rbs

@@ -161,7 +161,7 @@ module RBS
 
         include _HashEqual
 
-        def update: (?name: Symbol, ?type: Types::t, ?ivar_name: Symbol | false | nil, ?kind: kind, ?annotations: Array[Annotation], ?location: loc?, ?comment: Comment?, ?visibility: visibility) -> instance
+        def update: (?name: Symbol, ?type: Types::t, ?ivar_name: Symbol | false | nil, ?kind: kind, ?annotations: Array[Annotation], ?location: loc?, ?comment: Comment?, ?visibility: visibility?) -> instance
       end
 
       class AttrReader < Base

data/sig/method_builder.rbs

@@ -1,9 +1,19 @@
 module RBS
   class DefinitionBuilder
+    # MethodBuilder calculates the sequence of methods available on given type
+    #
+    # The sequence are sorted topologically.
+    #
     class MethodBuilder
+      # Set of methods defined in a type.
+      #
       class Methods
         type instance_type = Types::ClassInstance | Types::ClassSingleton | Types::Interface
 
+        # Definition of a method in the type
+        #
+        # The Definition object allows invalid method definition so that more than one _original_ definitions may exist.
+        #
         class Definition
           type original = AST::Members::MethodDefinition | AST::Members::Alias | AST::Members::AttrAccessor | AST::Members::AttrWriter | AST::Members::AttrReader
 

data/sig/namespace.rbs

@@ -1,35 +1,49 @@
 module RBS
   # Namespace instance represents a _prefix of module names_.
   #
-  #    vvvvvvvvvvvvvv  TypeName
-  #    RBS::Namespace
-  #    ^^^^^           Namespace
+  # ```
+  # vvvvvvvvvvvvvv  TypeName
+  # RBS::Namespace
+  # ^^^^^           Namespace
   #
-  #    vvvvvvvvvv    TypeName
-  #    RBS::Types
-  #    ^^^^^         Namespace
+  # vvvvvvvvvv    TypeName
+  # RBS::Types
+  # ^^^^^         Namespace
   #
-  #    vvvvvvvvvvvvvvvvv    TypeName
-  #    RBS::Types::Union
-  #    ^^^^^^^^^^^^         Namespace
+  # vvvvvvvvvvvvvvvvv    TypeName
+  # RBS::Types::Union
+  # ^^^^^^^^^^^^         Namespace
+  # ```
   #
   # Note that `Namespace` is an RBS specific concept and there is no corresponding concept in Ruby.
   #
   # There are _absolute_ and _relative_ namespaces.
   #
-  #    Namespace(::RBS::)         # Absolute namespace
-  #    Namespace(  RBS::)         # Relative namespace
+  # ```
+  # Namespace(::RBS::)         # Absolute namespace
+  # Namespace(  RBS::)         # Relative namespace
+  # ```
   #
   # It also defines two special namespaces.
   #
-  #    ::              # _Root_ namespace
-  #                    # _Empty_ namespace
+  # ```
+  # ::              # _Root_ namespace
+  #                 # _Empty_ namespace
+  # ```
   #
   class Namespace
     attr_reader path: Array[Symbol]
 
     def initialize: (path: Array[Symbol], absolute: boolish) -> void
 
+    @absolute: bool
+
+    @parent: Namespace?
+
+    self.@root: Namespace?
+
+    self.@empty: Namespace?
+
     # Returns new _empty_ namespace.
     def self.empty: () -> Namespace
 
@@ -38,26 +52,33 @@ module RBS
 
     # Concat two namespaces.
     #
-    #   Namespace("Foo::") + Namespace("Bar::")   # => Foo::Bar::
-    #   Namespace("::Foo::") + Namespace("Bar::") # => ::Foo::Bar::
+    # ```rb
+    # Namespace("Foo::") + Namespace("Bar::")   # => Foo::Bar::
+    # Namespace("::Foo::") + Namespace("Bar::") # => ::Foo::Bar::
+    # ```
     #
     # If `other` is an absolute namespace, it returns `other`.
     #
-    #   Namespace("Foo::") + Namespace("::Bar::")  # =>  ::Bar::
-    #
+    # ```rb
+    # Namespace("Foo::") + Namespace("::Bar::")  # =>  ::Bar::
+    # ```
     def +: (Namespace other) -> Namespace
 
     # Add one path component to self.
     #
-    #   Namespace("Foo::").append(:Bar) # => Namespace("Foo::Bar::")
+    # ```rb
+    # Namespace("Foo::").append(:Bar) # => Namespace("Foo::Bar::")
+    # ```
     def append: (Symbol component) -> Namespace
 
     # Returns parent namespace.
     # Raises error there is no parent namespace.
     #
-    #    Namespace("::A").parent    # => Namespace("::")
-    #    Namespace("::").parent     # raises error
-    #    Namespace("A::B").parent   # => Namespace("A")
+    # ```rb
+    # Namespace("::A").parent    # => Namespace("::")
+    # Namespace("::").parent     # raises error
+    # Namespace("A::B").parent   # => Namespace("A")
+    # ```
     def parent: () -> Namespace
 
     # Returns true if self is absolute namespace.
@@ -68,9 +89,10 @@ module RBS
 
     # Returns absolute namespace.
     #
-    #    Namespace("A").absolute!      # => Namespace("::A")
-    #    Namespace("::A").absolute!    # => Namespace("::A")
-    #
+    # ```rb
+    # Namespace("A").absolute!      # => Namespace("::A")
+    # Namespace("::A").absolute!    # => Namespace("::A")
+    # ```
     def absolute!: () -> Namespace
 
     # Returns _relative_ namespace.
@@ -91,8 +113,9 @@ module RBS
 
     # Returns a pair of parent namespace and a symbol of last component.
     #
-    #    Namespace("::A::B::C").split    # => [Namespace("::A::B::"), :C]
-    #
+    # ```rb
+    # Namespace("::A::B::C").split    # => [Namespace("::A::B::"), :C]
+    # ```
     def split: () -> [Namespace, Symbol]?
 
     def to_s: () -> String
@@ -105,12 +128,12 @@ module RBS
 
     # Iterate over Namespace for each element in ascending order.
     #
-    # ```
+    # ```rb
     # Namespace.parse("::A::B::C").ascend {|ns| p ns }
-    #   => ::A::B::C
-    #   => ::A::B
-    #   => ::A
-    #   => ::(root)
+    #   # => ::A::B::C
+    #   # => ::A::B
+    #   # => ::A
+    #   # => ::(root)
     # ```
     def ascend: () { (Namespace) -> void } -> void
               | () -> Enumerator[Namespace, void]

data/sig/prototype/rb.rbs

@@ -70,8 +70,12 @@ module RBS
 
       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

data/sig/rbs.rbs

@@ -1,9 +1,9 @@
 module RBS
   def self.logger: () -> Logger
 
-  def self.logger_level: () -> untyped
+  def self.logger_level: () -> Integer?
 
-  def self.logger_level=: (untyped) -> untyped
+  def self.logger_level=: (Integer?) -> Integer?
 
   def self.logger_output: () -> IO
 
@@ -11,9 +11,11 @@ module RBS
 
   def self.print_warning: () { () -> String } -> void
 
-  self.@warnings: Set[String]
-end
+  self.@logger: Logger?
+
+  self.@logger_output: IO?
 
-module Ruby
-  Signature: singleton(RBS)
+  self.@logger_level: Integer?
+
+  self.@warnings: Set[String]
 end

data/sig/rdoc/rbs.rbs

@@ -0,0 +1,63 @@
+module RDoc
+  class Parser
+    class RBS < Parser
+    end
+  end
+end
+
+module RBS
+  module RDocPlugin
+    class Parser
+      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 declartion 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/{polyfill.rbs → shims.rbs}

@@ -4,7 +4,7 @@ module Gem
 
     attr_reader gem_dir (): String
 
-    def self.find_by_name: (String name, ?String? version) -> instance
+    def self.find_by_name: (String name, *String requirements) -> instance
   end
 end
 
@@ -39,10 +39,6 @@ module RDoc
     end
   end
 
-  class CodeObject
-    def comment: () -> RDoc::Markup::Document
-  end
-
   class Context < CodeObject
 
   end
@@ -55,32 +51,6 @@ module RDoc
     def attributes: () -> Array[Attr]
   end
 
-  class Constant < CodeObject
-    def name: () -> String
-  end
-
-  class AnyMethod < MethodAttr
-    def arglists: () -> String?
-
-    def callseq: () -> String?
-  end
-
-  class MethodAttr < CodeObject
-    attr_reader name: String
-
-    attr_reader singleton: bool
-
-    attr_reader is_alias_for: MethodAttr?
-
-    attr_reader call_seq: String
-
-    attr_reader arglists: String
-  end
-
-  class Attr < MethodAttr
-    attr_accessor rw: "RW" | "R" | "W"
-  end
-
   module Markup
     class Document
       include Enumerable[Document]

data/sig/sorter.rbs

@@ -0,0 +1,23 @@
+module RBS
+  class Sorter
+    include RBS::AST
+
+    type member = AST::Declarations::Class::member
+                | AST::Declarations::Module::member
+                | AST::Declarations::Interface::member
+
+    attr_reader path: Pathname
+
+    attr_reader stdout: IO
+
+    def initialize: (Pathname path, ?stdout: IO) -> void
+
+    def run: () -> void
+
+    def group: (member member) -> Numeric
+
+    def key: (member member) -> String
+
+    def sort_decl!: (AST::Declarations::t decl) -> void
+  end
+end

data/sig/types.rbs

@@ -404,13 +404,19 @@ module RBS
       def drop_tail: () -> [Param, Function]
 
       def has_keyword?: () -> bool
+
+      def amap: [A, B] (Array[A]) { (A) -> B } -> Array[B]
+
+      def hmapv: [X, Y, Z] (Hash[X, Y]) { (Y) -> Z } -> Hash[X, Z]
     end
 
     class Block
       attr_reader type: Types::Function
       attr_reader required: bool
 
-      def initialize: (type: Types::Function, required: boolish) -> void
+      attr_reader self_type: t?
+
+      def initialize: (type: Types::Function, ?self_type: t?, required: boolish) -> void
 
       def ==: (untyped other) -> bool
 
@@ -421,13 +427,19 @@ module RBS
       def map_type: () { (t) -> t } -> Block
     end
 
+    module SelfTypeBindingHelper
+      def self?.self_type_binding_to_s: (t?) -> String
+    end
+
     class Proc
       attr_reader type: Function
       attr_reader block: Block?
 
+      attr_reader self_type: t?
+
       type loc = Location[bot, bot]
 
-      def initialize: (location: loc?, type: Function, block: Block?) -> void
+      def initialize: (location: loc?, type: Function, ?self_type: t?, block: Block?) -> void
 
       include _TypeBase
 

data/sig/vendorer.rbs

@@ -1,44 +1,51 @@
 module RBS
   # Copies RBS files loaded through `loader` under `vendor_dir`.
-  # 
+  #
   # Core libraries and library RBS files will be copied.
-  # 
-  #   loader = RBS::EnvironmentLoader.new()
-  # 
-  #   loader.add(library: set)               # Libraries will be copied.
-  #   loader.add(library: "minitest", version: "1.2.3")
-  # 
-  #   loader.add(path: Pathname("sig"))      # Dirs will be ignored.
-  # 
-  #   vendorer = RBS::Vendorer.new(vendor_dir: Pathname("vendor/rbs"), loader: loader)
-  #   vendorer.clearn!
-  #   vendorer.copy!
-  # 
+  #
+  # ```rb
+  # loader = RBS::EnvironmentLoader.new()
+  #
+  # loader.add(library: set)               # Libraries will be copied.
+  # loader.add(library: "minitest", version: "1.2.3")
+  #
+  # loader.add(path: Pathname("sig"))      # Dirs will be ignored.
+  #
+  # vendorer = RBS::Vendorer.new(vendor_dir: Pathname("vendor/rbs"), loader: loader)
+  # vendorer.clearn!
+  # vendorer.copy!
+  # ```
+  #
   # The result will be:
-  #   vendor/rbs/core            => Will include core RBSs
-  #   vendor/rbs/set-0           => Will include `set` library RBSs.
-  #   vendor/rbs/minitest-1.2.3  => Will include `minitest` library RBSs.
-  # 
+  #
+  # ```
+  # vendor/rbs/core            => Will include core RBSs
+  # vendor/rbs/set-0           => Will include `set` library RBSs.
+  # vendor/rbs/minitest-1.2.3  => Will include `minitest` library RBSs.
+  # ```
+  #
   # The vendorerd RBSs will be loaded through :dir source.
-  # 
-  #   loader = RBS::EnvironmentLoader.new(core_root: nil, repository: RBS::Repository.new(no_stdlib: true))
-  #   loader.add(path: Pathname("vendor/rbs"))
-  #   loader.add(path: Pathname("sig"))
-  # 
+  #
+  # ```rb
+  # loader = RBS::EnvironmentLoader.new(core_root: nil, repository: RBS::Repository.new(no_stdlib: true))
+  # loader.add(path: Pathname("vendor/rbs"))
+  # loader.add(path: Pathname("sig"))
+  # ```
+  #
   class Vendorer
     attr_reader vendor_dir: Pathname
     attr_reader loader: EnvironmentLoader
 
     def initialize: (vendor_dir: Pathname, loader: EnvironmentLoader) -> void
-    
+
     # Copy RBS files into `vendor_dir`.
     # Ensures the `vendor_dir` exists.
     def copy!: () -> void
 
     # Deletes `vendor_dir` and its content if exists.
-    # 
+    #
     def clean!: () -> void
-    
+
     def ensure_dir: [A] () { () -> A } -> A
   end
 end