Use attachment to tag backquoted trees

Author: odersky

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

@@ -142,8 +142,7 @@ trait TreeInfo[T >: Untyped <: Type] { self: Trees.Instance[T] =>
 
   /** Is tree a variable pattern? */
   def isVarPattern(pat: Tree): Boolean = unsplice(pat) match {
-    case x: BackquotedIdent => false
-    case x: Ident => x.name.isVariableName
+    case x: Ident => x.name.isVariableName && !x.isBackquoted
     case _  => false
   }
 

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

@@ -31,7 +31,10 @@ object Trees {
   @sharable var ntrees: Int = 0
 
   /** Property key for trees with documentation strings attached */
-  val DocComment: Property.StickyKey[Comments.Comment] = new Property.StickyKey
+  val DocComment: Property.StickyKey[Comments.Comment] = Property.StickyKey()
+
+  /** Property key for backquoted identifiers and definitions */
+  val Backquoted: Property.StickyKey[Unit] = Property.StickyKey()
 
   /** Trees take a parameter indicating what the type of their `tpe` field
    *  is. Two choices: `Type` or `Untyped`.
@@ -376,15 +379,7 @@ object Trees {
     type ThisTree[-T >: Untyped] = Ident[T]
     def qualifier: Tree[T] = genericEmptyTree
 
-    /** Is this a `BackquotedIdent` ? */
-    def isBackquoted: Boolean = false
-  }
-
-  class BackquotedIdent[-T >: Untyped]private[ast] (name: Name)(implicit @constructorOnly src: SourceFile)
-    extends Ident[T](name) {
-    override def isBackquoted: Boolean = true
-
-    override def toString: String = s"BackquotedIdent($name)"
+    def isBackquoted: Boolean = hasAttachment(Backquoted)
   }
 
   class SearchFailureIdent[-T >: Untyped] private[ast] (name: Name)(implicit @constructorOnly src: SourceFile)
@@ -947,7 +942,6 @@ object Trees {
     type LazyTreeList = Trees.LazyTreeList[T]
 
     type Ident = Trees.Ident[T]
-    type BackquotedIdent = Trees.BackquotedIdent[T]
     type SearchFailureIdent = Trees.SearchFailureIdent[T]
     type Select = Trees.Select[T]
     type SelectWithSig = Trees.SelectWithSig[T]
@@ -1036,9 +1030,6 @@ object Trees {
         postProcess(tree, copied.withSpan(tree.span).withAttachmentsFrom(tree))
 
       def Ident(tree: Tree)(name: Name)(implicit ctx: Context): Ident = tree match {
-        case tree: BackquotedIdent =>
-          if (name == tree.name) tree
-          else finalize(tree, new BackquotedIdent(name)(sourceFile(tree)))
         case tree: Ident if name == tree.name => tree
         case _ => finalize(tree, untpd.Ident(name)(sourceFile(tree)))
       }

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

@@ -299,7 +299,6 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   // ------ Creation methods for untyped only -----------------
 
   def Ident(name: Name)(implicit src: SourceFile): Ident = new Ident(name)
-  def BackquotedIdent(name: Name)(implicit src: SourceFile): BackquotedIdent = new BackquotedIdent(name)
   def SearchFailureIdent(name: Name)(implicit src: SourceFile): SearchFailureIdent = new SearchFailureIdent(name)
   def Select(qualifier: Tree, name: Name)(implicit src: SourceFile): Select = new Select(qualifier, name)
   def SelectWithSig(qualifier: Tree, name: Name, sig: Signature)(implicit src: SourceFile): Select = new SelectWithSig(qualifier, name, sig)

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

@@ -628,9 +628,8 @@ object Parsers {
       makeIdent(in.token, in.offset, ident().toTypeName)
 
     private def makeIdent(tok: Token, offset: Offset, name: Name) = {
-      val tree =
-        if (tok == BACKQUOTED_IDENT) BackquotedIdent(name)
-        else Ident(name)
+      val tree = Ident(name)
+      if (tok == BACKQUOTED_IDENT) tree.pushAttachment(Backquoted, ())
 
       // Make sure that even trees with parsing errors have a offset that is within the offset
       val errorOffset = offset min (in.lastOffset - 1)
@@ -2526,10 +2525,11 @@ object Parsers {
           }
         } else EmptyTree
       lhs match {
-        case (id: BackquotedIdent) :: Nil if id.name.isTermName =>
-          finalizeDef(BackquotedValDef(id.name.asTermName, tpt, rhs), mods, start)
-        case Ident(name: TermName) :: Nil =>
-          finalizeDef(ValDef(name, tpt, rhs), mods, start)
+        case (id @ Ident(name: TermName)) :: Nil =>
+          if (id.isBackquoted)
+            finalizeDef(BackquotedValDef(id.name.asTermName, tpt, rhs), mods, start)
+          else
+            finalizeDef(ValDef(name, tpt, rhs), mods, start)
         case _ =>
           PatDef(mods, lhs, tpt, rhs)
       }

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

@@ -334,24 +334,23 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
     }
 
     tree match {
-      case id: Trees.BackquotedIdent[_] if !homogenizedView =>
-        "`" ~ toText(id.name) ~ "`"
       case id: Trees.SearchFailureIdent[_] =>
         tree.typeOpt match {
           case reason: Implicits.SearchFailureType =>
             toText(id.name) ~ "implicitly[" ~ toText(reason.clarify(reason.expectedType)) ~ "]"
           case _ =>
             toText(id.name)
         }
-      case Ident(name) =>
+      case id @ Ident(name) =>
         val txt = tree.typeOpt match {
           case tp: NamedType if name != nme.WILDCARD =>
             val pre = if (tp.symbol.is(JavaStatic)) tp.prefix.widen else tp.prefix
             toTextPrefix(pre) ~ withPos(selectionString(tp), tree.sourcePos)
           case _ =>
             toText(name)
         }
-        if (name.isTypeName) typeText(txt)
+        if (tree.isBackquoted && !homogenizedView) "`" ~ toText(name) ~ "`"
+        else if (name.isTypeName) typeText(txt)
         else txt
       case tree @ Select(qual, name) =>
         if (!printDebug && tree.hasType && tree.symbol == defn.QuotedType_splice) typeText("${") ~ toTextLocal(qual) ~ typeText("}")

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

@@ -188,8 +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: BackquotedIdent                    => false
-        case x: Ident                              => x.name.isVariableName
+        case x: Ident                              => x.name.isVariableName && !x.isBackquoted
         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 _: BackquotedIdent => Typ(pat.tpe, false)
+    case pat: Ident if pat.isBackquoted => 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

@@ -752,16 +752,15 @@ trait Checking {
         isInfix(sym.owner.linkedClass)
 
     tree.op match {
-      case _: untpd.BackquotedIdent =>
-        ()
-      case Ident(name: Name) =>
+      case id @ Ident(name: Name) =>
         name.toTermName match {
           case name: SimpleName
-          if !name.exists(isOperatorPart) &&
-            !isInfix(meth) &&
-            !meth.maybeOwner.is(Scala2x) &&
-            !infixOKSinceFollowedBy(tree.right) &&
-            ctx.settings.strict.value =>
+          if !id.isBackquoted &&
+             !name.exists(isOperatorPart) &&
+             !isInfix(meth) &&
+             !meth.maybeOwner.is(Scala2x) &&
+             !infixOKSinceFollowedBy(tree.right) &&
+             ctx.settings.strict.value =>
             val (kind, alternative) =
               if (ctx.mode.is(Mode.Type))
                 ("type", (n: Name) => s"prefix syntax $n[...]")