Replace runtime.Rich* implicits on primitives by direct extension methods.

It has always been weird that the public API of primitive types,
enriched by `Predef` depends on the `Rich*` classes, which are
in the not-really-public `runtime` package.

Moreover, the design of those classes was overabstracted, with
consequences on performance (unnecessary boxing) and quality of
the API (including methods that do not make sense on some types).
To mitigate that, the individual `Rich*` classes redefined some
(but not all) of the methods, defeating the abstraction.

We solve both issues with a simple solution: define all those
methods as simple `extension` methods. We do this directly in the
companion objects of the primitive types.

Author: sjrd

library/src/scala/Boolean.scala

@@ -138,5 +138,27 @@ object Boolean extends AnyValCompanion {
   /** The String representation of the scala.Boolean companion object. */
   override def toString = "object scala.Boolean"
 
-}
+  extension (self: Boolean) {
+
+    /** Compares `this` to `that` according to the standard total ordering.
+      *
+      * Returns:
+      * - a positive value if `this` is `true` and `that` is `false`
+      * - a negative value if `this` is `false` and `that` is `true`
+      * - `0` if `this == that`
+      */
+    def compare(that: Boolean): Int = java.lang.Boolean.compare(self, that)
+
+    /** Returns true iff `this` is `false` and `that` is `true`. */
+    def <(that: Boolean): Boolean = !self & that
 
+    /** Returns true iff `this` is `true` and `that` is `false`. */
+    def >(that: Boolean): Boolean = self & !that
+
+    /** Returns true iff `this` is `false` or `that` is `true`. */
+    def <=(that: Boolean): Boolean = !self | that
+
+    /** Returns true iff `this` is `true` or `that` is `false`. */
+    def >=(that: Boolean): Boolean = self | !that
+  }
+}

library/src/scala/Byte.scala

@@ -18,6 +18,8 @@ package scala
 
 import scala.language.`2.13`
 
+import scala.collection.immutable.NumericRange
+
 /** `Byte`, a 8-bit signed integer (equivalent to Java's `byte` primitive type) is a
  *  subtype of [[scala.AnyVal]]. Instances of `Byte` are not
  *  represented by an object in the underlying runtime system.
@@ -485,5 +487,118 @@ object Byte extends AnyValCompanion {
   implicit def byte2long(x: Byte): Long = x.toLong
   implicit def byte2float(x: Byte): Float = x.toFloat
   implicit def byte2double(x: Byte): Double = x.toDouble
-}
 
+  extension (self: Byte) {
+    /** Returns `'''true'''` if this number has no decimal component.
+      * Always `'''true'''` for `Byte`.
+      */
+    @deprecated("isWhole on Byte is always true", "2.12.15")
+    def isWhole: Boolean = true
+
+    /** Returns `true` iff this is within the
+      * range of [[scala.Char]] MinValue and MaxValue; otherwise returns `false`.
+      */
+    def isValidChar: Boolean = self >= 0
+
+    /** Returns `true` iff this is within the
+      * range of [[scala.Byte]] MinValue and MaxValue; otherwise returns `false`.
+      */
+    @deprecated("isValidByte on Byte is always true", "3.8.0")
+    def isValidByte: Boolean = true
+
+    /** Returns `true` iff this is within the
+      * range of [[scala.Short]] MinValue and MaxValue; otherwise returns `false`.
+      */
+    @deprecated("isValidShort on Byte is always true", "3.8.0")
+    def isValidShort: Boolean = true
+
+    /** Returns `true` iff this is within the
+      * range of [[scala.Int]] MinValue and MaxValue; otherwise returns `false`.
+      */
+    @deprecated("isValidInt on Byte is always true", "3.8.0")
+    def isValidInt: Boolean = true
+
+    /** Returns the absolute value of `this`. */
+    def abs: Byte = java.lang.Math.abs(self.toInt).toByte
+
+    /** Returns `this` if `this > that` or `that` otherwise. */
+    def max(that: Byte): Byte = java.lang.Math.max(self.toInt, that.toInt).toByte
+
+    /** Returns `this` if `this < that` or `that` otherwise. */
+    def min(that: Byte): Byte = java.lang.Math.min(self.toInt, that.toInt).toByte
+
+    /** Returns the sign of `this`.
+      *
+      * `0` if `this == 0`, `-1` if `this < 0` and `1` if `this > 0`.
+      */
+    def sign: Byte = java.lang.Integer.signum(self.toInt).toByte
+
+    /** Returns the signum of `this`. */
+    @deprecated("use `sign` method instead", since = "2.13.0")
+    def signum: Int = self.sign.toInt
+
+    /** Compares `this` to `that` according to the standard total ordering.
+      *
+      * Returns:
+      * - a positive value if `this > that`
+      * - a negative value if `this < that`
+      * - `0` if `this == that`
+      */
+    def compare(that: Byte): Int = java.lang.Byte.compare(self, that)
+
+    /** A [[scala.collection.immutable.NumericRange]] from `this` up to but not including `end`.
+      *
+      * @param end The final bound of the range to make.
+      */
+    def until(end: Byte): NumericRange.Exclusive[Byte] = NumericRange(self, end, 1)
+
+    /** A [[scala.collection.immutable.NumericRange]] from `this` up to but not including `end`.
+      *
+      * @param end The final bound of the range to make.
+      * @param step The number to increase by for each step of the range.
+      */
+    def until(end: Byte, step: Byte): NumericRange.Exclusive[Byte] = NumericRange(self, end, step)
+
+    /** A [[scala.collection.immutable.NumericRange]] from `this` up to and including `end`.
+      *
+      * @param end The final bound of the range to make.
+      */
+    def to(end: Byte): NumericRange.Inclusive[Byte] = NumericRange.inclusive(self, end, 1)
+
+    /** A [[scala.collection.immutable.NumericRange]] from `this` up to and including `end`.
+      *
+      * @param end The final bound of the range to make.
+      * @param step The number to increase by for each step of the range.
+      */
+    def to(end: Byte, step: Byte): NumericRange.Inclusive[Byte] = NumericRange.inclusive(self, end, step)
+
+    // ------------------------------------
+    // For source compatibility with the previous API, when the rhs is an Int, we want an int Range
+
+    /** A [[scala.collection.immutable.Range]] from `this` up to but not including `end`.
+      *
+      * @param end The final bound of the range to make.
+      */
+    def until(end: Int): Range = Range(self.toInt, end, 1)
+
+    /** A [[scala.collection.immutable.Range]] from `this` up to but not including `end`.
+      *
+      * @param end The final bound of the range to make.
+      * @param step The number to increase by for each step of the range.
+      */
+    def until(end: Int, step: Int): Range = Range(self.toInt, end, step)
+
+    /** A [[scala.collection.immutable.Range]] from `this` up to and including `end`.
+      *
+      * @param end The final bound of the range to make.
+      */
+    def to(end: Int): Range.Inclusive = Range.inclusive(self.toInt, end, 1)
+
+    /** A [[scala.collection.immutable.Range]] from `this` up to and including `end`.
+      *
+      * @param end The final bound of the range to make.
+      * @param step The number to increase by for each step of the range.
+      */
+    def to(end: Int, step: Int): Range.Inclusive = Range.inclusive(self.toInt, end, step)
+  }
+}

