rbs 3.0.0.dev.1 → 3.0.0.dev.3

data/sig/parser.rbs

@@ -6,15 +6,13 @@ module RBS
     # If no token is left in the input, it returns `nil`.
     #
     # ```ruby
+    # RBS::Parser.parse_method_type("() -> void")                                # => `() -> void`
     # RBS::Parser.parse_method_type("() -> void", range: 0...)                   # => `() -> void`
     # RBS::Parser.parse_method_type("() -> void () -> String", range: 11...)     # => `() -> String`
     # RBS::Parser.parse_method_type("() -> void () -> String", range: 23...)     # => nil
     # ```
     #
-    # `line` and `column` is deprecated and are ignored.
-    #
-    def self.parse_method_type: (Buffer | String, range: Range[Integer?], ?variables: Array[Symbol]) -> MethodType?
-                              | (Buffer | String, ?line: top, ?column: top, ?variables: Array[Symbol]) -> MethodType
+    def self.parse_method_type: (Buffer | String, ?range: Range[Integer?], ?variables: Array[Symbol]) -> MethodType?
 
     # Parse a type and return it
     #
@@ -22,22 +20,17 @@ module RBS
     # If no token is left in the input, it returns `nil`.
     #
     # ```ruby
+    # RBS::Parser.parse_type("String")                          # => `String`
     # RBS::Parser.parse_type("String", range: 0...)             # => `String`
     # RBS::Parser.parse_type("String Integer", pos: 7...)       # => `Integer`
     # RBS::Parser.parse_type("String Integer", pos: 14...)      # => nil
     # ```
     #
-    # `line` and `column` is deprecated and are ignored.
-    #
-    def self.parse_type: (Buffer | String, range: Range[Integer?], ?variables: Array[Symbol]) -> Types::t?
-                       | (Buffer | String, ?line: top, ?column: top, ?variables: Array[Symbol]) -> Types::t
+    def self.parse_type: (Buffer | String, ?range: Range[Integer?], ?variables: Array[Symbol]) -> Types::t?
 
     # Parse whole RBS file and return an array of declarations
     #
-    # `line` and `column` is deprecated and are ignored.
-    #
-    def self.parse_signature: (Buffer | String) -> Array[AST::Declarations::t]
-                            | (Buffer | String, ?line: top, ?column: top) -> Array[AST::Declarations::t]
+    def self.parse_signature: (Buffer | String) -> [Buffer, Array[AST::Directives::t], Array[AST::Declarations::t]]
 
     KEYWORDS: Hash[String, bot]
 
@@ -45,11 +38,11 @@ module RBS
 
     def self.buffer: (String | Buffer source) -> Buffer
 
-    def self._parse_type: (Buffer, Integer start_pos, Integer end_pos, Array[Symbol] variables, boolish eof) -> Types::t?
+    def self._parse_type: (Buffer, Integer start_pos, Integer end_pos, Array[Symbol] variables) -> Types::t?
 
-    def self._parse_method_type: (Buffer, Integer start_pos, Integer end_pos, Array[Symbol] variables, boolish eof) -> MethodType?
+    def self._parse_method_type: (Buffer, Integer start_pos, Integer end_pos, Array[Symbol] variables) -> MethodType?
 
-    def self._parse_signature: (Buffer, Integer end_pos) -> Array[AST::Declarations::t]
+    def self._parse_signature: (Buffer, Integer end_pos) -> [Array[AST::Directives::t], Array[AST::Declarations::t]]
 
     class LocatedValue
     end

data/sig/resolver/constant_resolver.rbs

@@ -37,7 +37,7 @@ module RBS
 
         def constant_of_module: (TypeName name, Environment::ClassEntry | Environment::ModuleEntry) -> Constant
 
-        def constant_of_constant: (TypeName name, Environment::SingleEntry[TypeName, AST::Declarations::Constant]) -> Constant
+        def constant_of_constant: (TypeName name, Environment::ConstantEntry) -> Constant
       end
 
       attr_reader builder: DefinitionBuilder
@@ -65,7 +65,6 @@ module RBS
       #    ^  <- constant_name
       # ```
       #
-      # Find the
       def resolve_child: (TypeName module_name, Symbol constant_name) -> Constant?
 
       # Returns the table of all constants accessible with `::` (colon2) operator.

data/sig/shims/bundler.rbs

@@ -1,13 +1,31 @@
 module Bundler
   class LockfileParser
     def initialize: (String) -> void
