Return older implementations without FatalError

Author: neko-kai

distage/distage-core-api/src/main/scala/izumi/distage/constructors/macros/ConstructorMacros.scala

@@ -78,7 +78,7 @@ abstract class TraitConstructorMacros extends ConstructorMacrosBase {
 
   def traitConstructorAssertion(targetType: Type): Unit = {
     ReflectionUtil
-      .deepIntersectionTypeMembers(c.universe: c.universe.type)(targetType)
+      .deepIntersectionTypeMembers[c.universe.type](targetType)
       .find(tpe => tpe.typeSymbol.isParameter || tpe.typeSymbol.isFinal)
       .foreach {
         err =>
@@ -258,7 +258,7 @@ abstract class ConstructorMacrosBase {
     constructorParameters: List[List[Tree]],
     methodImpls: List[Tree],
   ): Tree = {
-    val parents = ReflectionUtil.deepIntersectionTypeMembers(u.u: u.u.type)(targetType)
+    val parents = ReflectionUtil.deepIntersectionTypeMembers[u.u.type](targetType)
     parents match {
       case parent :: Nil if parent.typeSymbol.isClass && !parent.typeSymbol.asClass.isTrait =>
         if (methodImpls.isEmpty) {

distage/distage-core-api/src/main/scala/izumi/distage/constructors/macros/HasConstructorMacro.scala

@@ -20,7 +20,7 @@ object HasConstructorMacro {
     val targetType = ReflectionUtil.norm(c.universe: c.universe.type)(weakTypeOf[T].dealias)
     requireConcreteTypeConstructor(c)("HasConstructor", targetType)
     val deepIntersection = ReflectionUtil
-      .deepIntersectionTypeMembers(c.universe: c.universe.type)(targetType)
+      .deepIntersectionTypeMembers[c.universe.type](targetType)
       .filter(_ ne definitions.AnyTpe)
 
     targetType match {

distage/distage-core-api/src/main/scala/izumi/distage/model/reflection/universe/WithDISymbolInfo.scala

@@ -85,7 +85,7 @@ trait WithDISymbolInfo { this: DIUniverseBase with WithDISafeType =>
         SymbolInfo.Static(
           name = transformName(tpe.typeSymbol.name.toString),
           finalResultType = tpe,
-          annotations = AnnotationTools.getAllTypeAnnotations(u)(tpe),
+          annotations = AnnotationTools.getAllTypeAnnotations[u.type](tpe),
           isByName = tpe.typeSymbol.isClass && tpe.typeSymbol.asClass == u.definitions.ByNameParamClass,
           wasGeneric = tpe.typeSymbol.isParameter,
         )

distage/distage-core-api/src/main/scala/izumi/distage/reflection/ReflectionProviderDefaultImpl.scala

@@ -128,7 +128,7 @@ trait ReflectionProviderDefaultImpl extends ReflectionProvider {
     if (tpe.typeSymbol.isStatic) {
       None
     } else {
-      val typeRef = ReflectionUtil.toTypeRef(u.u: u.u.type)(tpe)
+      val typeRef = ReflectionUtil.toTypeRef[u.u.type](tpe)
       typeRef
         .map(_.pre)
         .filterNot(m => m.termSymbol.isModule && m.termSymbol.isStatic)

fundamentals/fundamentals-reflection/src/main/scala/izumi/fundamentals/reflection/AnnotationTools.scala

@@ -1,24 +1,20 @@
 package izumi.fundamentals.reflection
 
-import izumi.fundamentals.reflection.ReflectionUtil.stripByName
-
 import scala.reflect.api.Universe
 
 object AnnotationTools {
 
   def getAllAnnotations(u: Universe)(symb: u.Symbol): List[u.Annotation] = {
-    val out = symb.annotations ++ getAllTypeAnnotations(u)(symb.typeSignature)
-    out
+    symb.annotations ++ getAllTypeAnnotations[u.type](symb.typeSignature)
   }
 
-  def getAllTypeAnnotations(u: Universe)(typ: u.Type): List[u.Annotation] = {
-    val out = stripByName(u)(typ.finalResultType.dealias) match {
-      case t: u.AnnotatedTypeApi =>
+  def getAllTypeAnnotations[U <: Universe with Singleton](typ: U#Type): List[U#Annotation] = {
+    typ.finalResultType.dealias match {
+      case t: U#AnnotatedTypeApi =>
         t.annotations
       case _ =>
         Nil
     }
-    out
   }
 
   def annotationTypeEq(u: Universe)(tpe: u.Type, ann: u.Annotation): Boolean = {

fundamentals/fundamentals-reflection/src/main/scala/izumi/fundamentals/reflection/ReflectionUtil.scala

@@ -25,17 +25,17 @@ object ReflectionUtil {
     * So we just strip it when we get it.
     */
   @tailrec
-  final def norm0(u: Universe)(x: u.Type): u.Type = {
+  final def norm0[U <: SingletonUniverse](x: U#Type): U#Type = {
     x match {
-      case r: u.RefinedTypeApi if (r.parents.drop(1) eq Nil) && r.decls.isEmpty => norm0(u)(r.asInstanceOf[u.Type])
-      case a: u.AnnotatedTypeApi => norm0(u)(a.underlying)
+      case r: U#RefinedTypeApi if (r.parents.drop(1) eq Nil) && r.decls.isEmpty => norm0[U](r.asInstanceOf[U#Type])
+      case a: U#AnnotatedTypeApi => norm0[U](a.underlying)
       case _ => x
     }
   }
 
-  def toTypeRef(u: Universe)(tpe: u.TypeApi): Option[u.TypeRefApi] = {
+  def toTypeRef[U <: SingletonUniverse](tpe: U#TypeApi): Option[U#TypeRefApi] = {
     tpe match {
-      case typeRef: u.TypeRefApi =>
+      case typeRef: U#TypeRefApi =>
         Some(typeRef)
       case _ =>
         None
@@ -100,10 +100,10 @@ object ReflectionUtil {
     tpe1.dealias =:= tpe1
   }
 
-  def deepIntersectionTypeMembers(u: Universe)(targetType: u.Type): List[u.Type] = {
-    def go(tpe: u.Type): List[u.Type] = {
+  def deepIntersectionTypeMembers[U <: SingletonUniverse](targetType: U#Type): List[U#Type] = {
+    def go(tpe: U#Type): List[U#Type] = {
       tpe match {
-        case r: u.RefinedTypeApi => r.parents.flatMap(t => deepIntersectionTypeMembers(u)(norm0(u)(t.dealias)))
+        case r: U#RefinedTypeApi => r.parents.flatMap(t => deepIntersectionTypeMembers[U](norm0[U](t.dealias): U#Type))
         case _ => List(tpe)
       }
     }