rbs 3.7.0.pre.1 → 3.8.0.pre.1

data/sig/resolver/context.rbs

@@ -9,7 +9,7 @@ module RBS
     #
     # Note that the `TypeName` must be an absolute type name.
     #
-    # The following Ruby code has context of `[[nil, TypeName("::Foo")], false]` where
+    # The following Ruby code has context of `[[nil, TypeName.parse("::Foo")], false]` where
     #
     # * `Foo` is a class defined in RBS file
     # * `Bar` is not defined in RBS files

data/sig/type_alias_regularity.rbs

@@ -20,9 +20,9 @@ module RBS
   # ```rb
   # validator = RBS::TypeAliasRegularity.validate(env: env)
   #
-  # validator.nonregular?(TypeName("::foo"))    # => nil
-  # validator.nonregular?(TypeName("::bar"))    # => nil
-  # validator.nonregular?(TypeName("::baz"))    # => TypeAliasRegularity::Diagnostic
+  # validator.nonregular?(TypeName.parse("::foo"))    # => nil
+  # validator.nonregular?(TypeName.parse("::bar"))    # => nil
+  # validator.nonregular?(TypeName.parse("::baz"))    # => TypeAliasRegularity::Diagnostic
   # ```
   #
   # A special case is when the type argument is `untyped`.
@@ -51,8 +51,8 @@ module RBS
     # The type `t` is nonregular because it contains `t[T?]` on it's right hand side.
     #
     # ```
-    # diagnostic = validator.nonregular?(TypeName("::t"))
-    # diagnostic.type_name         # => TypeName("::t")
+    # diagnostic = validator.nonregular?(TypeName.parse("::t"))
+    # diagnostic.type_name         # => TypeName.parse("::t")
     # diagnostic.nonregular_type   # => t[T?]
     # ```
     #

data/sig/typename.rbs

@@ -57,9 +57,9 @@ module RBS
     # Returns a new type name with a namespace appended to given namespace.
     #
     # ```rb
-    # TypeName("Hello").with_prefix(Namespace("World"))           # => World::Hello
-    # TypeName("Foo::Bar").with_prefix(Namespace("::Hello"))      # => ::Hello::Foo::Bar
-    # TypeName("::A::B").with_prefix(Namespace("C"))              # => ::A::B
+    # TypeName.parse("Hello").with_prefix(Namespace("World"))           # => World::Hello
+    # TypeName.parse("Foo::Bar").with_prefix(Namespace("::Hello"))      # => ::Hello::Foo::Bar
+    # TypeName.parse("::A::B").with_prefix(Namespace("C"))              # => ::A::B
     # ```
     #
     def with_prefix: (Namespace namespace) -> TypeName
@@ -67,10 +67,13 @@ module RBS
     def +: (TypeName) -> TypeName
 
     def split: () -> Array[Symbol]
+
+    # Returns type name with given string representation.
+    def self.parse: (String name) -> RBS::TypeName
   end
 end
 
 module Kernel
-  # Returns type name with given string representation.
-  def TypeName: (String name) -> RBS::TypeName
+  # Deprecated: Use `RBS::TypeName.parse` instead
+  %a{steep:deprecated} def TypeName: (String name) -> RBS::TypeName
 end

data/sig/use_map.rbs

@@ -3,7 +3,7 @@ module RBS
     # ```rb
     # map = UseMap.build(environment)
     #
-    # map.resolve?(TypeName("TN"))   # => nil or resolved type name
+    # map.resolve?(TypeName.parse("TN"))   # => nil or resolved type name
     # ```
     #
     class UseMap

data/sig/validator.rbs

@@ -2,7 +2,7 @@ module RBS
   class Validator
     attr_reader env: Environment
 
-    attr_reader resolver: Resolver::TypeNameResolver
+    attr_reader resolver: Resolver::TypeNameResolver?
 
     attr_reader definition_builder: DefinitionBuilder
 
@@ -10,7 +10,7 @@ module RBS
 
     attr_reader type_alias_regularity: TypeAliasRegularity
 
-    def initialize: (env: Environment, resolver: Resolver::TypeNameResolver) -> void
+    def initialize: (env: Environment, ?resolver: Resolver::TypeNameResolver?) -> void
 
     # Validates the presence of type names and type application arity match.
     #

data/stdlib/base64/0/base64.rbs