library/src/scala/Char.scala

@@ -18,6 +18,8 @@ package scala
 
 import scala.language.`2.13`
 
+import scala.collection.immutable.NumericRange
+
 /** `Char`, a 16-bit unsigned integer (equivalent to Java's `char` primitive type) is a
  *  subtype of [[scala.AnyVal]]. Instances of `Char` are not
  *  represented by an object in the underlying runtime system.
@@ -484,5 +486,154 @@ object Char extends AnyValCompanion {
   implicit def char2long(x: Char): Long = x.toLong
   implicit def char2float(x: Char): Float = x.toFloat
   implicit def char2double(x: Char): Double = x.toDouble
-}
 
+  extension (self: Char) {
+
+    /** Returns `'''true'''` if this number has no decimal component.
+      * Always `'''true'''` for `RichInt`.
+      */
+    @deprecated("isWhole on Char is always true", "2.12.15")
+    def isWhole: Boolean = true
+
+    /** Returns `true` iff this is within the
+      * range of [[scala.Char]] MinValue and MaxValue; otherwise returns `false`.
+      */
+    @deprecated("isValidChar on Char is always true", "3.8.0")
+    def isValidChar: Boolean = true
+
+    /** Returns `true` iff this is within the
+      * range of [[scala.Byte]] MinValue and MaxValue; otherwise returns `false`.
+      */
+    def isValidByte: Boolean = self.toInt <= Byte.MaxValue.toInt
+
+    /** Returns `true` iff this is within the
+      * range of [[scala.Short]] MinValue and MaxValue; otherwise returns `false`.
+      */
+    def isValidShort: Boolean = self.toInt <= Short.MaxValue.toInt
+
+    /** Returns `true` iff this is within the
+      * range of [[scala.Int]] MinValue and MaxValue; otherwise returns `false`.
+      */
+    @deprecated("isValidInt on Char is always true", "3.8.0")
+    def isValidInt: Boolean = true
+
+    /** Returns the absolute value of `this`. */
+    @deprecated("Char's are never negative; abs is redundant and can be removed", since = "3.8.0")
+    def abs: Char = self
+
+    /** Returns `this` if `this > that` or `that` otherwise. */
+    def max(that: Char): Char = java.lang.Math.max(self.toInt, that.toInt).toChar
+
+    /** Returns `this` if `this < that` or `that` otherwise. */
+    def min(that: Char): Char = java.lang.Math.min(self.toInt, that.toInt).toChar
+
+    /** Returns the sign of `this`.
+      *
+      * zero if the argument is zero, -zero if the argument is -zero,
+      * one if the argument is greater than zero, -one if the argument is less than zero,
+      * and NaN if the argument is NaN where applicable.
+      */
+    @deprecated("since Char's are never negative, compare to '\\u0000' instead", since = "3.8.0")
+    def sign: Char = java.lang.Integer.signum(self.toInt).toChar
+
+    /** Returns the signum of `this`. */
+    @deprecated("use `sign` method instead", since = "2.13.0")
+    def signum: Int = self.sign
+
+    /** Compares `this` to `that` according to the standard total ordering.
+      *
+      * Returns:
+      * - a positive value if `this > that`
+      * - a negative value if `this < that`
+      * - `0` if `this == that`
+      */
+    def compare(that: Char): Int = java.lang.Character.compare(self, that)
+
+    /** A [[scala.collection.immutable.NumericRange]] from `this` up to but not including `end`.
+      *
+      * @param end The final bound of the range to make.
+      */
+    def until(end: Char): NumericRange.Exclusive[Char] = NumericRange(self, end, '\u0001')
+
+    /** A [[scala.collection.immutable.NumericRange]] from `this` up to but not including `end`.
+      *
+      * @param end The final bound of the range to make.
+      * @param step The number to increase by for each step of the range.
+      */
+    def until(end: Char, step: Char): NumericRange.Exclusive[Char] = NumericRange(self, end, step)
+
+    /** A [[scala.collection.immutable.NumericRange]] from `this` up to and including `end`.
+      *
+      * @param end The final bound of the range to make.
+      */
+    def to(end: Char): NumericRange.Inclusive[Char] = NumericRange.inclusive(self, end, '\u0001')
+
+    /** A [[scala.collection.immutable.NumericRange]] from `this` up to and including `end`.
+      *
+      * @param end The final bound of the range to make.
+      * @param step The number to increase by for each step of the range.
+      */
+    def to(end: Char, step: Char): NumericRange.Inclusive[Char] = NumericRange.inclusive(self, end, step)
+
+    // ------------------------------------
+    // For source compatibility with the previous API, when the rhs is an Int, we want an int Range
+
+    /** A [[scala.collection.immutable.Range]] from `this` up to but not including `end`.
+      *
+      * @param end The final bound of the range to make.
+      */
+    def until(end: Int): Range = Range(self.toInt, end, 1)
+
+    /** A [[scala.collection.immutable.Range]] from `this` up to but not including `end`.
+      *
+      * @param end The final bound of the range to make.
+      * @param step The number to increase by for each step of the range.
+      */
+    def until(end: Int, step: Int): Range = Range(self.toInt, end, step)
+
+    /** A [[scala.collection.immutable.Range]] from `this` up to and including `end`.
+      *
+      * @param end The final bound of the range to make.
+      */
+    def to(end: Int): Range.Inclusive = Range.inclusive(self.toInt, end, 1)
+
+    /** A [[scala.collection.immutable.Range]] from `this` up to and including `end`.
+      *
+      * @param end The final bound of the range to make.
+      * @param step The number to increase by for each step of the range.
+      */
+    def to(end: Int, step: Int): Range.Inclusive = Range.inclusive(self.toInt, end, step)
+
+    // ------------------------------------
+    // Unicode properties
+
+    def asDigit: Int                      = Character.digit(self, Character.MAX_RADIX)
+
+    def isControl: Boolean                = Character.isISOControl(self)
+    def isDigit: Boolean                  = Character.isDigit(self)
+    def isLetter: Boolean                 = Character.isLetter(self)
+    def isLetterOrDigit: Boolean          = Character.isLetterOrDigit(self)
+    def isWhitespace: Boolean             = Character.isWhitespace(self)
+    def isSpaceChar: Boolean              = Character.isSpaceChar(self)
+    def isHighSurrogate: Boolean          = Character.isHighSurrogate(self)
+    def isLowSurrogate: Boolean           = Character.isLowSurrogate(self)
+    def isSurrogate: Boolean              = isHighSurrogate || isLowSurrogate
+    def isUnicodeIdentifierStart: Boolean = Character.isUnicodeIdentifierStart(self)
+    def isUnicodeIdentifierPart: Boolean  = Character.isUnicodeIdentifierPart(self)
+    def isIdentifierIgnorable: Boolean    = Character.isIdentifierIgnorable(self)
+    def isMirrored: Boolean               = Character.isMirrored(self)
+
+    def isLower: Boolean                  = Character.isLowerCase(self)
+    def isUpper: Boolean                  = Character.isUpperCase(self)
+    def isTitleCase: Boolean              = Character.isTitleCase(self)
+
+    def toLower: Char                     = Character.toLowerCase(self)
+    def toUpper: Char                     = Character.toUpperCase(self)
+    def toTitleCase: Char                 = Character.toTitleCase(self)
+
+    def getType: Int                      = Character.getType(self)
+    def getNumericValue: Int              = Character.getNumericValue(self)
+    def getDirectionality: Byte           = Character.getDirectionality(self)
+    def reverseBytes: Char                = Character.reverseBytes(self)
+  }
+}