Set Span for top level annotations generated in PostTyper (#16378)

This should help avoid macros throwing assertion errors in the case of
annotations not having assigned Spans/positions. Since the annotation is
generated and does not have a position corresponding to the source file,
it inherits Span from the tree to which it is assigned.

Fixes #16318

Author: nicolasstucki

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

@@ -175,7 +175,7 @@ object desugar {
       case Into(tpt1) =>
         mods1 = vdef.mods.withAddedAnnotation(
           TypedSplice(
-            Annotation(defn.AllowConversionsAnnot).tree.withSpan(tpt.span.startPos)))
+            Annotation(defn.AllowConversionsAnnot, tpt.span.startPos).tree))
         tpt1
       case ByNameTypeTree(tpt1) =>
         cpy.ByNameTypeTree(tpt)(dropInto(tpt1))

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

@@ -194,27 +194,21 @@ object Annotations {
   object Annotation {
 
     def apply(tree: Tree): ConcreteAnnotation = ConcreteAnnotation(tree)
+    
+    def apply(cls: ClassSymbol, span: Span)(using Context): Annotation =
+      apply(cls, Nil, span)
 
-    def apply(cls: ClassSymbol)(using Context): Annotation =
-      apply(cls, Nil)
+    def apply(cls: ClassSymbol, arg: Tree, span: Span)(using Context): Annotation =
+      apply(cls, arg :: Nil, span)
 
-    def apply(cls: ClassSymbol, arg: Tree)(using Context): Annotation =
-      apply(cls, arg :: Nil)
+    def apply(cls: ClassSymbol, args: List[Tree], span: Span)(using Context): Annotation =
+      apply(cls.typeRef, args, span)
 
-    def apply(cls: ClassSymbol, arg1: Tree, arg2: Tree)(using Context): Annotation =
-      apply(cls, arg1 :: arg2 :: Nil)
-
-    def apply(cls: ClassSymbol, args: List[Tree])(using Context): Annotation =
-      apply(cls.typeRef, args)
-
-    def apply(atp: Type, arg: Tree)(using Context): Annotation =
-      apply(atp, arg :: Nil)
-
-    def apply(atp: Type, arg1: Tree, arg2: Tree)(using Context): Annotation =
-      apply(atp, arg1 :: arg2 :: Nil)
-
-    def apply(atp: Type, args: List[Tree])(using Context): Annotation =
-      apply(New(atp, args))
+    def apply(atp: Type, arg: Tree, span: Span)(using Context): Annotation =
+      apply(atp, arg :: Nil, span)
+    
+    def apply(atp: Type, args: List[Tree], span: Span)(using Context): Annotation =
+      apply(New(atp, args).withSpan(span))
 
     /** Create an annotation where the tree is computed lazily. */
     def deferred(sym: Symbol)(treeFn: Context ?=> Tree): Annotation =
@@ -251,15 +245,15 @@ object Annotations {
         else None
     }
 
-    def makeSourceFile(path: String)(using Context): Annotation =
-      apply(defn.SourceFileAnnot, Literal(Constant(path)))
+    def makeSourceFile(path: String, span: Span)(using Context): Annotation =
+      apply(defn.SourceFileAnnot, Literal(Constant(path)), span)
   }
 
   @sharable val EmptyAnnotation = Annotation(EmptyTree)
 
   def ThrowsAnnotation(cls: ClassSymbol)(using Context): Annotation = {
     val tref = cls.typeRef
-    Annotation(defn.ThrowsAnnot.typeRef.appliedTo(tref), Ident(tref))
+    Annotation(defn.ThrowsAnnot.typeRef.appliedTo(tref), Ident(tref), cls.span)
   }
 
   /** Extracts the type of the thrown exception from an annotation.

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

@@ -283,7 +283,7 @@ object SymDenotations {
 
     /** Add the given annotation without parameters to the annotations of this denotation */
     final def addAnnotation(cls: ClassSymbol)(using Context): Unit =
-      addAnnotation(Annotation(cls))
+      addAnnotation(Annotation(cls, symbol.span))
 
     /** Remove annotation with given class from this denotation */
     final def removeAnnotation(cls: Symbol)(using Context): Unit =

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

@@ -3965,9 +3965,9 @@ object Types {
      *   - wrap types of parameters that have an @allowConversions annotation with Into[_]
      */
     def fromSymbols(params: List[Symbol], resultType: Type)(using Context): MethodType =
-      def addAnnotation(tp: Type, cls: ClassSymbol): Type = tp match
-        case ExprType(resType) => ExprType(addAnnotation(resType, cls))
-        case _ => AnnotatedType(tp, Annotation(cls))
+      def addAnnotation(tp: Type, cls: ClassSymbol, param: Symbol): Type = tp match
+        case ExprType(resType) => ExprType(addAnnotation(resType, cls, param))
+        case _ => AnnotatedType(tp, Annotation(cls, param.span))
 
       def wrapConvertible(tp: Type) =
         AppliedType(defn.IntoType.typeRef, tp :: Nil)
@@ -3992,9 +3992,9 @@ object Types {
       def paramInfo(param: Symbol) =
         var paramType = param.info.annotatedToRepeated
         if param.is(Inline) then
-          paramType = addAnnotation(paramType, defn.InlineParamAnnot)
+          paramType = addAnnotation(paramType, defn.InlineParamAnnot, param)
         if param.is(Erased) then
-          paramType = addAnnotation(paramType, defn.ErasedParamAnnot)
+          paramType = addAnnotation(paramType, defn.ErasedParamAnnot, param)
         if param.hasAnnotation(defn.AllowConversionsAnnot) then
           paramType = addInto(paramType)
         paramType

compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala

@@ -764,7 +764,7 @@ class ClassfileParser(
               res.namedParams += (i -> name.name)
 
         case tpnme.AnnotationDefaultATTR =>
-          sym.addAnnotation(Annotation(defn.AnnotationDefaultAnnot, Nil))
+          sym.addAnnotation(Annotation(defn.AnnotationDefaultAnnot, Nil, sym.span))
 
         // Java annotations on classes / methods / fields with RetentionPolicy.RUNTIME
         case tpnme.RuntimeVisibleAnnotationATTR

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

@@ -110,7 +110,7 @@ class CompleteJavaEnums extends MiniPhase with InfoTransformer { thisPhase =>
     yield {
       def forwarderSym(flags: FlagSet, info: Type): Symbol { type ThisName = TermName } =
         val sym = newSymbol(clazz, enumValue.name.asTermName, flags, info)
-        sym.addAnnotation(Annotations.Annotation(defn.ScalaStaticAnnot))
+        sym.addAnnotation(Annotations.Annotation(defn.ScalaStaticAnnot, sym.span))
         sym
       val body = moduleRef.select(enumValue)
       if ctx.settings.scalajs.value then

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

@@ -39,7 +39,7 @@ object ContextFunctionResults:
     val count = contextResultCount(mdef.rhs, mdef.tpt.tpe)
 
     if Config.flattenContextFunctionResults && count != 0 && !disabled then
-      val countAnnot = Annotation(defn.ContextResultCountAnnot, Literal(Constant(count)))
+      val countAnnot = Annotation(defn.ContextResultCountAnnot, Literal(Constant(count)), mdef.symbol.span)
       mdef.symbol.addAnnotation(countAnnot)
   end annotateContextResults
 

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

@@ -112,7 +112,7 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer {
     appendOffsetDefs.get(cls) match {
       case None => template
       case Some(data) =>
-        data.defs.foreach(_.symbol.addAnnotation(Annotation(defn.ScalaStaticAnnot)))
+        data.defs.foreach(defin => defin.symbol.addAnnotation(Annotation(defn.ScalaStaticAnnot, defin.symbol.span)))
         cpy.Template(template)(body = addInFront(data.defs, template.body))
     }
   }
@@ -464,7 +464,7 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer {
     def offsetName(id: Int) = s"${StdNames.nme.LAZY_FIELD_OFFSET}${if (x.symbol.owner.is(Module)) "_m_" else ""}$id".toTermName
     val containerName = LazyLocalName.fresh(x.name.asTermName)
     val containerSymbol = newSymbol(claz, containerName, x.symbol.flags &~ containerFlagsMask | containerFlags | Private, defn.ObjectType, coord = x.symbol.coord).enteredAfter(this)
-    containerSymbol.addAnnotation(Annotation(defn.VolatileAnnot)) // private @volatile var _x: AnyRef
+    containerSymbol.addAnnotation(Annotation(defn.VolatileAnnot, containerSymbol.span)) // private @volatile var _x: AnyRef
     containerSymbol.addAnnotations(x.symbol.annotations) // pass annotations from original definition
     val stat = x.symbol.isStatic
     if stat then
@@ -482,7 +482,7 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer {
         newSymbol(claz, offsetName(info.defs.size), Synthetic, defn.LongType).enteredAfter(this)
       case None =>
         newSymbol(claz, offsetName(0), Synthetic, defn.LongType).enteredAfter(this)
-    offsetSymbol.nn.addAnnotation(Annotation(defn.ScalaStaticAnnot))
+    offsetSymbol.nn.addAnnotation(Annotation(defn.ScalaStaticAnnot, offsetSymbol.nn.span))
     val fieldTree = thizClass.select(lazyNme.RLazyVals.getDeclaredField).appliedTo(Literal(Constant(containerName.mangledString)))
     val offsetTree = ValDef(offsetSymbol.nn, getOffset.appliedTo(fieldTree))
     val offsetInfo = appendOffsetDefs.getOrElseUpdate(claz, new OffsetInfo(Nil))
@@ -625,7 +625,7 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer {
              .symbol.asTerm
         else { // need to create a new flag
           offsetSymbol = newSymbol(claz, offsetById, Synthetic, defn.LongType).enteredAfter(this)
-          offsetSymbol.nn.addAnnotation(Annotation(defn.ScalaStaticAnnot))
+          offsetSymbol.nn.addAnnotation(Annotation(defn.ScalaStaticAnnot, offsetSymbol.nn.span))
           val flagName = LazyBitMapName.fresh(id.toString.toTermName)
           val flagSymbol = newSymbol(claz, flagName, containerFlags, defn.LongType).enteredAfter(this)
           flag = ValDef(flagSymbol, Literal(Constant(0L)))
@@ -636,7 +636,7 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer {
 
       case None =>
         offsetSymbol = newSymbol(claz, offsetName(0), Synthetic, defn.LongType).enteredAfter(this)
-        offsetSymbol.nn.addAnnotation(Annotation(defn.ScalaStaticAnnot))
+        offsetSymbol.nn.addAnnotation(Annotation(defn.ScalaStaticAnnot, offsetSymbol.nn.span))
         val flagName = LazyBitMapName.fresh("0".toTermName)
         val flagSymbol = newSymbol(claz, flagName, containerFlags, defn.LongType).enteredAfter(this)
         flag = ValDef(flagSymbol, Literal(Constant(0L)))

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

@@ -46,7 +46,7 @@ class MoveStatics extends MiniPhase with SymTransformer {
           if (staticFields.nonEmpty) {
             /* do NOT put Flags.JavaStatic here. It breaks .enclosingClass */
             val staticCostructor = newSymbol(orig.symbol, nme.STATIC_CONSTRUCTOR, Flags.Synthetic | Flags.Method | Flags.Private, MethodType(Nil, defn.UnitType))
-            staticCostructor.addAnnotation(Annotation(defn.ScalaStaticAnnot))
+            staticCostructor.addAnnotation(Annotation(defn.ScalaStaticAnnot, staticCostructor.span))
             staticCostructor.entered
 
             val staticAssigns = staticFields.map(x => Assign(ref(x.symbol), x.rhs.changeOwner(x.symbol, staticCostructor)))

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

@@ -297,7 +297,7 @@ object PCPCheckAndHeal {
         flags = Synthetic,
         info = TypeAlias(splicedTree.tpe.select(tpnme.Underlying)),
         coord = span).asType
-      local.addAnnotation(Annotation(defn.QuotedRuntime_SplicedTypeAnnot))
+      local.addAnnotation(Annotation(defn.QuotedRuntime_SplicedTypeAnnot, span))
       ctx.typeAssigner.assignType(untpd.TypeDef(local.name, alias), local)
     }