@@ -5,14 +5,12 @@
 #     printable ASCII characters.
 # *   Decoding such an encoded string.
 #
-#
 # Base64 is commonly used in contexts where binary data is not allowed or
 # supported:
 #
 # *   Images in HTML or CSS files, or in URLs.
 # *   Email attachments.
 #
-#
 # A Base64-encoded string is about one-third larger that its source. See the
 # [Wikipedia article](https://en.wikipedia.org/wiki/Base64) for more
 # information.
@@ -24,7 +22,6 @@
 # *   Whether "padding" is to be used.
 # *   Whether encoded strings are to contain newlines.
 #
-#
 # Note: Examples on this page assume that the including program has executed:
 #
 #     require 'base64'
@@ -45,22 +42,18 @@
 #         [RFC-4648-compliant](https://datatracker.ietf.org/doc/html/rfc4648);
 #         safe for URLs.
 #
-#
-#
 # If you are working with Base64-encoded strings that will come from or be put
 # into URLs, you should choose this encoder-decoder pair of RFC-4648-compliant
 # methods:
 #
 # *   Base64.urlsafe_encode64 and Base64.urlsafe_decode64.
 #
-#
 # Otherwise, you may choose any of the pairs in this module, including the pair
 # above, or the RFC-2045-compliant pairs:
 #
 # *   Base64.encode64 and Base64.decode64.
 # *   Base64.strict_encode64 and Base64.strict_decode64.
 #
-#
 # ## Padding
 #
 # Base64-encoding changes a triplet of input bytes into a quartet of output
@@ -104,7 +97,6 @@
 #         # n = 2:  8 bytes => 12 characters.
 #         Base64.strict_encode64('12345678') # => "MDEyMzQ1Njc="
 #
-#
 # When padding is suppressed, for a positive integer *n*:
 #
 # *   Input bytes of length *3n* generate unpadded output characters of length
@@ -131,7 +123,6 @@
 #         # m = 2:  8 bytes => 11 characters.
 #         Base64.urlsafe_encode64('12345678', padding: false) # => "MDEyMzQ1Njc"
 #
-#
 # **Padding in Decode Methods**
 #
 # All of the Base64 decode methods support (but do not require) padding.

data/stdlib/benchmark/0/benchmark.rbs

@@ -46,7 +46,6 @@
 #           x.report("upto:")  { 1.upto(n) do ; a = "1"; end }
 #         end
 #
-#
 # The result:
 #
 #                   user     system      total        real
@@ -241,7 +240,11 @@ module Benchmark
   #   rdoc-file=lib/benchmark.rb
   #   - realtime() { || ... }
   # -->
-  # Returns the elapsed real time used to execute the given block.
+  # Returns the elapsed real time used to execute the given block. The unit of
+  # time is seconds.
+  #
+  #     Benchmark.realtime { "a" * 1_000_000_000 }
+  #     #=> 0.5098029999935534
   #
   def self?.realtime: () { () -> void } -> Float
 
@@ -366,17 +369,23 @@ module Benchmark
     #
     # `%u`
     # :   Replaced by the user CPU time, as reported by Tms#utime.
+    #
     # `%y`
     # :   Replaced by the system CPU time, as reported by #stime (Mnemonic: y of
     #     "s*y*stem")
+    #
     # `%U`
     # :   Replaced by the children's user CPU time, as reported by Tms#cutime
+    #
     # `%Y`
     # :   Replaced by the children's system CPU time, as reported by Tms#cstime
+    #
     # `%t`
     # :   Replaced by the total CPU time, as reported by Tms#total
+    #
     # `%r`
     # :   Replaced by the elapsed real time, as reported by Tms#real
+    #
     # `%n`
     # :   Replaced by the label string, as reported by Tms#label (Mnemonic: n of
     #     "*n*ame")

data/stdlib/bigdecimal/0/big_decimal.rbs