+
     def specs: () -> Array[LazySpecification]
   end
 
   class LazySpecification
     def name: () -> String
+
     def version: () -> String
+
+    def dependencies: () -> Array[Gem::Dependency]
+  end
+
+  class Dependency < Gem::Dependency
+    attr_reader autorequire: Array[String]?
+  end
+
+  class Definition
+    def lockfile: () -> Pathname
+
+    def locked_gems: () -> LockfileParser
+
+    def dependencies: () -> Array[Dependency]
   end
 
   def self.default_lockfile: () -> Pathname
+
+  def self.definition: () -> Definition
 end

data/sig/shims/rubygems.rbs

@@ -5,5 +5,11 @@ module Gem
     attr_reader gem_dir (): String
 
     def self.find_by_name: (String name, *String requirements) -> instance
+
+    def dependencies: () -> Array[Dependency]
+  end
+
+  class Dependency
+    def name: () -> String
   end
 end

data/sig/use_map.rbs

@@ -0,0 +1,35 @@
+module RBS
+  class Environment
+    # ```rb
+    # map = UseMap.build(environment)
+    #
+    # map.resolve?(TypeName("TN"))   # => nil or resolved type name
+    # ```
+    #
+    class UseMap
+      class Table
+        attr_reader known_types: Set[TypeName]
+
+        attr_reader children: Hash[Namespace, Set[TypeName]]
+
+        def initialize: () -> void
+
+        def compute_children: () -> self
+      end
+
+      attr_reader use_dirs: Array[AST::Directives::Use]
+
+      @map: Hash[Symbol, TypeName]
+
+      @table: Table
+
+      def initialize: (table: Table) -> void
+
+      def resolve?: (TypeName) -> TypeName?
+
+      def resolve: (TypeName) -> TypeName
+
+      def build_map: (AST::Directives::Use::clause) -> self
+    end
+  end
+end

data/sig/validator.rbs

@@ -2,7 +2,7 @@ module RBS
   class Validator
     attr_reader env: Environment
 
-    attr_reader resolver: TypeNameResolver
+    attr_reader resolver: Resolver::TypeNameResolver
 
     attr_reader definition_builder: DefinitionBuilder
 
@@ -10,11 +10,11 @@ module RBS
 
     attr_reader type_alias_regularity: TypeAliasRegularity
 
-    def initialize: (env: Environment, resolver: TypeNameResolver) -> void
+    def initialize: (env: Environment, resolver: Resolver::TypeNameResolver) -> void
 
     # Validates the presence of type names and type application arity match.
     #
-    def validate_type: (Types::t, context: TypeNameResolver::context) -> void
+    def validate_type: (Types::t, context: Resolver::context) -> void
 
     # Validates type alias definition:
     #
@@ -25,7 +25,7 @@ module RBS
     #
     # It yields the rhs type if block is given, so that you can validate the rhs type.
     #
-    def validate_type_alias: (entry: Environment::SingleEntry[TypeName, AST::Declarations::Alias]) ?{ (Types::t rhs_type) -> void } -> void
+    def validate_type_alias: (entry: Environment::TypeAliasEntry) ?{ (Types::t rhs_type) -> void } -> void
 
     # Validates the type parameters in generic methods.
     #
@@ -42,11 +42,18 @@ module RBS
     #
     def validate_type_params: (Array[AST::TypeParam] params, type_name: TypeName, ?method_name: Symbol?, location: Location[untyped, untyped]?) -> void
 
+    # Validates class alias declaration
+    #
+    # - The right hand side can be normalized
+    # - No mixing alias declaration between class and modules
+    # 
+    def validate_class_alias: (entry: Environment::ClassAliasEntry | Environment::ModuleAliasEntry) -> void
+
     private
 
     # Resolves relative type names to absolute type names in given context.
     # Yields the type when the type name resolution using `#resolver` fails.
     #
-    def absolute_type: (Types::t, context: TypeNameResolver::context) { (Types::t) -> TypeName } -> Types::t
+    def absolute_type: (Types::t, context: Resolver::context) { (Types::t) -> TypeName } -> Types::t
   end
 end

data/sig/writer.rbs

@@ -21,7 +21,7 @@ module RBS
     # Output the array of declarations.
     # It automatically inserts empty lines between the declarations.
     #
-    def write: (Array[AST::Declarations::t]) -> void
+    def write: (Array[AST::Declarations::t | AST::Directives::t]) -> void
 
     def preserve?: () -> bool
 
@@ -96,6 +96,8 @@ module RBS
 
     def format_annotation: (AST::Annotation) -> String
 
