Merge pull request #3334 from dotty-staging/change-transform-phases-2

Eliminate AnnotationTransformer

Author: smarter

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

@@ -1,6 +1,7 @@
 package dotty.tools.backend.jvm
 
 import dotty.tools.dotc.ast.tpd
+import dotty.tools.dotc.ast.Trees
 import dotty.tools.dotc
 import dotty.tools.dotc.backend.jvm.DottyPrimitives
 import dotty.tools.dotc.core.Flags.FlagSet
@@ -231,11 +232,16 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
     annot.atp.typeSymbol.getAnnotation(AnnotationRetentionAttr).
       flatMap(_.argumentConstant(0).map(_.symbolValue)).getOrElse(AnnotationRetentionClassAttr)
 
+  private def normalizeArgument(arg: Tree): Tree = arg match {
+    case Trees.NamedArg(_, arg1) => normalizeArgument(arg1)
+    case Trees.Typed(arg1, _) => normalizeArgument(arg1)
+    case _ => arg
+  }
+
   private def emitArgument(av:   AnnotationVisitor,
                            name: String,
                            arg:  Tree, bcodeStore: BCodeHelpers)(innerClasesStore: bcodeStore.BCInnerClassGen): Unit = {
-    (arg: @unchecked) match {
-
+    (normalizeArgument(arg): @unchecked) match {
       case Literal(const @ Constant(_)) =>
         const.tag match {
           case BooleanTag | ByteTag | ShortTag | CharTag | IntTag | LongTag | FloatTag | DoubleTag => av.visit(name, const.value)
@@ -251,16 +257,18 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
       case t: TypeApply if (t.fun.symbol == Predef_classOf) =>
         av.visit(name, t.args.head.tpe.classSymbol.denot.info.toTypeKind(bcodeStore)(innerClasesStore).toASMType)
       case t: tpd.Select =>
-        if (t.symbol.denot.is(Flags.Enum)) {
+        if (t.symbol.denot.owner.is(Flags.Enum)) {
           val edesc = innerClasesStore.typeDescriptor(t.tpe.asInstanceOf[bcodeStore.int.Type]) // the class descriptor of the enumeration class.
           val evalue = t.symbol.name.mangledString // value the actual enumeration value.
           av.visitEnum(name, edesc, evalue)
         } else {
-          assert(toDenot(t.symbol).name.is(DefaultGetterName), toDenot(t.symbol).name.debugString) // this should be default getter. do not emmit.
+            // println(i"not an enum: ${t.symbol} / ${t.symbol.denot.owner} / ${t.symbol.denot.owner.isTerm} / ${t.symbol.denot.owner.flags}")
+            assert(toDenot(t.symbol).name.is(DefaultGetterName),
+              s"${toDenot(t.symbol).name.debugString}") // this should be default getter. do not emmit.
         }
       case t: SeqLiteral =>
         val arrAnnotV: AnnotationVisitor = av.visitArray(name)
-        for(arg <- t.elems) { emitArgument(arrAnnotV, null, arg, bcodeStore)(innerClasesStore) }
+        for (arg <- t.elems) { emitArgument(arrAnnotV, null, arg, bcodeStore)(innerClasesStore) }
         arrAnnotV.visitEnd()
 
       case Apply(fun, args) if fun.symbol == defn.ArrayClass.primaryConstructor ||
@@ -272,11 +280,15 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
           fun.asInstanceOf[Apply].args
         } else args
 
-        val flatArgs = actualArgs.flatMap {
-          case t: tpd.SeqLiteral => t.elems
-          case e => List(e)
+        val flatArgs = actualArgs.flatMap { arg =>
+          normalizeArgument(arg) match {
+            case t: tpd.SeqLiteral => t.elems
+            case e => List(e)
+          }
+        }
+        for(arg <- flatArgs) {
+          emitArgument(arrAnnotV, null, arg, bcodeStore)(innerClasesStore)
         }
-        for(arg <- flatArgs) { emitArgument(arrAnnotV, null, arg, bcodeStore)(innerClasesStore) }
         arrAnnotV.visitEnd()
 /*
       case sb @ ScalaSigBytes(bytes) =>

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

@@ -506,7 +506,7 @@ object Flags {
     Accessor | AbsOverride | Stable | Captured | Synchronized
 
   /** Flags that can apply to a module class */
-  final val RetainedModuleClassFlags: FlagSet = RetainedModuleValAndClassFlags | ImplClass
+  final val RetainedModuleClassFlags: FlagSet = RetainedModuleValAndClassFlags | ImplClass | Enum
 
   /** Packages and package classes always have these flags set */
   final val PackageCreationFlags =

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

@@ -601,7 +601,7 @@ object JavaParsers {
       atPos(cdef.pos) {
         assert(cdef.pos.exists)
         ModuleDef(cdef.name.toTermName,
-          makeTemplate(List(), statics, List(), false)).withMods((cdef.mods & (Flags.AccessFlags | Flags.JavaDefined)).toTermFlags)
+          makeTemplate(List(), statics, List(), false)).withMods((cdef.mods & Flags.RetainedModuleClassFlags).toTermFlags)
       }
 
     def importCompanionObject(cdef: TypeDef): Tree =

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

@@ -5,7 +5,7 @@ import core._
 import Names._
 import StdNames.nme
 import Types._
-import dotty.tools.dotc.transform.TreeTransforms.{AnnotationTransformer, TransformerInfo, MiniPhaseTransform, TreeTransformer}
+import dotty.tools.dotc.transform.TreeTransforms.{TransformerInfo, MiniPhaseTransform, TreeTransformer}
 import ast.Trees._
 import Flags._
 import Contexts.Context
@@ -25,7 +25,7 @@ import TypeUtils._
 /** A transformer that removes repeated parameters (T*) from all types, replacing
  *  them with Seq types.
  */
-class ElimRepeated extends MiniPhaseTransform with InfoTransformer with AnnotationTransformer { thisTransformer =>
+class ElimRepeated extends MiniPhaseTransform with InfoTransformer { thisTransformer =>
   import ast.tpd._
 
   override def phaseName = "elimRepeated"
@@ -74,9 +74,10 @@ class ElimRepeated extends MiniPhaseTransform with InfoTransformer with Annotati
     transformTypeOfTree(tree)
 
   override def transformApply(tree: Apply)(implicit ctx: Context, info: TransformerInfo): Tree = {
-    val formals = (tree.fun.tpe.widen: @unchecked) match {
-      case mt: MethodType => mt.paramInfos
-    }
+    val formals =
+      ctx.atPhase(thisTransformer) { implicit ctx =>
+        tree.fun.tpe.widen.asInstanceOf[MethodType].paramInfos
+      }
     val args1 = tree.args.zipWithConserve(formals) { (arg, formal) =>
       arg match {
         case arg: Typed if isWildcardStarArg(arg) =>
@@ -111,13 +112,13 @@ class ElimRepeated extends MiniPhaseTransform with InfoTransformer with Annotati
   /** If method overrides a Java varargs method, add a varargs bridge.
    *  Also transform trees inside method annotation
    */
-  override def transformDefDef(tree: DefDef)(implicit ctx: Context, info: TransformerInfo): Tree = {
-    assert(ctx.phase == thisTransformer)
-    if (tree.symbol.info.isVarArgsMethod && overridesJava(tree.symbol))
-      addVarArgsBridge(tree)
-    else
-      tree
-  }
+  override def transformDefDef(tree: DefDef)(implicit ctx: Context, info: TransformerInfo): Tree =
+    ctx.atPhase(thisTransformer) { implicit ctx =>
+      if (tree.symbol.info.isVarArgsMethod && overridesJava(tree.symbol))
+        addVarArgsBridge(tree)
+      else
+        tree
+    }
 
   /** Add a Java varargs bridge
    *  @param  ddef  the original method definition which is assumed to override

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

@@ -35,7 +35,7 @@ import StdNames._
  *          if (true) A else B    ==> A
  *          if (false) A else B   ==> B
  */
-class FirstTransform extends MiniPhaseTransform with InfoTransformer with AnnotationTransformer { thisTransformer =>
+class FirstTransform extends MiniPhaseTransform with InfoTransformer { thisTransformer =>
   import ast.tpd._
 
   override def phaseName = "firstTransform"

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

@@ -61,7 +61,8 @@ object TreeTransforms {
 
     def phase: MiniPhase
 
-    def treeTransformPhase: Phase = phase.next
+    /** The phase at which the tree is transformed */
+    final def treeTransformPhase: Phase = phase.next
 
     val cpy: TypedTreeCopier = cpyBetweenPhases
 
@@ -173,30 +174,6 @@ object TreeTransforms {
     def phase = this
  }
 
-  /** A helper trait to transform annotations on MemberDefs */
-  trait AnnotationTransformer extends MiniPhaseTransform with DenotTransformer {
-
-    val annotationTransformer = mkTreeTransformer
-    override final def treeTransformPhase = this
-      // need to run at own phase because otherwise we get ahead of ourselves in transforming denotations
-
-    abstract override def transform(ref: SingleDenotation)(implicit ctx: Context): SingleDenotation =
-      super.transform(ref) match {
-        case ref1: SymDenotation if ref1.symbol.isDefinedInCurrentRun =>
-          val annots = ref1.annotations
-          val annotTrees = annots.map(_.tree)
-          val annotTrees1 = annotTrees.mapConserve(annotationTransformer.macroTransform)
-          if (annotTrees eq annotTrees1) ref1
-          else {
-            val derivedAnnots = (annots, annotTrees1).zipped.map((annot, annotTree1) =>
-              annot.derivedAnnotation(annotTree1))
-            ref1.copySymDenotation(annotations = derivedAnnots).copyCaches(ref1, ctx.phase.next)
-          }
-        case ref1 =>
-          ref1
-      }
-  }
-
   private class NoTreeTransform extends TreeTransform {
     def phase = unsupported("phase")
   }