@@ -1,155 +1,3 @@
-# <!-- rdoc-file=ext/bigdecimal/bigdecimal.c -->
-# BigDecimal provides arbitrary-precision floating point decimal arithmetic.
-#
-# ## Introduction
-#
-# Ruby provides built-in support for arbitrary precision integer arithmetic.
-#
-# For example:
-#
-#     42**13  #=>   1265437718438866624512
-#
-# BigDecimal provides similar support for very large or very accurate floating
-# point numbers.
-#
-# Decimal arithmetic is also useful for general calculation, because it provides
-# the correct answers people expect--whereas normal binary floating point
-# arithmetic often introduces subtle errors because of the conversion between
-# base 10 and base 2.
-#
-# For example, try:
-#
-#     sum = 0
-#     10_000.times do
-#       sum = sum + 0.0001
-#     end
-#     print sum #=> 0.9999999999999062
-#
-# and contrast with the output from:
-#
-#     require 'bigdecimal'
-#
-#     sum = BigDecimal("0")
-#     10_000.times do
-#       sum = sum + BigDecimal("0.0001")
-#     end
-#     print sum #=> 0.1E1
-#
-# Similarly:
-#
-#     (BigDecimal("1.2") - BigDecimal("1.0")) == BigDecimal("0.2") #=> true
-#
-#     (1.2 - 1.0) == 0.2 #=> false
-#
-# ## A Note About Precision
-#
-# For a calculation using a BigDecimal and another `value`, the precision of the
-# result depends on the type of `value`:
-#
-# *   If `value` is a Float, the precision is Float::DIG + 1.
-# *   If `value` is a Rational, the precision is larger than Float::DIG + 1.
-# *   If `value` is a BigDecimal, the precision is `value`'s precision in the
-#     internal representation, which is platform-dependent.
-# *   If `value` is other object, the precision is determined by the result of
-#     +BigDecimal(value)+.
-#
-#
-# ## Special features of accurate decimal arithmetic
-#
-# Because BigDecimal is more accurate than normal binary floating point
-# arithmetic, it requires some special values.
-#
-# ### Infinity
-#
-# BigDecimal sometimes needs to return infinity, for example if you divide a
-# value by zero.
-#
-#     BigDecimal("1.0") / BigDecimal("0.0")  #=> Infinity
-#     BigDecimal("-1.0") / BigDecimal("0.0")  #=> -Infinity
-#
-# You can represent infinite numbers to BigDecimal using the strings
-# `'Infinity'`, `'+Infinity'` and `'-Infinity'` (case-sensitive)
-#
-# ### Not a Number
-#
-# When a computation results in an undefined value, the special value `NaN` (for
-# 'not a number') is returned.
-#
-# Example:
-#
-#     BigDecimal("0.0") / BigDecimal("0.0") #=> NaN
-#
-# You can also create undefined values.
-#
-# NaN is never considered to be the same as any other value, even NaN itself:
-#
-#     n = BigDecimal('NaN')
-#     n == 0.0 #=> false
-#     n == n #=> false
-#
-# ### Positive and negative zero
-#
-# If a computation results in a value which is too small to be represented as a
-# BigDecimal within the currently specified limits of precision, zero must be
-# returned.
-#
-# If the value which is too small to be represented is negative, a BigDecimal
-# value of negative zero is returned.
-#
-#     BigDecimal("1.0") / BigDecimal("-Infinity") #=> -0.0
-#
-# If the value is positive, a value of positive zero is returned.
-#
-#     BigDecimal("1.0") / BigDecimal("Infinity") #=> 0.0
-#
-# (See BigDecimal.mode for how to specify limits of precision.)
-#
-# Note that `-0.0` and `0.0` are considered to be the same for the purposes of
-# comparison.
-#
-# Note also that in mathematics, there is no particular concept of negative or
-# positive zero; true mathematical zero has no sign.
-#
-# ## bigdecimal/util
-#
-# When you require `bigdecimal/util`, the #to_d method will be available on
-# BigDecimal and the native Integer, Float, Rational, and String classes:
-#
-#     require 'bigdecimal/util'
-#
-#     42.to_d         # => 0.42e2
-#     0.5.to_d        # => 0.5e0
-#     (2/3r).to_d(3)  # => 0.667e0
-#     "0.5".to_d      # => 0.5e0
-#
-# ## Methods for Working with JSON
-#
-# *   [::json_create](rdoc-ref:BigDecimal.json_create): Returns a new BigDecimal
-#     object constructed from the given object.
-# *   [#as_json](rdoc-ref:BigDecimal#as_json): Returns a 2-element hash
-#     representing `self`.
-# *   [#to_json](rdoc-ref:BigDecimal#to_json): Returns a JSON string
-#     representing `self`.
-#
-#
-# These methods are provided by the [JSON gem](https://github.com/flori/json).
-# To make these methods available:
-#
-#     require 'json/add/bigdecimal'
-#
-# *   ## License
-#
-#
-# Copyright (C) 2002 by Shigeo Kobayashi <shigeo@tinyforest.gr.jp>.
-#
-# BigDecimal is released under the Ruby and 2-clause BSD licenses. See
-# LICENSE.txt for details.
-#
-# Maintained by mrkn <mrkn@mrkn.jp> and ruby-core members.
-#
-# Documented by zzak <zachary@zacharyscott.net>, mathew <meta@pobox.com>, and
-# many other contributors.
-#
 class BigDecimal < Numeric
   # <!--
   #   rdoc-file=ext/bigdecimal/bigdecimal.c
