Move isBackquoted to TreeInfo

Author: odersky

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

@@ -310,7 +310,7 @@ object desugar {
    *  ```
    */
   def transformQuotedPatternName(tree: ValOrDefDef)(implicit ctx: Context): ValOrDefDef = {
-    if (ctx.mode.is(Mode.QuotedPattern) && !tree.isBackquoted && tree.name != nme.ANON_FUN && tree.name.startsWith("$")) {
+    if (ctx.mode.is(Mode.QuotedPattern) && !isBackquoted(tree) && tree.name != nme.ANON_FUN && tree.name.startsWith("$")) {
       val mods = tree.mods.withAddedAnnotation(New(ref(defn.InternalQuoted_patternBindHoleAnnot.typeRef)).withSpan(tree.span))
       tree.withMods(mods)
     } else tree
@@ -1478,7 +1478,7 @@ object desugar {
         // This is a deliberate departure from scalac, where StringContext is not rooted (See #4732)
         Apply(Select(Apply(scalaDot(nme.StringContext), strs), id), elems)
       case PostfixOp(t, op) =>
-        if ((ctx.mode is Mode.Type) && !op.isBackquoted && op.name == tpnme.raw.STAR) {
+        if ((ctx.mode is Mode.Type) && !isBackquoted(op) && op.name == tpnme.raw.STAR) {
           val seqType = if (ctx.compilationUnit.isJava) defn.ArrayType else defn.SeqType
           Annotated(
             AppliedTypeTree(ref(seqType), t),

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

@@ -140,9 +140,12 @@ trait TreeInfo[T >: Untyped <: Type] { self: Trees.Instance[T] =>
     case _ => false
   }
 
+  /** Is tree a backquoted identifier or definition */
+  def isBackquoted(tree: Tree): Boolean = tree.hasAttachment(Backquoted)
+
   /** Is tree a variable pattern? */
   def isVarPattern(pat: Tree): Boolean = unsplice(pat) match {
-    case x: Ident => x.name.isVariableName && !x.isBackquoted
+    case x: Ident => x.name.isVariableName && !isBackquoted(x)
     case _  => false
   }
 

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -408,9 +408,9 @@ object Parsers {
     */
     def convertToParam(tree: Tree, expected: String = "formal parameter"): ValDef = tree match {
       case id @ Ident(name) =>
-        makeParameter(name.asTermName, TypeTree(), isBackquoted = id.isBackquoted).withSpan(tree.span)
+        makeParameter(name.asTermName, TypeTree(), isBackquoted = isBackquoted(id)).withSpan(tree.span)
       case Typed(id @ Ident(name), tpt) =>
-        makeParameter(name.asTermName, tpt, isBackquoted = id.isBackquoted).withSpan(tree.span)
+        makeParameter(name.asTermName, tpt, isBackquoted = isBackquoted(id)).withSpan(tree.span)
       case Typed(Splice(Ident(name)), tpt) =>
         makeParameter(("$" + name).toTermName, tpt).withSpan(tree.span)
       case _ =>
@@ -2526,7 +2526,7 @@ object Parsers {
         } else EmptyTree
       lhs match {
         case (id @ Ident(name: TermName)) :: Nil =>
-          if (id.isBackquoted)
+          if (isBackquoted(id))
             finalizeDef(BackquotedValDef(id.name.asTermName, tpt, rhs), mods, start)
           else
             finalizeDef(ValDef(name, tpt, rhs), mods, start)
@@ -2606,7 +2606,7 @@ object Parsers {
             expr()
           }
 
-        if (ident.isBackquoted) finalizeDef(BackquotedDefDef(ident.name.asTermName, tparams, vparamss, tpt, rhs), mods1, start)
+        if (isBackquoted(ident)) finalizeDef(BackquotedDefDef(ident.name.asTermName, tparams, vparamss, tpt, rhs), mods1, start)
         else finalizeDef(DefDef(ident.name.asTermName, tparams, vparamss, tpt, rhs), mods1, start)
       }
     }

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

@@ -349,7 +349,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
           case _ =>
             toText(name)
         }
-        if (tree.isBackquoted && !homogenizedView) "`" ~ toText(name) ~ "`"
+        if (isBackquoted(tree) && !homogenizedView) "`" ~ toText(name) ~ "`"
         else if (name.isTypeName) typeText(txt)
         else txt
       case tree @ Select(qual, name) =>

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

@@ -188,7 +188,7 @@ object PatternMatcher {
         case Typed(_, tpt) if tpt.tpe.isRepeatedParam => true
         case Bind(nme.WILDCARD, WildcardPattern()) => true // don't skip when binding an interesting symbol!
         case t if isWildcardArg(t)                 => true
-        case x: Ident                              => x.name.isVariableName && !x.isBackquoted
+        case x: Ident                              => x.name.isVariableName && !isBackquoted(x)
         case Alternative(ps)                       => ps.forall(unapply)
         case EmptyTree                             => true
         case _                                     => false

compiler/src/dotty/tools/dotc/transform/patmat/Space.scala

@@ -330,7 +330,7 @@ class SpaceEngine(implicit ctx: Context) extends SpaceLogic {
         Typ(c.value.asInstanceOf[Symbol].termRef, false)
       else
         Typ(ConstantType(c), false)
-    case pat: Ident if pat.isBackquoted => Typ(pat.tpe, false)
+    case pat: Ident if isBackquoted(pat) => Typ(pat.tpe, false)
     case Ident(nme.WILDCARD) =>
       Or(Typ(pat.tpe.stripAnnots, false) :: nullSpace :: Nil)
     case Ident(_) | Select(_, _) =>

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

@@ -755,7 +755,7 @@ trait Checking {
       case id @ Ident(name: Name) =>
         name.toTermName match {
           case name: SimpleName
-          if !id.isBackquoted &&
+          if !untpd.isBackquoted(id) &&
              !name.exists(isOperatorPart) &&
              !isInfix(meth) &&
              !meth.maybeOwner.is(Scala2x) &&