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.
  */

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

@@ -43,6 +43,7 @@ import scala.annotation.internal.sharable
 import scala.annotation.threadUnsafe
 
 import dotty.tools.dotc.transform.SymUtils._
+import Symbols.TypeTests.given
 
 object Types {
 
@@ -2719,7 +2720,7 @@ object Types {
       if (prefix eq this.prefix) this
       else if !NamedType.validPrefix(prefix) then UnspecifiedErrorType
       else if (lastDenotation == null) NamedType(prefix, designator)
-      else designator match {
+      else (designator: @unchecked) match {  // !!! dotty opaque exhaustivity problem
         case sym: Symbol =>
           if (infoDependsOnPrefix(sym, prefix) && !prefix.isArgPrefixOf(sym)) {
             val candidate = reload()
@@ -2899,7 +2900,7 @@ object Types {
   }
 
   object NamedType {
-    def isType(desig: Designator)(using Context): Boolean = desig match {
+    def isType(desig: Designator)(using Context): Boolean = (desig: @unchecked) match {  // !!! dotty opaque exhaustivity problem
       case sym: Symbol => sym.isType
       case name: Name => name.isTypeName
     }
@@ -5036,7 +5037,7 @@ object Types {
               TypeAlias(
                 withMode(Mode.CheckCyclic)(
                   LazyRef.of(force))))
-          cinfo.selfInfo match
+          (cinfo.selfInfo: @unchecked) match  // !!! dotty opaque exhaustivity problem
             case self: Type =>
               cinfo.derivedClassInfo(
                 selfInfo = refineSelfType(self.orElse(defn.AnyType)))

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

@@ -4,6 +4,7 @@ package core
 import Types._, Contexts._, Flags._, Symbols._, Annotations._
 import TypeApplications.TypeParamInfo
 import Decorators._
+import Symbols.TypeTests.given
 
 object Variances {
 

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

@@ -23,6 +23,7 @@ import scala.annotation.switch
 import typer.Checking.checkNonCyclic
 import io.{AbstractFile, ZipArchive}
 import scala.util.control.NonFatal
+import Symbols.TypeTests.given
 
 object ClassfileParser {
   /** Marker trait for unpicklers that can be embedded in classfiles. */

compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala

@@ -19,6 +19,7 @@ import config.Config
 import collection.mutable
 import reporting.{Profile, NoProfile}
 import dotty.tools.tasty.TastyFormat.ASTsSection
+import core.Symbols.TypeTests.given
 
 object TreePickler:
   class StackSizeExceeded(val mdef: tpd.MemberDef) extends Exception
@@ -212,7 +213,7 @@ class TreePickler(pickler: TastyPickler) {
           report.error(em"pickling reference to as yet undefined $tpe with symbol ${sym}", sym.srcPos)
         pickleSymRef(sym)
       }
-      else tpe.designator match {
+      else (tpe.designator: @unchecked) match {  // !!! dotty opaque exhaustivity problem
         case name: Name =>
           writeByte(if (tpe.isType) TYPEREF else TERMREF)
           pickleName(name); pickleType(tpe.prefix)
@@ -598,7 +599,7 @@ class TreePickler(pickler: TastyPickler) {
               else {
                 if (!tree.self.isEmpty) registerTreeAddr(tree.self)
                 pickleType {
-                  selfInfo match {
+                  (selfInfo: @unchecked) match {  // !!! dotty opaque exhaustivity problem
                     case sym: Symbol => sym.info
                     case tp: Type => tp
                   }

compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala

@@ -46,6 +46,7 @@ import dotty.tools.tasty.TastyFormat._
 
 import scala.annotation.constructorOnly
 import scala.annotation.internal.sharable
+import Symbols.TypeTests.given
 
 /** Unpickler for typed trees
  *  @param reader              the reader from which to unpickle

compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Erasure.scala

@@ -6,6 +6,7 @@ package unpickleScala2
 import Symbols._, Types._, Contexts._, Flags._, Names._, StdNames._, Phases._
 import Decorators._
 import scala.collection.mutable.ListBuffer
+import Symbols.TypeTests.given
 
 /** Erasure logic specific to Scala 2 symbols. */
 object Scala2Erasure:
@@ -161,7 +162,7 @@ object Scala2Erasure:
        *  pseudo-symbol, if its upper-bound is a sub of that pseudo-symbol.
        */
       def goUpperBound(psym: Symbol | StructuralRef): Boolean =
-        val info = psym match
+        val info = (psym: @unchecked) match // !!! dotty opaque exhaustivity problem
           case sym: Symbol => sym.info
           case tp: StructuralRef => tp.info
         info match
@@ -178,7 +179,7 @@ object Scala2Erasure:
         // is an abstract type upper-bounded by this refinement, since each
         // textual appearance of a refinement will have its own class symbol.
         !that.isInstanceOf[Scala2RefinedType] &&
-        psym.match
+        (psym: @unchecked).match // !!! dotty opaque exhaustivity problem
           case sym1: Symbol => that match
             case sym2: Symbol =>
               if sym1.isClass && sym2.isClass then

compiler/src/dotty/tools/dotc/fromtasty/ReadTasty.scala

@@ -11,6 +11,7 @@ import Denotations.staticRef
 import NameOps._
 import ast.Trees.Tree
 import Phases.Phase
+import Symbols.TypeTests.given
 
 
 /** Load trees from TASTY files */

compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala

@@ -16,6 +16,7 @@ import scala.util.control.NonFatal
 import scala.annotation.switch
 import config.{Config, Feature}
 import cc.{CapturingType, EventuallyCapturingType, CaptureSet, isBoxed}
+import Symbols.TypeTests.given
 
 class PlainPrinter(_ctx: Context) extends Printer {
 

compiler/src/dotty/tools/dotc/reporting/Message.scala

@@ -12,6 +12,7 @@ import config.SourceVersion
 import scala.language.unsafeNulls
 
 import scala.annotation.threadUnsafe
+import Symbols.TypeTests.given
 
 /** ## Tips for error message generation
  *
@@ -154,7 +155,7 @@ object Message:
     /** Produce a where clause with explanations for recorded iterms.
      */
     def explanations(using Context): String =
-      def needsExplanation(entry: Recorded) = entry match {
+      def needsExplanation(entry: Recorded) = (entry: @unchecked) match { // !!! dotty opaque exhaustivity problem
         case param: TypeParamRef => ctx.typerState.constraint.contains(param)
         case param: ParamRef     => false
         case skolem: SkolemType => true

compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala

@@ -24,6 +24,7 @@ import scala.annotation.{ threadUnsafe => tu, tailrec }
 import scala.PartialFunction.condOpt
 
 import dotty.tools.dotc.{semanticdb => s}
+import Symbols.TypeTests.given
 
 /** Extract symbol references and uses to semanticdb files.
  *  See https://scalameta.org/docs/semanticdb/specification.html#symbol-1

compiler/src/dotty/tools/dotc/semanticdb/Scala3.scala

@@ -12,6 +12,7 @@ import core.StdNames.nme
 import SymbolInformation.{Kind => k}
 import dotty.tools.dotc.util.SourceFile
 import dotty.tools.dotc.util.Spans.Span
+import core.Symbols.TypeTests.given
 
 import java.lang.Character.{isJavaIdentifierPart, isJavaIdentifierStart}
 
@@ -44,7 +45,7 @@ object Scala3:
         else (span.start, span.end)
       val nameInSource = content.slice(start, end).mkString
       // for secondary constructors `this`
-      desig match
+      (desig: @unchecked) match // !!! dotty opaque exhaustivity problem
         case sym: Symbol =>
           if sym.isConstructor && nameInSource == nme.THISkw.toString then
             true
@@ -76,15 +77,15 @@ object Scala3:
 
   given SemanticSymbolOps : AnyRef with
     extension (sym: SemanticSymbol)
-      def name(using Context): Name = sym match
+      def name(using Context): Name = (sym: @unchecked) match  // !!! dotty opaque exhaustivity problem
         case s: Symbol => core.Symbols.name(s)
         case s: WildcardTypeSymbol => nme.WILDCARD
         case s: TermParamRefSymbol => s.name
         case s: TypeParamRefSymbol => s.name
         case s: RefinementSymbol => s.name
 
       def symbolName(using builder: SemanticSymbolBuilder)(using Context): String =
-        sym match
+        (sym: @unchecked) match  // !!! dotty opaque exhaustivity problem
           case s: Symbol => builder.symbolName(s)
           case s: FakeSymbol =>
             s.sname.getOrElse {
@@ -94,7 +95,7 @@ object Scala3:
             }
 
       def symbolInfo(symkinds: Set[SymbolKind])(using LinkMode, TypeOps, SemanticSymbolBuilder, Context): SymbolInformation =
-        sym match
+        (sym: @unchecked) match  // !!! dotty opaque exhaustivity problem
           case s: Symbol =>
             val kind = s.symbolKind(symkinds)
             val sname = sym.symbolName

compiler/src/dotty/tools/dotc/semanticdb/TypeOps.scala

@@ -12,6 +12,7 @@ import core.StdNames.tpnme
 import scala.util.chaining.scalaUtilChainingOps
 
 import collection.mutable
+import core.Symbols.TypeTests.given
 
 import dotty.tools.dotc.{semanticdb => s}
 import Scala3.{FakeSymbol, SemanticSymbol, WildcardTypeSymbol, TypeParamRefSymbol, TermParamRefSymbol, RefinementSymbol}

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

@@ -10,6 +10,7 @@ import Symbols._, StdNames._, Trees._
 import TypeErasure.ErasedValueType, ValueClasses._
 import reporting._
 import NameKinds.SuperAccessorName
+import Symbols.TypeTests.given
 
 object ElimErasedValueType {
   val name: String = "elimErasedValueType"