@@ -208,14 +56,12 @@ class BigDecimal < Numeric
   # *   BigDecimal::EXCEPTION_ZERODIVIDE.
   # *   BigDecimal::EXCEPTION_ALL.
   #
-  #
   # Values for `setting` for exception handling:
   #
   # *   `true`: sets the given `mode` to `true`.
   # *   `false`: sets the given `mode` to `false`.
   # *   `nil`: does not modify the mode settings.
   #
-  #
   # You can use method BigDecimal.save_exception_mode to temporarily change, and
   # then automatically restore, exception modes.
   #
@@ -226,7 +72,6 @@ class BigDecimal < Numeric
   #
   # *   BigDecimal::ROUND_MODE
   #
-  #
   # You can use method BigDecimal.save_rounding_mode to temporarily change, and
   # then automatically restore, the rounding mode.
   #
@@ -240,7 +85,6 @@ class BigDecimal < Numeric
   # *   `false` (default): Returns `BigDecimal('NaN')`.
   # *   `true`: Raises FloatDomainError.
   #
-  #
   # Examples:
   #
   #     BigDecimal.mode(BigDecimal::EXCEPTION_ALL, false) # => 0
@@ -257,7 +101,6 @@ class BigDecimal < Numeric
   #     `BigDecimal('-Infinity')`.
   # *   `true`: Raises FloatDomainError.
   #
-  #
   # Examples:
   #
   #     BigDecimal.mode(BigDecimal::EXCEPTION_ALL, false)     # => 0
@@ -275,7 +118,6 @@ class BigDecimal < Numeric
   # *   `false` (default): Returns `BigDecimal('0')` or `BigDecimal('-Infinity')`.
   # *   `true`: Raises FloatDomainError.
   #
-  #
   # Examples:
   #
   #     BigDecimal.mode(BigDecimal::EXCEPTION_ALL, false)      # => 0
@@ -296,7 +138,6 @@ class BigDecimal < Numeric
   #     `BigDecimal('-Infinity')`.
   # *   `true`: Raises FloatDomainError.
   #
-  #
   # Examples:
   #
   #     BigDecimal.mode(BigDecimal::EXCEPTION_ALL, false)     # => 0
@@ -317,7 +158,6 @@ class BigDecimal < Numeric
   #     `BigDecimal('-Infinity')`.
   # *   `true`: Raises FloatDomainError.
   #
-  #
   # Examples:
   #
   #     BigDecimal.mode(BigDecimal::EXCEPTION_ALL, false)       # => 0
@@ -1030,16 +870,22 @@ class BigDecimal < Numeric
   #
   # BigDecimal::SIGN_NaN
   # :   value is Not a Number
+  #
   # BigDecimal::SIGN_POSITIVE_ZERO
   # :   value is +0
+  #
   # BigDecimal::SIGN_NEGATIVE_ZERO
   # :   value is -0
+  #
   # BigDecimal::SIGN_POSITIVE_INFINITE
   # :   value is +Infinity
+  #
   # BigDecimal::SIGN_NEGATIVE_INFINITE
   # :   value is -Infinity
+  #
   # BigDecimal::SIGN_POSITIVE_FINITE
   # :   value is positive
+  #
   # BigDecimal::SIGN_NEGATIVE_FINITE
   # :   value is negative
   #
@@ -1403,8 +1249,6 @@ module Kernel
   #     *   Raises an exception if keyword argument `exception` is `true`.
   #     *   Returns `nil` if keyword argument `exception` is `false`.
   #
-  #
-  #
   # Raises an exception if `value` evaluates to a Float and `digits` is larger
   # than Float::DIG + 1.
   #
