AnnotationTransformer now also transforms types

Required as gettersAndSetters ignores modifiers
 in tree and uses ones in the type instead.
This means that gettersAndSetters carries over
modifiers from type to tree and this one violates postconditions.

Author: DarkDimius

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

@@ -3,7 +3,7 @@ package transform
 
 import core._
 import Names._
-import TreeTransforms.{TransformerInfo, MiniPhaseTransform, TreeTransformer}
+import dotty.tools.dotc.transform.TreeTransforms.{AnnotationTransformer, TransformerInfo, MiniPhaseTransform, TreeTransformer}
 import ast.Trees._
 import Flags._
 import Types._
@@ -12,6 +12,8 @@ import Contexts.Context
 import Symbols._
 import SymDenotations._
 import Decorators._
+import dotty.tools.dotc.core.Annotations.ConcreteAnnotation
+import dotty.tools.dotc.core.Denotations.SingleDenotation
 import scala.collection.mutable
 import DenotTransformers._
 import typer.Checking
@@ -27,10 +29,13 @@ import NameOps._
  *   - checks the bounds of AppliedTypeTrees
  *   - stubs out native methods
  */
-class FirstTransform extends MiniPhaseTransform with IdentityDenotTransformer { thisTransformer =>
+class FirstTransform extends MiniPhaseTransform with IdentityDenotTransformer with AnnotationTransformer { thisTransformer =>
   import ast.tpd._
 
-  override def phaseName = "companions"
+  override def phaseName = "firstTransform"
+
+
+  def transformInfo(tp: Type, sym: Symbol)(implicit ctx: Context): Type = tp
 
   override def checkPostCondition(tree: Tree)(implicit ctx: Context): Unit = tree match {
     case Select(qual, _) if tree.symbol.exists =>
@@ -82,13 +87,16 @@ class FirstTransform extends MiniPhaseTransform with IdentityDenotTransformer {
     addMissingCompanions(reorder(stats))
   }
 
-  override def transformDefDef(ddef: DefDef)(implicit ctx: Context, info: TransformerInfo) =
-    if (ddef.symbol.hasAnnotation(defn.NativeAnnot)) {
-      ddef.symbol.resetFlag(Deferred)
-      DefDef(ddef.symbol.asTerm,
-        _ => ref(defn.Sys_error).withPos(ddef.pos)
-          .appliedTo(Literal(Constant("native method stub"))))
-    } else ddef
+  override def transformDefDef(ddef: DefDef)(implicit ctx: Context, info: TransformerInfo) = {
+    val r =
+     if (ddef.symbol.hasAnnotation(defn.NativeAnnot)) {
+        ddef.symbol.resetFlag(Deferred)
+        DefDef(ddef.symbol.asTerm,
+          _ => ref(defn.Sys_error).withPos(ddef.pos)
+            .appliedTo(Literal(Constant("native method stub"))))
+      } else ddef
+    transformAnnotations(r)
+  }
 
   override def transformStats(trees: List[Tree])(implicit ctx: Context, info: TransformerInfo): List[Tree] =
     ast.Trees.flatten(reorderAndComplete(trees)(ctx.withPhase(thisTransformer.next)))
@@ -107,6 +115,8 @@ class FirstTransform extends MiniPhaseTransform with IdentityDenotTransformer {
     case _ => normalizeType(tree)
   }
 
+
+
   override def transformSelect(tree: Select)(implicit ctx: Context, info: TransformerInfo) =
     normalizeType {
       val qual = tree.qualifier

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

@@ -2,8 +2,12 @@ package dotty.tools.dotc
 package transform
 
 import dotty.tools.dotc.ast.tpd
+import dotty.tools.dotc.core.Annotations.ConcreteAnnotation
 import dotty.tools.dotc.core.Contexts.Context
+import dotty.tools.dotc.core.DenotTransformers.{InfoTransformer, DenotTransformer}
+import dotty.tools.dotc.core.Denotations.SingleDenotation
 import dotty.tools.dotc.core.Phases.Phase
+import dotty.tools.dotc.core.SymDenotations.SymDenotation
 import dotty.tools.dotc.core.Symbols.Symbol
 import dotty.tools.dotc.core.Flags.PackageVal
 import dotty.tools.dotc.typer.Mode
@@ -169,10 +173,24 @@ object TreeTransforms {
  }
 
   /** A helper trait to transform annotations on MemberDefs */
-  trait AnnotationTransformer extends MiniPhaseTransform {
+  trait AnnotationTransformer extends MiniPhaseTransform with InfoTransformer {
 
     val annotationTransformer = mkTreeTransformer
 
+    override def transform(ref: SingleDenotation)(implicit ctx: Context): SingleDenotation = {
+      val info1 = transformInfo(ref.info, ref.symbol)
+
+      ref match {
+        case ref: SymDenotation =>
+          val annotTrees = ref.annotations.map(_.tree)
+          val annotTrees1 = annotTrees.mapConserve(annotationTransformer.transform)
+          val annots1 = if(annotTrees eq annotTrees1) ref.annotations else annotTrees1.map(new ConcreteAnnotation(_))
+          if ((info1 eq ref.info) && (annots1 eq ref.annotations)) ref
+          else ref.copySymDenotation(info = info1, annotations = annots1)
+        case _ => if (info1 eq ref.info) ref else ref.derivedSingleDenotation(ref.symbol, info1)
+      }
+    }
+
     def transformAnnotations(tree: MemberDef)(implicit ctx: Context): MemberDef ={
       val newAnnots = tree.mods.annotations.mapConserve(annotationTransformer.transform)
       if (newAnnots eq tree.mods.annotations) tree