Use new extension syntax in compiler

Author: nicolasstucki

compiler/src/dotty/tools/backend/jvm/BTypesFromSymbols.scala

@@ -121,7 +121,7 @@ class BTypesFromSymbols[I <: DottyBackendInterface](val int: I) extends BTypes {
      * All interfaces implemented by a class, except for those inherited through the superclass.
      * Redundant interfaces are removed unless there is a super call to them.
      */
-    def (sym: Symbol).superInterfaces: List[Symbol] = {
+    extension (sym: Symbol) def superInterfaces: List[Symbol] = {
       val directlyInheritedTraits = sym.directlyInheritedTraits
       val directlyInheritedTraitsSet = directlyInheritedTraits.toSet
       val allBaseClasses = directlyInheritedTraits.iterator.flatMap(_.asClass.baseClasses.drop(1)).toSet
@@ -272,8 +272,9 @@ class BTypesFromSymbols[I <: DottyBackendInterface](val int: I) extends BTypes {
    *   object T { def f { object U } }
    * the owner of U is T, so UModuleClass.isStatic is true. Phase travel does not help here.
    */
-  private def (sym: Symbol).isOriginallyStaticOwner: Boolean =
-    sym.is(PackageClass) || sym.is(ModuleClass) && sym.originalOwner.originalLexicallyEnclosingClass.isOriginallyStaticOwner
+  extension (sym: Symbol):
+    private def isOriginallyStaticOwner: Boolean =
+      sym.is(PackageClass) || sym.is(ModuleClass) && sym.originalOwner.originalLexicallyEnclosingClass.isOriginallyStaticOwner
 
   /**
    * Return the Java modifiers for the given symbol.

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

@@ -333,7 +333,7 @@ object Trees {
     def namedType: NamedType = tpe.asInstanceOf[NamedType]
   }
 
-  def (mdef: untpd.DefTree).mods: untpd.Modifiers = mdef.rawMods
+  extension (mdef: untpd.DefTree) def mods: untpd.Modifiers = mdef.rawMods
 
   abstract class NamedDefTree[-T >: Untyped](implicit @constructorOnly src: SourceFile) extends NameTree[T] with DefTree[T] {
     type ThisTree[-T >: Untyped] <: NamedDefTree[T]

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

@@ -775,7 +775,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   }
 
   /** Is there a subtree of this tree that satisfies predicate `p`? */
-  def (tree: Tree) existsSubTree(p: Tree => Boolean)(implicit ctx: Context): Boolean = {
+  extension (tree: Tree) def existsSubTree(p: Tree => Boolean)(implicit ctx: Context): Boolean = {
     val acc = new UntypedTreeAccumulator[Boolean] {
       def apply(x: Boolean, t: Tree)(implicit ctx: Context) = x || p(t) || foldOver(x, t)
     }

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

@@ -21,10 +21,10 @@ object Decorators {
    *  a simple collective extension.
    */
   implicit object PreNamedString:
-    def (pn: PreName).toTypeName: TypeName = pn match
+    extension (pn: PreName) def toTypeName: TypeName = pn match
       case s: String => typeName(s)
       case n: Name => n.toTypeName
-    def (pn: PreName).toTermName: TermName = pn match
+    extension (pn: PreName) def toTermName: TermName = pn match
       case s: String => termName(s)
       case n: Name => n.toTermName
 

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

@@ -22,7 +22,7 @@ object Flags {
 
   type Flag = opaques.Flag
 
-  extension on (x: FlagSet) {
+  extension (x: FlagSet) {
 
     def bits: Long = opaques.toBits(x)
 

compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala

@@ -727,7 +727,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
   }
 
   /** Print modifiers from symbols if tree has type, overriding the behavior in Trees. */
-  def (mdef: untpd.DefTree).mods: untpd.Modifiers =
+  extension (mdef: untpd.DefTree) def mods: untpd.Modifiers =
     if mdef.hasType then Modifiers(mdef.symbol) else mdef.rawMods
 
   private def Modifiers(sym: Symbol): Modifiers = untpd.Modifiers(

compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala

@@ -260,9 +260,10 @@ class ExtractSemanticDB extends Phase:
 
         case _ => None
 
-      private inline def (tpe: Types.Type) isAnnotatedByUnchecked(using Context) = tpe match
-        case Types.AnnotatedType(_, annot) => annot.symbol == defn.UncheckedAnnot
-        case _                             => false
+      extension (tpe: Types.Type):
+        private inline def isAnnotatedByUnchecked(using Context) = tpe match
+          case Types.AnnotatedType(_, annot) => annot.symbol == defn.UncheckedAnnot
+          case _                             => false
 
       def collectPats(pat: Tree): List[Tree] =
 
@@ -282,11 +283,12 @@ class ExtractSemanticDB extends Phase:
 
     end PatternValDef
 
-    private def (tree: NamedDefTree) adjustedNameSpan(using Context): Span =
-      if tree.span.exists && tree.name.isAnonymousFunctionName || tree.name.isAnonymousClassName
-        Span(tree.span.point)
-      else
-        tree.nameSpan
+    extension (tree: NamedDefTree):
+      private def adjustedNameSpan(using Context): Span =
+        if tree.span.exists && tree.name.isAnonymousFunctionName || tree.name.isAnonymousClassName
+          Span(tree.span.point)
+        else
+          tree.nameSpan
 
     /** Add semanticdb name of the given symbol to string builder */
     private def addSymName(b: StringBuilder, sym: Symbol)(using Context): Unit =
@@ -496,12 +498,14 @@ class ExtractSemanticDB extends Phase:
       val start = if idx >= 0 then idx else span.start
       Span(start, start + sym.name.show.length, start)
 
-    private inline def (list: List[List[ValDef]]) isSingleArg = list match
-      case (_::Nil)::Nil => true
-      case _             => false
+    extension (list: List[List[ValDef]]):
+      private  inline def isSingleArg = list match
+        case (_::Nil)::Nil => true
+        case _             => false
 
-    private def (tree: DefDef) isSetterDef(using Context): Boolean =
-      tree.name.isSetterName && tree.mods.is(Accessor) && tree.vparamss.isSingleArg
+    extension (tree: DefDef):
+      private def isSetterDef(using Context): Boolean =
+        tree.name.isSetterName && tree.mods.is(Accessor) && tree.vparamss.isSingleArg
 
     private def findGetters(ctorParams: Set[Names.TermName], body: List[Tree])(using Context): Map[Names.TermName, ValDef] =
       if ctorParams.isEmpty || body.isEmpty then
@@ -525,26 +529,27 @@ class ExtractSemanticDB extends Phase:
         else limit
       Span(start max limit, end)
 
-    private extension on (span: Span):
-      def hasLength: Boolean = span.start != span.end
-      def zeroLength: Boolean = span.start == span.end
+    extension (span: Span):
+      private def hasLength: Boolean = span.start != span.end
+      private def zeroLength: Boolean = span.start == span.end
 
     /**Consume head while not an import statement.
      * Returns the rest of the list after the first import, or else the empty list
      */
-    @tailrec
-    private def (body: List[Tree]) foreachUntilImport(op: Tree => Unit): List[Tree] = body match
-      case ((_: Import) :: rest) => rest
-      case stat :: rest =>
-        op(stat)
-        rest.foreachUntilImport(op)
-      case Nil => Nil
-
-    private def (sym: Symbol) adjustIfCtorTyparam(using Context) =
-      if sym.isType && sym.owner.exists && sym.owner.isConstructor
-        matchingMemberType(sym, sym.owner.owner)
-      else
-        sym
+    extension (body: List[Tree]):
+      @tailrec private def foreachUntilImport(op: Tree => Unit): List[Tree] = body match
+        case ((_: Import) :: rest) => rest
+        case stat :: rest =>
+          op(stat)
+          rest.foreachUntilImport(op)
+        case Nil => Nil
+
+    extension (sym: Symbol):
+      private def adjustIfCtorTyparam(using Context) =
+        if sym.isType && sym.owner.exists && sym.owner.isConstructor
+          matchingMemberType(sym, sym.owner.owner)
+        else
+          sym
 
     private inline def matchingMemberType(ctorTypeParam: Symbol, classSym: Symbol)(using Context) =
       classSym.info.member(ctorTypeParam.name).symbol

compiler/src/dotty/tools/dotc/semanticdb/Scala3.scala

@@ -105,7 +105,7 @@ object Scala3:
 
       val setterName = sym.name.toTermName.setterName
 
-      inline def (t: Type) matchingType = t.paramInfoss match
+      extension (t: Type) inline def matchingType = t.paramInfoss match
         case (arg::Nil)::Nil => t.resultType == defn.UnitType && arg == sym.info
         case _               => false
 
@@ -139,9 +139,10 @@ object Scala3:
 
   end LocalSymbol
 
-  private inline def (char: Char) isGlobalTerminal = (char: @switch) match
-    case '/' | '.' | '#' | ']' | ')' => true
-    case _                           => false
+  extension (char: Char):
+    private inline def isGlobalTerminal = (char: @switch) match
+      case '/' | '.' | '#' | ']' | ')' => true
+      case _                           => false
 
   extension StringOps on (symbol: String):
 

compiler/src/dotty/tools/dotc/semanticdb/Tools.scala

@@ -137,4 +137,5 @@ object Tools:
     sb.append(if occ.role.isReference then " -> " else " <- ").append(occ.symbol).nl
   end processOccurrence
 
-  private inline def (sb: StringBuilder) nl = sb.append(System.lineSeparator)
+  extension (sb: StringBuilder):
+    private inline def nl = sb.append(System.lineSeparator)

compiler/src/dotty/tools/dotc/transform/ExplicitOuter.scala

@@ -323,7 +323,7 @@ object ExplicitOuter {
       tpe
   }
 
-  def (sym: Symbol).isOuterParamAccessor(using Context): Boolean =
+  extension (sym: Symbol) def isOuterParamAccessor(using Context): Boolean =
     sym.is(ParamAccessor) && sym.name == nme.OUTER
 
   def outer(implicit ctx: Context): OuterOps = new OuterOps(ctx)