+    def write_directive: (AST::Directives::t) -> void
+
     def write_annotation: (Array[AST::Annotation]) -> void
 
     def write_comment: (AST::Comment?) -> void
@@ -108,7 +110,7 @@ module RBS
 
     def name_and_args: (TypeName, Array[Types::t]) -> String?
 
-    def write_alias: (AST::Declarations::Alias) -> void
+    def write_alias: (AST::Declarations::TypeAlias) -> void
 
     def method_name: (Symbol) -> String
 

data/stdlib/bigdecimal/0/big_decimal.rbs

@@ -145,12 +145,8 @@ class BigDecimal < Numeric
 
   # <!--
   #   rdoc-file=ext/bigdecimal/bigdecimal.c
-  #   - BigDecimal.double_fig -> integer
+  #   - double_fig()
   # -->
-  # Returns the number of digits a Float object is allowed to have; the result is
-  # system-dependent:
-  #
-  #     BigDecimal.double_fig # => 16
   #
   def self.double_fig: () -> Integer
 
@@ -1007,7 +1003,9 @@ class BigDecimal < Numeric
   # -->
   # Returns the sign of the value.
   #
-  # Returns a positive value if > 0, a negative value if < 0, and a zero if == 0.
+  # Returns a positive value if > 0, a negative value if < 0. It behaves the same
+  # with zeros - it returns a positive value for a positive zero (BigDecimal('0'))
+  # and a negative value for a negative zero (BigDecimal('-0')).
   #
   # The specific value returned indicates the type and sign of the BigDecimal, as
   # follows:
@@ -1348,12 +1346,15 @@ module Kernel
   #   - BigDecimal(value, exception: true) -> bigdecimal
   #   - BigDecimal(value, ndigits, exception: true) -> bigdecimal
   # -->
-  # Returns the \BigDecimal converted from +value+
-  #     with a precision of +ndigits+ decimal digits.
+  # Returns the BigDecimal converted from `value` with a precision of `ndigits`
+  # decimal digits.
+  #
+  # When `ndigits` is less than the number of significant digits in the value, the
+  # result is rounded to that number of digits, according to the current rounding
+  # mode; see BigDecimal.mode.
   #
-  #     When +ndigits+ is less than the number of significant digits
-  #     in the value, the result is rounded to that number of digits,
-  #     according to the current rounding mode; see BigDecimal.mode.
+  # When `ndigits` is 0, the number of digits to correctly represent a float
+  # number is determined automatically.
   #
   # Returns `value` converted to a BigDecimal, depending on the type of `value`:
   #
@@ -1486,13 +1487,15 @@ class Float
   #   - float.to_d(precision)  -> bigdecimal
   # -->
   # Returns the value of `float` as a BigDecimal. The `precision` parameter is
-  # used to determine the number of significant digits for the result (the default
-  # is Float::DIG).
+  # used to determine the number of significant digits for the result. When
+  # `precision` is set to `0`, the number of digits to represent the float being
+  # converted is determined automatically. The default `precision` is `0`.
   #
   #     require 'bigdecimal'
   #     require 'bigdecimal/util'
   #
   #     0.5.to_d         # => 0.5e0
+  #     1.234.to_d       # => 0.1234e1
   #     1.234.to_d(2)    # => 0.12e1
   #
   # See also BigDecimal::new.

data/stdlib/cgi/0/core.rbs

@@ -882,6 +882,14 @@ class CGI
     #
     def escapeHTML: (string str) -> String
 
+    # <!--
+    #   rdoc-file=ext/cgi/escape/escape.c
+    #   - CGI.escapeURIComponent(string) -> string
+    # -->
+    # Returns URL-escaped string following RFC 3986.
+    #
+    def escapeURIComponent: (string) -> String
+
     # <!--
     #   rdoc-file=ext/cgi/escape/escape.c
     #   - CGI.unescape(string, encoding=@@accept_charset) -> string
@@ -897,6 +905,14 @@ class CGI
     # Returns HTML-unescaped string.
     #
     def unescapeHTML: (string str) -> String
+
+    # <!--
+    #   rdoc-file=ext/cgi/escape/escape.c
+    #   - CGI.unescapeURIComponent(string, encoding=@@accept_charset) -> string
+    # -->
+    # Returns URL-unescaped string following RFC 3986.
+    #
+    def unescapeURIComponent: (string) -> String
   end
 
   # <!-- rdoc-file=lib/cgi/core.rb -->

