Merge pull request #9407 from dotty-staging/use-extension-methods

Use extension methods

Author: nicolasstucki

compiler/src/dotty/tools/dotc/CompilationUnit.scala

@@ -12,7 +12,7 @@ import tpd.{Tree, TreeTraverser}
 import typer.PrepareInlineable.InlineAccessors
 import typer.Nullables
 import transform.SymUtils._
-import core.Decorators.{given _}
+import core.Decorators._
 import config.SourceVersion
 
 class CompilationUnit protected (val source: SourceFile) {

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -5,7 +5,7 @@ package ast
 import core._
 import util.Spans._, Types._, Contexts._, Constants._, Names._, NameOps._, Flags._
 import Symbols._, StdNames._, Trees._, Phases._, ContextOps._
-import Decorators.{given _}, transform.SymUtils._
+import Decorators._, transform.SymUtils._
 import NameKinds.{UniqueName, EvidenceParamName, DefaultGetterName}
 import typer.{FrontEnd, Namer}
 import util.{Property, SourceFile, SourcePosition}

compiler/src/dotty/tools/dotc/ast/TreeInfo.scala

@@ -831,7 +831,7 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
   /** Structural tree comparison (since == on trees is reference equality).
    *  For the moment, only Ident, Select, Literal, Apply and TypeApply are supported
    */
-  implicit class StructuralEqDeco(t1: Tree) {
+  extension (t1: Tree) {
     def === (t2: Tree)(using Context): Boolean = (t1, t2) match {
       case (t1: Ident, t2: Ident) =>
         t1.symbol == t2.symbol

compiler/src/dotty/tools/dotc/ast/tpd.scala

@@ -9,7 +9,7 @@ import transform.TypeUtils._
 import core._
 import util.Spans._, Types._, Contexts._, Constants._, Names._, Flags._, NameOps._
 import Symbols._, StdNames._, Annotations._, Trees._, Symbols._
-import Decorators.{given _}, DenotTransformers._
+import Decorators._, DenotTransformers._
 import collection.{immutable, mutable}
 import util.{Property, SourceFile, NoSource}
 import NameKinds.{TempResultName, OuterSelectName}
@@ -1111,12 +1111,11 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       !(sym.is(Method) && sym.info.isInstanceOf[MethodOrPoly]) // if is a method it is parameterless
   }
 
-  implicit class ListOfTreeDecorator(val xs: List[tpd.Tree]) extends AnyVal {
+  extension (xs: List[tpd.Tree]):
     def tpes: List[Type] = xs match {
       case x :: xs1 => x.tpe :: xs1.tpes
       case nil => Nil
     }
-  }
 
   /** A trait for loaders that compute trees. Currently implemented just by DottyUnpickler. */
   trait TreeProvider {

compiler/src/dotty/tools/dotc/classpath/ClassPathFactory.scala

@@ -4,7 +4,7 @@
 package dotty.tools.dotc.classpath
 
 import dotty.tools.io.{AbstractFile, VirtualDirectory}
-import FileUtils.AbstractFileOps
+import FileUtils._
 import dotty.tools.io.ClassPath
 import dotty.tools.dotc.core.Contexts._
 

compiler/src/dotty/tools/dotc/classpath/FileUtils.scala

@@ -12,7 +12,7 @@ import dotty.tools.io.AbstractFile
  * Common methods related to Java files and abstract files used in the context of classpath
  */
 object FileUtils {
-  implicit class AbstractFileOps(val file: AbstractFile) extends AnyVal {
+  extension (file: AbstractFile) {
     def isPackage: Boolean = file.isDirectory && mayBeValidPackage(file.name)
 
     def isClass: Boolean = !file.isDirectory && file.hasExtension("class") && !file.name.endsWith("$class.class")
@@ -30,7 +30,7 @@ object FileUtils {
     def toURLs(default: => Seq[URL] = Seq.empty): Seq[URL] = if (file.file == null) default else Seq(file.toURL)
   }
 
-  implicit class FileOps(val file: JFile) extends AnyVal {
+  extension (file: JFile) {
     def isPackage: Boolean = file.isDirectory && mayBeValidPackage(file.getName)
 
     def isClass: Boolean = file.isFile && file.getName.endsWith(".class") && !file.getName.endsWith("$class.class")

compiler/src/dotty/tools/dotc/classpath/ZipArchiveFileLookup.scala

@@ -7,7 +7,7 @@ import java.io.File
 import java.net.URL
 
 import dotty.tools.io.{ AbstractFile, FileZipArchive }
-import FileUtils.AbstractFileOps
+import FileUtils._
 import dotty.tools.io.{ClassPath, ClassRepresentation}
 
 /**

compiler/src/dotty/tools/dotc/config/Settings.scala

@@ -184,7 +184,7 @@ object Settings {
   }
 
   object Setting {
-    implicit class SettingDecorator[T](val setting: Setting[T]) extends AnyVal {
+    extension [T](setting: Setting[T]) {
       def value(using Context): T = setting.valueIn(ctx.settingsState)
       def update(x: T)(using Context): SettingsState = setting.updateIn(ctx.settingsState, x)
       def isDefault(using Context): Boolean = setting.isDefaultIn(ctx.settingsState)

compiler/src/dotty/tools/dotc/core/Contexts.scala

@@ -678,15 +678,15 @@ object Contexts {
   end ops
 
   // TODO: Fix issue when converting ModeChanges and FreshModeChanges to extension givens
-  implicit class ModeChanges(val c: Context) extends AnyVal {
+  extension (c: Context) {
     final def withModeBits(mode: Mode): Context =
       if (mode != c.mode) c.fresh.setMode(mode) else c
 
     final def addMode(mode: Mode): Context = withModeBits(c.mode | mode)
     final def retractMode(mode: Mode): Context = withModeBits(c.mode &~ mode)
   }
 
-  implicit class FreshModeChanges(val c: FreshContext) extends AnyVal {
+  extension (c: FreshContext) {
     final def addMode(mode: Mode): c.type = c.setMode(c.mode | mode)
     final def retractMode(mode: Mode): c.type = c.setMode(c.mode &~ mode)
   }

compiler/src/dotty/tools/dotc/core/Decorators.scala

@@ -28,28 +28,26 @@ object Decorators {
       case s: String => termName(s)
       case n: Name => n.toTermName
 
-  implicit class StringDecorator(val s: String) extends AnyVal {
+  extension (s: String):
     def splitWhere(f: Char => Boolean, doDropIndex: Boolean): Option[(String, String)] = {
       def splitAt(idx: Int, doDropIndex: Boolean): Option[(String, String)] =
         if (idx == -1) None
         else Some((s.take(idx), s.drop(if (doDropIndex) idx + 1 else idx)))
 
       splitAt(s.indexWhere(f), doDropIndex)
     }
-  }
 
   /** Implements a findSymbol method on iterators of Symbols that
    *  works like find but avoids Option, replacing None with NoSymbol.
    */
-  implicit class SymbolIteratorDecorator(val it: Iterator[Symbol]) extends AnyVal {
+  extension (it: Iterator[Symbol]):
     final def findSymbol(p: Symbol => Boolean): Symbol = {
       while (it.hasNext) {
         val sym = it.next()
         if (p(sym)) return sym
       }
       NoSymbol
     }
-  }
 
   final val MaxFilterRecursions = 1000
 
@@ -161,29 +159,27 @@ object Decorators {
     def & (ys: List[T]): List[T] = xs filter (ys contains _)
   }
 
-  given ListOfListDecorator as AnyRef:
-    extension [T, U](xss: List[List[T]]):
-      def nestedMap(f: T => U): List[List[U]] =
-        xss.map(_.map(f))
-      def nestedMapConserve(f: T => U): List[List[U]] =
-        xss.mapconserve(_.mapconserve(f))
-      def nestedZipWithConserve(yss: List[List[U]])(f: (T, U) => T): List[List[T]] =
-        xss.zipWithConserve(yss)((xs, ys) => xs.zipWithConserve(ys)(f))
-    end extension
-
-  implicit class TextToString(val text: Text) extends AnyVal {
+  extension [T, U](xss: List[List[T]]):
+    def nestedMap(f: T => U): List[List[U]] =
+      xss.map(_.map(f))
+    def nestedMapConserve(f: T => U): List[List[U]] =
+      xss.mapconserve(_.mapconserve(f))
+    def nestedZipWithConserve(yss: List[List[U]])(f: (T, U) => T): List[List[T]] =
+      xss.zipWithConserve(yss)((xs, ys) => xs.zipWithConserve(ys)(f))
+  end extension
+
+  extension (text: Text):
     def show(using Context): String = text.mkString(ctx.settings.pageWidth.value, ctx.settings.printLines.value)
-  }
 
   /** Test whether a list of strings representing phases contains
    *  a given phase. See [[config.CompilerCommand#explainAdvanced]] for the
    *  exact meaning of "contains" here.
    */
-  implicit class PhaseListDecorator(val names: List[String]) extends AnyVal {
+   extension (names: List[String]) {
     def containsPhase(phase: Phase): Boolean =
       names.nonEmpty && {
         phase match {
-          case phase: MegaPhase => phase.miniPhases.exists(containsPhase)
+          case phase: MegaPhase => phase.miniPhases.exists(x => names.containsPhase(x))
           case _ =>
             names exists { name =>
               name == "all" || {
@@ -197,7 +193,7 @@ object Decorators {
       }
   }
 
-  implicit class reportDeco[T](x: T) extends AnyVal {
+  extension [T](x: T) {
     def reporting(
         op: WrappedResult[T] ?=> String,
         printer: config.Printers.Printer = config.Printers.default): T = {
@@ -206,7 +202,7 @@ object Decorators {
     }
   }
 
-  implicit class genericDeco[T](val x: T) extends AnyVal {
+  extension [T](x: T) {
     def assertingErrorsReported(using Context): T = {
       assert(ctx.reporter.errorsReported)
       x
@@ -217,7 +213,7 @@ object Decorators {
     }
   }
 
-  implicit class StringInterpolators(val sc: StringContext) extends AnyVal {
+  extension (sc: StringContext) {
     /** General purpose string formatting */
     def i(args: Any*)(using Context): String =
       new StringFormatter(sc).assemble(args)
@@ -235,8 +231,8 @@ object Decorators {
       explained(em(args: _*))
   }
 
-  implicit class ArrayInterpolator[T <: AnyRef](val arr: Array[T]) extends AnyVal {
+  extension [T <: AnyRef](arr: Array[T]):
     def binarySearch(x: T): Int = java.util.Arrays.binarySearch(arr.asInstanceOf[Array[Object]], x)
-  }
+
 }