upgrade Scalafmt (from 1.5.1 to 3.7.4) and reformat sources

Author: SethTisue

.scalafmt.conf

@@ -1,7 +1,14 @@
-version=1.5.1
-align = more
-docstrings = JavaDoc
-assumeStandardLibraryStripMargin = true
+version = 3.7.4
+runner.dialect = scala3
+align.preset = more
+docstrings.style = keep
+rewrite.trailingCommas.style = keep
+align.openParenDefnSite = true
+newlines.avoidInResultType = true
+danglingParentheses.defnSite = false
+danglingParentheses.callSite = false
+newlines.source = keep
+newlines.implicitParamListModifierPrefer = before
 project.git = true
 maxColumn = 100
 project.excludeFilters = [
@@ -12,5 +19,3 @@ project.excludeFilters = [
   "scalafix/output213/"
   "scalafix/output213-failure/"
 ]
-
-

compat/src/main/scala-2.11/scala/collection/compat/package.scala

@@ -28,7 +28,7 @@ package object compat extends compat.PackageShared {
   // the strict type of the view to be `Map` instead of `Iterable`
   // Instances produced by this method are used to chain `filterKeys` after `mapValues`
   implicit def canBuildFromIterableViewMapLike[K, V, L, W, CC[X, Y] <: Map[X, Y]]
-    : CanBuildFrom[IterableView[(K, V), CC[K, V]], (L, W), IterableView[(L, W), CC[L, W]]] =
+      : CanBuildFrom[IterableView[(K, V), CC[K, V]], (L, W), IterableView[(L, W), CC[L, W]]] =
     new CanBuildFrom[IterableView[(K, V), CC[K, V]], (L, W), IterableView[(L, W), CC[L, W]]] {
       // `CanBuildFrom` parameters are used as type constraints, they are not used
       // at run-time, hence the dummy builder implementations
@@ -37,8 +37,8 @@ package object compat extends compat.PackageShared {
     }
 
   implicit def toTraversableLikeExtensionMethods[Repr](self: Repr)(
-      implicit traversable: IsTraversableLike[Repr])
-    : TraversableLikeExtensionMethods[traversable.A, Repr] =
+      implicit
+      traversable: IsTraversableLike[Repr]): TraversableLikeExtensionMethods[traversable.A, Repr] =
     new TraversableLikeExtensionMethods[traversable.A, Repr](traversable.conversion(self))
 
   implicit def toSeqExtensionMethods[A](self: c.Seq[A]): SeqExtensionMethods[A] =

compat/src/main/scala-2.11/scala/util/Using.scala

@@ -236,8 +236,8 @@ object Using {
       case _: LinkageError                          => 3
       case _: InterruptedException | _: ThreadDeath => 2
       case _: ControlThrowable                      => 0
-      case e if !NonFatal(e)                        => 1 // in case this method gets out of sync with NonFatal
-      case _                                        => -1
+      case e if !NonFatal(e) => 1 // in case this method gets out of sync with NonFatal
+      case _                 => -1
     }
     // special-case `ControlThrowable`, which incorrectly suppresses exceptions
     //   before 2.13

compat/src/main/scala-2.11_2.12/scala/collection/compat/CompatImpl.scala

@@ -24,7 +24,7 @@ private abstract class PreservingBuilder[A, C <: TraversableOnce[A]] extends m.B
   val that: m.Builder[A, C]
   val ct: ClassTag[C]
 
-  //invariant: ruined => (collection == null)
+  // invariant: ruined => (collection == null)
   var collection: C = null.asInstanceOf[C]
   var ruined        = false
 

compat/src/main/scala-2.11_2.12/scala/collection/compat/PackageShared.scala

@@ -578,8 +578,8 @@ class TrulyTraversableLikeExtensionMethods[El1, Repr1](
 class Tuple2ZippedExtensionMethods[El1, Repr1, El2, Repr2](
     private val self: Tuple2Zipped[El1, Repr1, El2, Repr2]) {
 
-  def lazyZip[El3, Repr3, T3](t3: T3)(implicit w3: T3 => IterableLike[El3, Repr3])
-    : Tuple3Zipped[El1, Repr1, El2, Repr2, El3, Repr3] =
+  def lazyZip[El3, Repr3, T3](t3: T3)(implicit
+  w3: T3 => IterableLike[El3, Repr3]): Tuple3Zipped[El1, Repr1, El2, Repr2, El3, Repr3] =
     new Tuple3Zipped((self.colls._1, self.colls._2, t3))
 }
 

compat/src/main/scala-2.11_2.12/scala/collection/compat/StringParsers.scala

@@ -20,12 +20,12 @@ import scala.annotation.tailrec
  */
 private[scala] object StringParsers {
 
-  //compile-time constant helpers
+  // compile-time constant helpers
 
-  //Int.MinValue == -2147483648
+  // Int.MinValue == -2147483648
   private final val intOverflowBoundary = -214748364
   private final val intOverflowDigit    = 9
-  //Long.MinValue == -9223372036854775808L
+  // Long.MinValue == -9223372036854775808L
   private final val longOverflowBoundary = -922337203685477580L
   private final val longOverflowDigit    = 9
 
@@ -56,23 +56,23 @@ private[scala] object StringParsers {
   @inline
   private[this] final def isDigit(c: Char): Boolean = c >= '0' && c <= '9'
 
-  //bool
+  // bool
   @inline
   final def parseBool(from: String): Option[Boolean] =
     if (from.equalsIgnoreCase("true")) Some(true)
     else if (from.equalsIgnoreCase("false")) Some(false)
     else None
 
-  //integral types
+  // integral types
   final def parseByte(from: String): Option[Byte] = {
     val len = from.length()
-    //empty strings parse to None
+    // empty strings parse to None
     if (len == 0) None
     else {
       val first = from.charAt(0)
       val v     = decValue(first)
       if (len == 1) {
-        //"+" and "-" parse to None
+        // "+" and "-" parse to None
         if (v > -1) Some(v.toByte)
         else None
       } else if (v > -1) stepToOverflow(from, len, -v, true, Byte.MinValue).map(_.toByte)
@@ -84,13 +84,13 @@ private[scala] object StringParsers {
 
   final def parseShort(from: String): Option[Short] = {
     val len = from.length()
-    //empty strings parse to None
+    // empty strings parse to None
     if (len == 0) None
     else {
       val first = from.charAt(0)
       val v     = decValue(first)
       if (len == 1) {
-        //"+" and "-" parse to None
+        // "+" and "-" parse to None
         if (v > -1) Some(v.toShort)
         else None
       } else if (v > -1) stepToOverflow(from, len, -v, true, Short.MinValue).map(_.toShort)
@@ -116,13 +116,13 @@ private[scala] object StringParsers {
         else step(i + 1, (agg * 10) - digit, isPositive)
       }
     }
-    //empty strings parse to None
+    // empty strings parse to None
     if (len == 0) None
     else {
       val first = from.charAt(0)
       val v     = decValue(first)
       if (len == 1) {
-        //"+" and "-" parse to None
+        // "+" and "-" parse to None
         if (v > -1) Some(v)
         else None
       } else if (v > -1) step(1, -v, true)
@@ -133,7 +133,7 @@ private[scala] object StringParsers {
   }
 
   final def parseLong(from: String): Option[Long] = {
-    //like parseInt, but Longer
+    // like parseInt, but Longer
     val len = from.length()
 
     @tailrec
@@ -149,13 +149,13 @@ private[scala] object StringParsers {
         else step(i + 1, agg * 10 - digit, isPositive)
       }
     }
-    //empty strings parse to None
+    // empty strings parse to None
     if (len == 0) None
     else {
       val first = from.charAt(0)
       val v     = decValue(first).toLong
       if (len == 1) {
-        //"+" and "-" parse to None
+        // "+" and "-" parse to None
         if (v > -1) Some(v)
         else None
       } else if (v > -1) step(1, -v, true)
@@ -165,24 +165,24 @@ private[scala] object StringParsers {
     }
   }
 
-  //floating point
+  // floating point
   final def checkFloatFormat(format: String): Boolean = {
-    //indices are tracked with a start index which points *at* the first index
-    //and an end index which points *after* the last index
-    //so that slice length === end - start
-    //thus start == end <=> empty slice
-    //and format.substring(start, end) is equivalent to the slice
+    // indices are tracked with a start index which points *at* the first index
+    // and an end index which points *after* the last index
+    // so that slice length === end - start
+    // thus start == end <=> empty slice
+    // and format.substring(start, end) is equivalent to the slice
 
-    //some utilities for working with index bounds into the original string
+    // some utilities for working with index bounds into the original string
     @inline
     def forAllBetween(start: Int, end: Int, pred: Char => Boolean): Boolean = {
       @tailrec
       def rec(i: Int): Boolean = i >= end || pred(format.charAt(i)) && rec(i + 1)
       rec(start)
     }
 
-    //one after last index for the predicate to hold, or `from` if none hold
-    //may point after the end of the string
+    // one after last index for the predicate to hold, or `from` if none hold
+    // may point after the end of the string
     @inline
     def skipIndexWhile(predicate: Char => Boolean, from: Int, until: Int): Int = {
       @tailrec @inline
@@ -201,20 +201,21 @@ private[scala] object StringParsers {
       def prefixOK(startIndex: Int, endIndex: Int): Boolean = {
         val len = endIndex - startIndex
         (len > 0) && {
-          //the prefix part is
-          //hexDigits
-          //hexDigits.
-          //hexDigits.hexDigits
-          //.hexDigits
-          //but not .
+          // the prefix part is
+          // hexDigits
+          // hexDigits.
+          // hexDigits.hexDigits
+          // .hexDigits
+          // but not .
           if (format.charAt(startIndex) == '.') {
             (len > 1) && forAllBetween(startIndex + 1, endIndex, isHexDigit)
           } else {
             val noLeading = skipIndexWhile(isHexDigit, startIndex, endIndex)
             (noLeading >= endIndex) ||
-            ((format.charAt(noLeading) == '.') && forAllBetween(noLeading + 1,
-                                                                endIndex,
-                                                                isHexDigit))
+            ((format.charAt(noLeading) == '.') && forAllBetween(
+              noLeading + 1,
+              endIndex,
+              isHexDigit))
           }
         }
       }
@@ -234,7 +235,7 @@ private[scala] object StringParsers {
     }
 
     def isDecFloatLiteral(startIndex: Int, endIndex: Int): Boolean = {
-      //invariant: endIndex > startIndex
+      // invariant: endIndex > startIndex
 
       def isExp(c: Char): Boolean = c == 'e' || c == 'E'
 
@@ -247,57 +248,59 @@ private[scala] object StringParsers {
           else skipIndexWhile(isDigit, startIndex, endIndex) == endIndex
         }
 
-      //significant can be one of
-      //* digits.digits
-      //* .digits
-      //* digits.
-      //but not just .
+      // significant can be one of
+      // * digits.digits
+      // * .digits
+      // * digits.
+      // but not just .
       val startChar = format.charAt(startIndex)
       if (startChar == '.') {
         val noSignificant = skipIndexWhile(isDigit, startIndex + 1, endIndex)
         // a digit is required followed by optional exp
         (noSignificant > startIndex + 1) && (noSignificant >= endIndex ||
-        isExp(format.charAt(noSignificant)) && expOK(noSignificant + 1, endIndex))
+          isExp(format.charAt(noSignificant)) && expOK(noSignificant + 1, endIndex))
       } else if (isDigit(startChar)) {
         // one set of digits, then optionally a period, then optionally another set of digits, then optionally an exponent
         val noInt = skipIndexWhile(isDigit, startIndex, endIndex)
         // just the digits
         (noInt == endIndex) || {
           if (format.charAt(noInt) == '.') {
             val noSignificant = skipIndexWhile(isDigit, noInt + 1, endIndex)
-            (noSignificant >= endIndex) || //no exponent
+            (noSignificant >= endIndex) || // no exponent
             isExp(format.charAt(noSignificant)) && expOK(noSignificant + 1, endIndex)
           } else
             isExp(format.charAt(noInt)) && expOK(noInt + 1, endIndex)
         }
       } else false
     }
 
-    //count 0x00 to 0x20 as "whitespace", and nothing else
+    // count 0x00 to 0x20 as "whitespace", and nothing else
     val unspacedStart = format.indexWhere(ch => ch.toInt > 0x20)
     val unspacedEnd   = format.lastIndexWhere(ch => ch.toInt > 0x20) + 1
 
     if (unspacedStart == -1 || unspacedStart >= unspacedEnd || unspacedEnd <= 0) false
     else {
-      //all formats can have a sign
+      // all formats can have a sign
       val unsigned = {
         val startchar = format.charAt(unspacedStart)
         if (startchar == '-' || startchar == '+') unspacedStart + 1 else unspacedStart
       }
       if (unsigned >= unspacedEnd) false
-      //that's it for NaN and Infinity
+      // that's it for NaN and Infinity
       else if (format.charAt(unsigned) == 'N') format.substring(unsigned, unspacedEnd) == "NaN"
       else if (format.charAt(unsigned) == 'I') format.substring(unsigned, unspacedEnd) == "Infinity"
       else {
-        //all other formats can have a format suffix
+        // all other formats can have a format suffix
         val desuffixed = {
           val endchar = format.charAt(unspacedEnd - 1)
           if (endchar == 'f' || endchar == 'F' || endchar == 'd' || endchar == 'D') unspacedEnd - 1
           else unspacedEnd
         }
         val len = desuffixed - unsigned
         if (len <= 0) false
-        else if (len >= 2 && (format.charAt(unsigned + 1) == 'x' || format.charAt(unsigned + 1) == 'X'))
+        else if (
+          len >= 2 && (format.charAt(unsigned + 1) == 'x' || format.charAt(unsigned + 1) == 'X')
+        )
           format.charAt(unsigned) == '0' && isHexFloatLiteral(unsigned + 2, desuffixed)
         else isDecFloatLiteral(unsigned, desuffixed)
       }