data/stdlib/coverage/0/coverage.rbs

@@ -3,7 +3,7 @@
 # experimental, so these APIs may be changed in future.
 #
 # Caveat: Currently, only process-global coverage measurement is supported. You
-# cannot measure per-thread covearge.
+# cannot measure per-thread coverage.
 #
 # # Usage
 #
@@ -153,7 +153,7 @@ module Coverage
   #   - line_stub(file)
   # -->
   #
-  def self.line_stub: () -> Array[Integer?]
+  def self.line_stub: (String) -> Array[Integer?]
 
   # <!--
   #   rdoc-file=ext/coverage/coverage.c
@@ -190,15 +190,41 @@ module Coverage
 
   # <!--
   #   rdoc-file=ext/coverage/coverage.c
-  #   - Coverage.start                                              => nil
-  #   - Coverage.start(:all)                                        => nil
-  #   - Coverage.start(lines: bool, branches: bool, methods: bool)  => nil
-  #   - Coverage.start(oneshot_lines: true)                         => nil
+  #   - Coverage.setup                                                          => nil
+  #   - Coverage.setup(:all)                                                    => nil
+  #   - Coverage.setup(lines: bool, branches: bool, methods: bool, eval: bool)  => nil
+  #   - Coverage.setup(oneshot_lines: true)                                     => nil
+  # -->
+  # Set up the coverage measurement.
+  #
+  # Note that this method does not start the measurement itself. Use
+  # Coverage.resume to start the measurement.
+  #
+  # You may want to use Coverage.start to setup and then start the measurement.
+  #
+  def self.setup: (?lines: bool, ?branches: bool, ?methods: bool, ?eval: bool) -> nil
+                | (oneshot_lines: bool, ?branches: bool, ?methods: bool, ?eval: bool) -> nil
+                | (:all) -> nil
+
+  # <!--
+  #   rdoc-file=ext/coverage/coverage.c
+  #   - Coverage.start                                                          => nil
+  #   - Coverage.start(:all)                                                    => nil
+  #   - Coverage.start(lines: bool, branches: bool, methods: bool, eval: bool)  => nil
+  #   - Coverage.start(oneshot_lines: true)                                     => nil
   # -->
   # Enables the coverage measurement. See the documentation of Coverage class in
   # detail. This is equivalent to Coverage.setup and Coverage.resume.
   #
-  def self.start: (?lines: boolish, ?branches: boolish, ?methods: boolish, ?oneshot_lines: boolish) -> nil
+  alias self.start self.setup
+
+  # <!--
+  #   rdoc-file=ext/coverage/coverage.c
+  #   - Coverage.state  => :idle, :suspended, :running
+  # -->
+  # Returns the state of the coverage measurement.
+  #
+  def self.state: () -> (:idle | :suspended | :running)
 
   # <!--
   #   rdoc-file=ext/coverage/coverage.c
@@ -207,12 +233,28 @@ module Coverage
   # Start/resume the coverage measurement.
   #
   # Caveat: Currently, only process-global coverage measurement is supported. You
-  # cannot measure per-thread covearge. If your process has multiple thread, using
+  # cannot measure per-thread coverage. If your process has multiple thread, using
   # Coverage.resume/suspend to capture code coverage executed from only a limited
   # code block, may yield misleading results.
   #
   def self.resume: () -> nil
 
+  # <!--
+  #   rdoc-file=ext/coverage/coverage.c
+  #   - Coverage.supported?(mode) -> true or false
+  # -->
+  # Returns true if coverage measurement is supported for the given mode.
+  #
+  # The mode should be one of the following symbols: `:lines`, `:branches`,
+  # `:methods`, `:eval`.
+  #
+  # Example:
+  #
+  #     Coverage.supported?(:lines)  #=> true
+  #     Coverage.supported?(:all)    #=> false
+  #
+  def self.supported?: (Symbol) -> bool
+
   # <!--
   #   rdoc-file=ext/coverage/coverage.c
   #   - Coverage.suspend  => nil

data/stdlib/csv/0/csv.rbs

@@ -2488,7 +2488,7 @@ class CSV::Row < Object
   # `index_or_header` and `specifiers`.
   #
   # The nested objects may be instances of various classes. See [Dig
-  # Methods](https://docs.ruby-lang.org/en/master/dig_methods_rdoc.html).
+  # Methods](rdoc-ref:dig_methods.rdoc).
   #
   # Examples:
   #     source = "Name,Value\nfoo,0\nbar,1\nbaz,2\n"