Make mods an extension method

Author: odersky

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

@@ -8,6 +8,7 @@ import core.Contexts.Context
 import core.Decorators._
 import core.Flags.{JavaDefined, Extension}
 import core.StdNames.nme
+import ast.Trees.mods
 import annotation.constructorOnly
 import annotation.internal.sharable
 import reporting.Reporter

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

@@ -333,6 +333,8 @@ object Trees {
     def namedType: NamedType = tpe.asInstanceOf[NamedType]
   }
 
+  def (mdef: untpd.DefTree).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

@@ -512,12 +512,6 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
 
 // ----- Accessing modifiers ----------------------------------------------------
 
-  abstract class ModsDecorator { def mods: Modifiers }
-
-  implicit class modsDeco(val mdef: DefTree)(implicit ctx: Context) {
-    def mods: Modifiers = mdef.rawMods
-  }
-
 // --------- Copier/Transformer/Accumulator classes for untyped trees -----
 
   override val cpy: UntypedTreeCopier = UntypedTreeCopier()

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

@@ -279,7 +279,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
   }
 
   protected def toTextCore[T >: Untyped](tree: Tree[T]): Text = {
-    import untpd.{modsDeco => _, _}
+    import untpd._
 
     def isLocalThis(tree: Tree) = tree.typeOpt match {
       case tp: ThisType => tp.cls == ctx.owner.enclosingClass
@@ -647,7 +647,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
   }
 
   override def toText[T >: Untyped](tree: Tree[T]): Text = controlled {
-    import untpd.{modsDeco => _, _}
+    import untpd._
 
     var txt = toTextCore(tree)
 
@@ -722,11 +722,9 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
     }
   }
 
-  /** Print modifiers from symbols if tree has type, overriding the untpd behavior. */
-  private implicit def modsDeco(mdef: untpd.DefTree): untpd.ModsDecorator =
-    new untpd.ModsDecorator {
-      def mods = if (mdef.hasType) Modifiers(mdef.symbol) else mdef.rawMods
-    }
+  /** Print modifiers from symbols if tree has type, overriding the behavior in Trees. */
+  def (mdef: untpd.DefTree).mods: untpd.Modifiers =
+    if mdef.hasType then Modifiers(mdef.symbol) else mdef.rawMods
 
   private def Modifiers(sym: Symbol): Modifiers = untpd.Modifiers(
     sym.flags & (if (sym.isType) ModifierFlags | VarianceFlags else ModifierFlags),
@@ -770,7 +768,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
     vparamss.foldLeft(leading)((txt, params) => txt ~ paramsText(params))
 
   protected def valDefToText[T >: Untyped](tree: ValDef[T]): Text = {
-    import untpd.{modsDeco => _}
+    import untpd._
     dclTextOr(tree) {
       modText(tree.mods, tree.symbol, keywordStr(if (tree.mods.is(Mutable)) "var" else "val"), isType = false) ~~
         valDefText(nameIdText(tree)) ~ optAscription(tree.tpt) ~
@@ -784,7 +782,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         ~ toText(params, ", ") ~ ")"
 
   protected def defDefToText[T >: Untyped](tree: DefDef[T]): Text = {
-    import untpd.{modsDeco => _}
+    import untpd._
     dclTextOr(tree) {
       val defKeyword = modText(tree.mods, tree.symbol, keywordStr("def"), isType = false)
       val isExtension = tree.hasType && tree.symbol.is(Extension)

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

@@ -5,6 +5,7 @@ package semanticdb
 import core._
 import Phases._
 import ast.tpd._
+import ast.Trees.mods
 import Contexts._
 import Symbols._
 import Flags._

compiler/src/dotty/tools/dotc/typer/Checking.scala

@@ -1111,7 +1111,6 @@ trait Checking {
    *  2. Check that case class `enum` cases do not extend java.lang.Enum.
    */
   def checkEnum(cdef: untpd.TypeDef, cls: Symbol, firstParent: Symbol)(using Context): Unit = {
-    import untpd.modsDeco
     def isEnumAnonCls =
       cls.isAnonymousClass &&
       cls.owner.isTerm &&

compiler/src/dotty/tools/dotc/typer/Namer.scala

@@ -854,7 +854,7 @@ class Namer { typer: Typer =>
     protected def addAnnotations(sym: Symbol): Unit = original match {
       case original: untpd.MemberDef =>
         lazy val annotCtx = annotContext(original, sym)
-        for (annotTree <- untpd.modsDeco(original).mods.annotations) {
+        for (annotTree <- original.mods.annotations) {
           val cls = typedAheadAnnotationClass(annotTree)(annotCtx)
           if (cls eq sym)
             ctx.error("An annotation class cannot be annotated with iself", annotTree.sourcePos)

compiler/src/dotty/tools/dotc/typer/Nullables.scala

@@ -14,6 +14,7 @@ import NullOpsDecorator._
 import collection.mutable
 import config.Printers.nullables
 import ast.{tpd, untpd}
+import ast.Trees.mods
 
 /** Operations for implementing a flow analysis for nullability */
 object Nullables:

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -1832,7 +1832,7 @@ class Typer extends Namer
     sym.annotations.foreach(_.ensureCompleted)
     lazy val annotCtx = annotContext(mdef, sym)
     // necessary in order to mark the typed ahead annotations as definitely typed:
-    for (annot <- untpd.modsDeco(mdef).mods.annotations)
+    for (annot <- mdef.mods.annotations)
       checkAnnotApplicable(typedAnnotation(annot)(using annotCtx), sym)
   }
 

compiler/test/dotty/tools/dotc/parsing/ModifiersParsingTest.scala

@@ -5,7 +5,7 @@ package parsing
 import org.junit.Test
 import org.junit.Assert._
 
-import ast.untpd.modsDeco
+import ast.Trees.mods
 import ast.untpd._
 import ast.{ Trees => d }
 import Parsers.Parser