Add backup TypeTests for Symbol and ClassSymbol

These are needed once we move to opaque types

Author: odersky

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

@@ -7,6 +7,7 @@ import Types._, Contexts._, Flags._
 import Symbols._, Annotations._, Trees._, Symbols._, Constants.Constant
 import Decorators._
 import dotty.tools.dotc.transform.SymUtils._
+import Symbols.TypeTests.given
 
 /** A map that applies three functions and a substitution together to a tree and
  *  makes sure they are coordinated so that the result is well-typed. The functions are

compiler/src/dotty/tools/dotc/cc/CaptureOps.scala

@@ -10,6 +10,7 @@ import config.Printers.capt
 import util.Property.Key
 import tpd.*
 import config.Feature
+import Symbols.TypeTests.given
 
 private val Captures: Key[CaptureSet] = Key()
 private val BoxedType: Key[BoxedTypeCache] = Key()

compiler/src/dotty/tools/dotc/cc/Setup.scala

@@ -12,6 +12,7 @@ import transform.Recheck.*
 import CaptureSet.IdentityCaptRefMap
 import Synthetics.isExcluded
 import util.Property
+import Symbols.TypeTests.given
 
 /** A tree traverser that prepares a compilation unit to be capture checked.
  *  It does the following:

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

@@ -7,6 +7,7 @@ import ast.tpd, tpd.*
 import util.Spans.Span
 import printing.{Showable, Printer}
 import printing.Texts.Text
+import Symbols.TypeTests.given
 
 import scala.annotation.internal.sharable
 
@@ -194,7 +195,7 @@ object Annotations {
   object Annotation {
 
     def apply(tree: Tree): ConcreteAnnotation = ConcreteAnnotation(tree)
-    
+
     def apply(cls: ClassSymbol, span: Span)(using Context): Annotation =
       apply(cls, Nil, span)
 
@@ -206,7 +207,7 @@ object Annotations {
 
     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))
 

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

@@ -5,6 +5,7 @@ import Contexts._, Symbols._, Types._, Flags._
 import Denotations._, SymDenotations._
 import Names.Name, StdNames.nme
 import ast.untpd
+import Symbols.TypeTests.given
 
 /** Extension methods for contexts where we want to keep the ctx.<methodName> syntax */
 object ContextOps:

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

@@ -5,6 +5,7 @@ package core
 import Contexts._, Symbols._, Types._, Flags._, Scopes._, Decorators._, Names._, NameOps._
 import SymDenotations.{LazyType, SymDenotation}, StdNames.nme
 import TypeApplications.EtaExpansion
+import Symbols.TypeTests.given
 
 /** Operations that are shared between Namer and TreeUnpickler */
 object NamerOps:

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

@@ -28,6 +28,7 @@ import transform.TypeUtils._
 import cc.{CapturingType, derivedCapturingType, Setup, EventuallyCapturingType, isEventuallyCapturingType}
 
 import scala.annotation.internal.sharable
+import Symbols.TypeTests.given
 
 object SymDenotations {
 
@@ -1993,7 +1994,7 @@ object SymDenotations {
     /** The explicitly given self type (self types of modules are assumed to be
      *  explcitly given here).
      */
-    def givenSelfType(using Context): Type = classInfo.selfInfo match {
+    def givenSelfType(using Context): Type = (classInfo.selfInfo: @unchecked) match { // !!! dotty problem: opaque exhaustive
       case tp: Type => tp
       case self: Symbol => self.info
     }

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

@@ -32,6 +32,7 @@ import util.{SourceFile, NoSource, Property, SourcePosition, SrcPos, EqHashMap}
 import scala.annotation.internal.sharable
 import config.Printers.typr
 import annotation.tailrec
+import scala.reflect.TypeTest
 
 object Symbols {
 
@@ -46,6 +47,19 @@ object Symbols {
   opaque type ClassSymbl <: Symbl
     = ClassDenotation
 
+  object TypeTests:
+
+    given SymTest: TypeTest[AnyRef, Symbol] with
+      def unapply(x: AnyRef): Option[x.type & Symbol] = x match
+        case sd: SymDenotation => Some(sd.asInstanceOf)
+        case _ => None
+
+    given ClsTest: TypeTest[AnyRef, ClassSymbol] with
+      def unapply(x: AnyRef): Option[x.type & ClassSymbol] = x match
+        case cd: ClassDenotation => Some(cd.asInstanceOf)
+        case _ => None
+  end TypeTests
+
   /** A Symbol represents a Scala definition/declaration or a package.
    *  @param coord  The coordinates of the symbol (a position or an index)
    *  @param id     A unique identifier of the symbol (unique per ContextBase)
@@ -84,7 +98,7 @@ object Symbols {
   type TermSymbol = Symbol { type ThisName = TermName }
   type TypeSymbol = Symbol { type ThisName = TypeName }
 
-  extension (x: AnyRef)
+  extension (x: Any)
     inline def isSymbol: Boolean = x.isInstanceOf[Symbol]
     inline def asSymbol: Symbol = x.asInstanceOf[Symbol]
 

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

@@ -12,6 +12,7 @@ import Names._
 import Flags.{Module, Provisional}
 import dotty.tools.dotc.config.Config
 import cc.boxedUnlessFun
+import Symbols.TypeTests.given
 
 object TypeApplications {
 
@@ -217,7 +218,7 @@ class TypeApplications(val self: Type) extends AnyVal {
   /** If `self` is a generic class, its type parameter symbols, otherwise Nil */
   final def typeParamSymbols(using Context): List[TypeSymbol] = typeParams match {
     case tparams @ (_: Symbol) :: _ =>
-      assert(tparams.forall(_.isInstanceOf[Symbol]))
+      assert(tparams.forall(_.isSymbol))
       tparams.asInstanceOf[List[TypeSymbol]]
         // Note: Two successive calls to typeParams can yield different results here because
         // of different completion status. I.e. the first call might produce some symbols,

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

@@ -24,6 +24,7 @@ import typer.Applications.productSelectorTypes
 import reporting.trace
 import annotation.constructorOnly
 import cc.{CapturingType, derivedCapturingType, CaptureSet, stripCapturing, isBoxedCapturing, boxed, boxedUnlessFun, boxedIfTypeParam, isAlwaysPure}
+import Symbols.TypeTests.given
 
 /** Provides methods to compare types.
  */