Path-dependent type on singleton value emits spurious outer test warnings

[neko-kai]

reproduction steps

using Scala 2.13.6,

object AnnotationTools {
  def getAllTypeAnnotations(u: Universe)(typ: u.Type): List[u.Annotation] = {
    typ.finalResultType.dealias match {
      case t: u.AnnotatedTypeApi =>
        t.annotations
      case _ =>
        Nil
    }
  }
}

problem

Results in a warning:

/izumi/fundamentals/fundamentals-reflection/src/main/scala/izumi/fundamentals/reflection/AnnotationTools.scala:16:12
The outer reference in this type test cannot be checked at run time.
      case t: u.AnnotatedTypeApi =>

When decompiled, the warning is true, the outer reference is in fact not checked:

   public List getAllTypeAnnotations(final Universe u, final TypeApi typ) {
      TypeApi var6 = .MODULE$.stripByName(u, typ.finalResultType().dealias());
      Object var3;
      if (var6 instanceof AnnotatedTypeApi && true) {
         var3 = ((AnnotatedTypeApi)var6).annotations();
      } else {
         var3 = scala.package..MODULE$.Nil();
      }

      return (List)var3;
   }

However, since u. is a literal prefix of AnnotatedTypeApi, is it not supposed to be checkable at runtime?

clarification

I've submitted this report assuming the new warning in 2.13.6 was incorrect and the type prefix was checked. On decompiling I found the warning is correct, and the behavior of all previous Scala versions was incorrect – they did not check the prefix AND did not issue the warning. So I rewrote the report to complain about lack of runtime type prefix comparison; 🤦
I am not sure if the behavior is incorrect, although from a language perspective it would seem that the implementation should always be able to compare prefixes when they are present syntactically in the type.

[dwijnand]

This is #4440. I spent more time looking at the variant where one is matching a nested final case class (rather than a trait) and what I understood is that it had been decided that adding a field for the outer reference was too much of an overhead to each case class, so it was optimistically elided. My understanding is the field is captured in Scala 3 so it's no longer incorrect. But in 2.13 we're stuck with what we've got. 😞

From my work on scala/scala#9622 if you can introduce the use of the Singleton type it would drop the warning.

[neko-kai]

There doesn't seem to be a way to interact with scala-reflect without warnings now, since using an Extractor object also generates warnings 🤔 :

  def getAllTypeAnnotations(u: Universe)(typ: u.Type): List[u.Annotation] = {
    typ.finalResultType.dealias match {
      case t @ u.AnnotatedType(_, _) =>
        t.annotations
      case _ =>
        Nil
    }

/izumi/fundamentals/fundamentals-reflection/src/main/scala/izumi/fundamentals/reflection/AnnotationTools.scala:17:31
abstract type pattern u.AnnotatedType is unchecked since it is eliminated by erasure
      case t @ u.AnnotatedType(_, _) =>

[dwijnand]

Yeah, it's very apparent in scala-reflect, with all its nested classes. Can you change to u: Universe with Singleton?

[neko-kai]

@dwijnand

if you can introduce the use of the Singleton type it would drop the warning.

This appears to be the case, but it also becomes very odd now, since a type projection is now warningless:

  def getAllTypeAnnotationsUSharp[U <: SingletonUniverse](u: U)(typ: U#Type): List[U#Annotation] = {
    typ.finalResultType.dealias match {
      case t: U#AnnotatedTypeApi =>
        t.annotations
      case _ =>
        Nil
    }
  }

But there doesn't seem to be a way to make the value-prefix match warningless:

  def getAllTypeAnnotations[U <: Universe with Singleton](u: U)(typ: U#Type): List[U#Annotation] = {
    typ.finalResultType.dealias match {
      case t: u.AnnotatedTypeApi =>
        t.annotations
      case _ =>
        Nil
    }
  }

/izumi/fundamentals/fundamentals-reflection/src/main/scala/izumi/fundamentals/reflection/AnnotationTools.scala:24:12
The outer reference in this type test cannot be checked at run time.
      case t: u.AnnotatedTypeApi =>

@dwijnand

Can you change to u: Universe with Singleton?

Yeah, in the snippet above, this does not seem to help the value case (even written like (u.type)#AnnotatedTypeApi)

[dwijnand]

I'll try to look at how u.AnnotatedTypeApi is behaving in prefixAligns.

[neko-kai]

The following workaround does get rid of the warning when only a value prefix is around:

def getAllTypeAnnotations(u: Universe)(typ: u.Type): List[u.Annotation] = {
  object xa { type U <: u.type with Singleton }
  typ.finalResultType.dealias match {
    case t: xa.U#AnnotatedTypeApi =>
      t.annotations
    case _ =>
      Nil
  }
}