Remove dead annotation typing code

Annotations are checked by completing them. No need to type modifiers
in Typer at all.

Author: odersky

src/dotty/tools/dotc/core/SymDenotations.scala

@@ -265,6 +265,10 @@ object SymDenotations {
     /** Make sure this denotation is completed */
     final def ensureCompleted()(implicit ctx: Context): Unit = info
 
+    /** Make sure all annotations of this symbol are full computed */
+    final def ensureAnnotationsCompleted()(implicit ctx: Context): Unit = 
+      annotations.foreach(_.tree)
+
     /** The symbols defined in this class or object.
      *  Careful! This does not force the type, so is compilation order dependent.
      *  This method should be used only in the following circumstances:

src/dotty/tools/dotc/typer/ReTyper.scala

@@ -72,10 +72,6 @@ class ReTyper extends Typer {
   override def tryInsertApplyOrImplicit(tree: Tree, pt: ProtoType)(fallBack: (Tree, TyperState) => Tree)(implicit ctx: Context): Tree =
     fallBack(tree, ctx.typerState)
 
-  override def addTypedModifiersAnnotations(mdef: untpd.MemberDef, sym: Symbol)(implicit ctx: Context): Unit =
-    () // was: typedModifiers(Modifiers(sym), sym)
-       // but annotations are not transformed after typer, so no use to check them.
-
   override def ensureConstrCall(cls: ClassSymbol, parents: List[Tree])(implicit ctx: Context): List[Tree] =
     parents
 

src/dotty/tools/dotc/typer/Typer.scala

@@ -859,24 +859,12 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
     assignType(cpy.Alternative(tree)(trees1), trees1)
   }
 
-  def addTypedModifiersAnnotations(mdef: untpd.MemberDef, sym: Symbol)(implicit ctx: Context): Unit = {
-    val mods1 = typedModifiers(untpd.modsDeco(mdef).mods, sym)
-    sym.annotations.foreach(_.tree) // force trees to be computed
-  }
-
-  def typedModifiers(mods: untpd.Modifiers, sym: Symbol)(implicit ctx: Context): Modifiers = track("typedModifiers") {
-    val annotations1 = mods.annotations mapconserve typedAnnotation
-    if (annotations1 eq mods.annotations) mods.asInstanceOf[Modifiers]
-    else Modifiers(mods.flags, mods.privateWithin, annotations1)
-  }
-
   def typedAnnotation(annot: untpd.Tree)(implicit ctx: Context): Tree = track("typedAnnotation") {
     typed(annot, defn.AnnotationClass.typeRef)
   }
 
   def typedValDef(vdef: untpd.ValDef, sym: Symbol)(implicit ctx: Context) = track("typedValDef") {
     val ValDef(name, tpt, _) = vdef
-    addTypedModifiersAnnotations(vdef, sym)
     val tpt1 = typedType(tpt)
     val rhs1 = vdef.rhs match {
       case rhs @ Ident(nme.WILDCARD) => rhs withType tpt1.tpe
@@ -887,7 +875,6 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
 
   def typedDefDef(ddef: untpd.DefDef, sym: Symbol)(implicit ctx: Context) = track("typedDefDef") {
     val DefDef(name, tparams, vparamss, tpt, _) = ddef
-    addTypedModifiersAnnotations(ddef, sym)
     val tparams1 = tparams mapconserve (typed(_).asInstanceOf[TypeDef])
     val vparamss1 = vparamss nestedMapconserve (typed(_).asInstanceOf[ValDef])
     if (sym is Implicit) checkImplicitParamsNotSingletons(vparamss1)
@@ -899,7 +886,6 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
 
   def typedTypeDef(tdef: untpd.TypeDef, sym: Symbol)(implicit ctx: Context): Tree = track("typedTypeDef") {
     val TypeDef(name, rhs) = tdef
-    addTypedModifiersAnnotations(tdef, sym)
     val _ = typedType(rhs) // unused, typecheck only to remove from typedTree
     assignType(cpy.TypeDef(tdef)(name, TypeTree(sym.info), Nil), sym)
   }
@@ -916,7 +902,6 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
         result
       }
 
-    addTypedModifiersAnnotations(cdef, cls)
     val constr1 = typed(constr).asInstanceOf[DefDef]
     val parentsWithClass = ensureFirstIsClass(parents mapconserve typedParent, cdef.pos.toSynthetic)
     val parents1 = ensureConstrCall(cls, parentsWithClass)(superCtx)
@@ -1023,11 +1008,16 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
             case tree: untpd.Bind => typedBind(tree, pt)
             case tree: untpd.ValDef =>
               if (tree.isEmpty) tpd.EmptyValDef
-              else typedValDef(tree, sym)(localContext(tree, sym).setNewScope)
+              else {
+                sym.ensureAnnotationsCompleted()
+                typedValDef(tree, sym)(localContext(tree, sym).setNewScope)
+              }
             case tree: untpd.DefDef =>
+              sym.ensureAnnotationsCompleted()
               val typer1 = localTyper(sym)
               typer1.typedDefDef(tree, sym)(localContext(tree, sym).setTyper(typer1))
             case tree: untpd.TypeDef =>
+              sym.ensureAnnotationsCompleted()
               if (tree.isClassDef)
                 typedClassDef(tree, sym.asClass)(localContext(tree, sym).setMode(ctx.mode &~ Mode.InSuperCall))
               else