@@ -1713,11 +1557,11 @@ class Complex
   # -->
   # Returns the quotient of `self` and `numeric`:
   #
-  #     Complex(2, 3)  / Complex(2, 3)  # => ((1/1)+(0/1)*i)
-  #     Complex(900)   / Complex(1)     # => ((900/1)+(0/1)*i)
-  #     Complex(-2, 9) / Complex(-9, 2) # => ((36/85)-(77/85)*i)
-  #     Complex(9, 8)  / 4              # => ((9/4)+(2/1)*i)
-  #     Complex(20, 9) / 9.8            # => (2.0408163265306123+0.9183673469387754i)
+  #     Complex.rect(2, 3)  / Complex.rect(2, 3)  # => (1+0i)
+  #     Complex.rect(900)   / Complex.rect(1)     # => (900+0i)
+  #     Complex.rect(-2, 9) / Complex.rect(-9, 2) # => ((36/85)-(77/85)*i)
+  #     Complex.rect(9, 8)  / 4                   # => ((9/4)+2i)
+  #     Complex.rect(20, 9) / 9.8                 # => (2.0408163265306123+0.9183673469387754i)
   #
   def /: (BigDecimal) -> Complex
     | ...
@@ -1728,11 +1572,11 @@ class Complex
   # -->
   # Returns the product of `self` and `numeric`:
   #
-  #     Complex(2, 3)  * Complex(2, 3)  # => (-5+12i)
-  #     Complex(900)   * Complex(1)     # => (900+0i)
-  #     Complex(-2, 9) * Complex(-9, 2) # => (0-85i)
-  #     Complex(9, 8)  * 4              # => (36+32i)
-  #     Complex(20, 9) * 9.8            # => (196.0+88.2i)
+  #     Complex.rect(2, 3)  * Complex.rect(2, 3)  # => (-5+12i)
+  #     Complex.rect(900)   * Complex.rect(1)     # => (900+0i)
+  #     Complex.rect(-2, 9) * Complex.rect(-9, 2) # => (0-85i)
+  #     Complex.rect(9, 8)  * 4                   # => (36+32i)
+  #     Complex.rect(20, 9) * 9.8                 # => (196.0+88.2i)
   #
   def *: (BigDecimal) -> Complex
     | ...
@@ -1743,11 +1587,11 @@ class Complex
   # -->
   # Returns the sum of `self` and `numeric`:
   #
-  #     Complex(2, 3)  + Complex(2, 3)  # => (4+6i)
-  #     Complex(900)   + Complex(1)     # => (901+0i)
-  #     Complex(-2, 9) + Complex(-9, 2) # => (-11+11i)
-  #     Complex(9, 8)  + 4              # => (13+8i)
-  #     Complex(20, 9) + 9.8            # => (29.8+9i)
+  #     Complex.rect(2, 3)  + Complex.rect(2, 3)  # => (4+6i)
+  #     Complex.rect(900)   + Complex.rect(1)     # => (901+0i)
+  #     Complex.rect(-2, 9) + Complex.rect(-9, 2) # => (-11+11i)
+  #     Complex.rect(9, 8)  + 4                   # => (13+8i)
+  #     Complex.rect(20, 9) + 9.8                 # => (29.8+9i)
   #
   def +: (BigDecimal) -> Complex
     | ...
@@ -1758,11 +1602,11 @@ class Complex
   # -->
   # Returns the difference of `self` and `numeric`:
   #
-  #     Complex(2, 3)  - Complex(2, 3)  # => (0+0i)
-  #     Complex(900)   - Complex(1)     # => (899+0i)
-  #     Complex(-2, 9) - Complex(-9, 2) # => (7+7i)
-  #     Complex(9, 8)  - 4              # => (5+8i)
-  #     Complex(20, 9) - 9.8            # => (10.2+9i)
+  #     Complex.rect(2, 3)  - Complex.rect(2, 3)  # => (0+0i)
+  #     Complex.rect(900)   - Complex.rect(1)     # => (899+0i)
+  #     Complex.rect(-2, 9) - Complex.rect(-9, 2) # => (7+7i)
+  #     Complex.rect(9, 8)  - 4                   # => (5+8i)
+  #     Complex.rect(20, 9) - 9.8                 # => (10.2+9i)
   #
   def -: (BigDecimal) -> Complex
     | ...