SI-7649 Fix positions for reshaped tag materializers

Calls to `materializeClassTag[T]` are replaced during reification with
`implicitly[ClassTag[T]]` in the `reify` macro. This is done to avoid
referring to symbols in scala-compiler.jar. Class- and Type-Tag
materialization is treated in the same way.

This commit positions the replacement trees to avoid triggering
assertions under -Yrangepos.

Author: retronym

src/compiler/scala/reflect/reify/phases/Reshape.scala

@@ -91,20 +91,20 @@ trait Reshape {
     private def undoMacroExpansion(tree: Tree): Tree =
       tree.attachments.get[MacroExpansionAttachment] match {
         case Some(MacroExpansionAttachment(original)) =>
+          def mkImplicitly(tp: Type) = atPos(tree.pos)(
+            gen.mkNullaryCall(Predef_implicitly, List(tp))
+          )
+          val sym = original.symbol
           original match {
             // this hack is necessary until I fix implicit macros
             // so far tag materialization is implemented by sneaky macros hidden in scala-compiler.jar
             // hence we cannot reify references to them, because noone will be able to see them later
             // when implicit macros are fixed, these sneaky macros will move to corresponding companion objects
             // of, say, ClassTag or TypeTag
-            case Apply(TypeApply(_, List(tt)), _) if original.symbol == materializeClassTag =>
-              gen.mkNullaryCall(Predef_implicitly, List(appliedType(ClassTagClass, tt.tpe)))
-            case Apply(TypeApply(_, List(tt)), List(pre)) if original.symbol == materializeWeakTypeTag =>
-              gen.mkNullaryCall(Predef_implicitly, List(typeRef(pre.tpe, WeakTypeTagClass, List(tt.tpe))))
-            case Apply(TypeApply(_, List(tt)), List(pre)) if original.symbol == materializeTypeTag =>
-              gen.mkNullaryCall(Predef_implicitly, List(typeRef(pre.tpe, TypeTagClass, List(tt.tpe))))
-            case _ =>
-              original
+            case Apply(TypeApply(_, List(tt)), _) if sym == materializeClassTag            => mkImplicitly(appliedType(ClassTagClass, tt.tpe))
+            case Apply(TypeApply(_, List(tt)), List(pre)) if sym == materializeWeakTypeTag => mkImplicitly(typeRef(pre.tpe, WeakTypeTagClass, List(tt.tpe)))
+            case Apply(TypeApply(_, List(tt)), List(pre)) if sym == materializeTypeTag     => mkImplicitly(typeRef(pre.tpe, TypeTagClass, List(tt.tpe)))
+            case _                                                                         => original
           }
         case _ => tree
       }

test/files/pos/t7649.flags

@@ -0,0 +1 @@
+-Yrangepos

test/files/pos/t7649.scala

@@ -0,0 +1,20 @@
+object Test {
+  val c: reflect.macros.Context = ???
+  import c.universe._
+  reify {
+    // The lookup of the implicit WeakTypeTag[Any]
+    // was triggering an unpositioned tree.
+    c.Expr[Any](Literal(Constant(0))).splice
+  }
+
+  import scala.reflect.ClassTag
+  def ct[A: ClassTag]: Expr[A] = ???
+  def tt[A: TypeTag]: Expr[A] = ???
+  def wtt[A: WeakTypeTag]: Expr[A] = ???
+
+  reify {
+    ct[String].splice
+    tt[String].splice
+    wtt[String].splice
+  }
+}