Use attachment for backquoted TypeDef

Author: nicolasstucki

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

@@ -769,13 +769,7 @@ object Trees {
     /** Is this a definition of a class? */
     def isClassDef: Boolean = rhs.isInstanceOf[Template[_]]
 
-    def isBackquoted: Boolean = false
-  }
-
-  class BackquotedTypeDef[-T >: Untyped] private[ast] (name: TypeName, rhs: Tree[T])(implicit @constructorOnly src: SourceFile)
-    extends TypeDef[T](name, rhs) {
-    override def isBackquoted: Boolean = true
-    override def productPrefix: String = "BackquotedTypeDef"
+    def isBackquoted: Boolean = hasAttachment(Backquoted)
   }
 
   /** extends parents { self => body }
@@ -990,7 +984,6 @@ object Trees {
     type ValDef = Trees.ValDef[T]
     type DefDef = Trees.DefDef[T]
     type TypeDef = Trees.TypeDef[T]
-    type BackquotedTypeDef = Trees.BackquotedTypeDef[T]
     type Template = Trees.Template[T]
     type Import = Trees.Import[T]
     type PackageDef = Trees.PackageDef[T]

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

@@ -339,7 +339,6 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   def ValDef(name: TermName, tpt: Tree, rhs: LazyTree)(implicit src: SourceFile): ValDef = new ValDef(name, tpt, rhs)
   def DefDef(name: TermName, tparams: List[TypeDef], vparamss: List[List[ValDef]], tpt: Tree, rhs: LazyTree)(implicit src: SourceFile): DefDef = new DefDef(name, tparams, vparamss, tpt, rhs)
   def TypeDef(name: TypeName, rhs: Tree)(implicit src: SourceFile): TypeDef = new TypeDef(name, rhs)
-  def BackquotedTypeDef(name: TypeName, rhs: Tree)(implicit src: SourceFile): TypeDef = new BackquotedTypeDef(name, rhs)
   def Template(constr: DefDef, parents: List[Tree], derived: List[Tree], self: ValDef, body: LazyTreeList)(implicit src: SourceFile): Template =
     if (derived.isEmpty) new Template(constr, parents, self, body)
     else new DerivingTemplate(constr, parents ++ derived, self, body, derived.length)

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

@@ -2647,9 +2647,9 @@ object Parsers {
         val tparams = typeParamClauseOpt(ParamOwner.Type)
         def makeTypeDef(rhs: Tree): Tree = {
           val rhs1 = lambdaAbstract(tparams, rhs)
-          val tdef =
-            if (nameIdent.isBackquoted) BackquotedTypeDef(nameIdent.name.toTypeName, rhs1)
-            else TypeDef(nameIdent.name.toTypeName, rhs1)
+          val tdef = TypeDef(nameIdent.name.toTypeName, rhs1)
+          if (nameIdent.isBackquoted)
+            tdef.pushAttachment(Backquoted, ())
           finalizeDef(tdef, mods, start)
         }
         in.token match {