Replace annotation extractor with access methods

Author: odersky

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

@@ -185,23 +185,6 @@ object Annotations {
         else None
     }
 
-    /** Extractor for opaque alias annotations */
-    object OpaqueAlias {
-      def apply(tp: Type, companion: Symbol)(implicit ctx: Context): Annotation = {
-        val arg = if (companion.exists) RefinedType(tp, nme.companion, companion.termRef) else tp
-        Annotation(TypeTree(defn.OpaqueAliasAnnot.typeRef.appliedTo(arg)))
-      }
-      def unapply(ann: Annotation)(implicit ctx: Context): Option[(Type, Symbol)] =
-        if (ann.symbol == defn.OpaqueAliasAnnot) {
-          ann.tree.tpe match {
-            case AppliedType(_, RefinedType(tp, nme.companion, ref) :: Nil) => Some((tp, ref.termSymbol))
-            case AppliedType(_, tp :: Nil) => Some((tp, NoSymbol))
-            case _ => None
-          }
-        }
-        else None
-    }
-
     /** Extractor for linked type annotations */
     object LinkedType extends TypeHintExtractor(implicit ctx => defn.LinkedTypeAnnot)
 

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

@@ -246,6 +246,7 @@ object StdNames {
 
     // Compiler-internal
     val ANYname: N                  = "<anyname>"
+    val COMPANION: N                = "<companion>"
     val CONSTRUCTOR: N              = "<init>"
     val STATIC_CONSTRUCTOR: N       = "<clinit>"
     val DEFAULT_CASE: N             = "defaultCase$"
@@ -394,7 +395,6 @@ object StdNames {
     val classOf: N              = "classOf"
     val clone_ : N              = "clone"
  //   val conforms : N             = "conforms" // Dotty deviation: no special treatment of conforms, so the occurrence of the name here would cause to unintended implicit shadowing. Should find a less common name for it in Predef.
-    val companion: N            = "companion"
     val copy: N                 = "copy"
     val currentMirror: N        = "currentMirror"
     val create: N               = "create"

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

@@ -390,9 +390,12 @@ object SymDenotations {
       }
       if (is(Opaque)) {
         info match {
-          case tp @ TypeAlias(alias) =>
+          case TypeAlias(alias) =>
             val companion = companionNamed(name.moduleClassName).sourceModule
-            addAnnotation(Annotation.OpaqueAlias(alias, companion))
+            val arg =
+              if (companion.exists) RefinedType(alias, nme.COMPANION, companion.termRef)
+              else alias
+            addAnnotation(Annotation(tpd.TypeTree(defn.OpaqueAliasAnnot.typeRef.appliedTo(arg))))
             info = TypeBounds(defn.NothingType, abstractRHS(alias))
             setFlag(Deferred)
           case _ =>
@@ -971,8 +974,13 @@ object SymDenotations {
       if (is(Module)) sourceModule
       else if (is(Opaque))
         getAnnotation(defn.OpaqueAliasAnnot) match {
-          case Some(Annotation.OpaqueAlias(_, ref)) => ref
-          case _ => NoSymbol
+          case Some(ann) =>
+            val AppliedType(_, arg :: Nil) = ann.tree.tpe
+            arg match {
+              case RefinedType(tp, _, ref) => ref.termSymbol
+              case _ => NoSymbol
+            }
+          case None => NoSymbol
         }
       else
         getAnnotation(defn.LinkedTypeAnnot) match {
@@ -1052,6 +1060,21 @@ object SymDenotations {
     final def enclosingSubClass(implicit ctx: Context) =
       ctx.owner.ownersIterator.findSymbol(_.isSubClass(symbol))
 
+    /** The alias of an opaque type */
+    def opaqueAlias(implicit ctx: Context): Type = {
+      if (is(Opaque))
+        getAnnotation(defn.OpaqueAliasAnnot) match {
+          case Some(ann) =>
+            val AppliedType(_, arg :: Nil) = ann.tree.tpe
+            arg match {
+              case RefinedType(tp, nme.COMPANION, _) => tp
+              case tp => tp
+            }
+          case None => NoType
+        }
+      else NoType
+    }
+
     /** The non-private symbol whose name and type matches the type of this symbol
      *  in the given class.
      *  @param inClass   The class containing the result symbol's definition

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

@@ -64,17 +64,12 @@ class FirstTransform extends MiniPhase with SymTransformer { thisPhase =>
       sym.copySymDenotation(info = tp.derivedClassInfo(selfInfo = self.info))
         .copyCaches(sym, ctx.phase.next)
     case _ =>
-      if (sym.is(Opaque))
-        sym.getAnnotation(defn.OpaqueAliasAnnot) match {
-          case Some(Annotation.OpaqueAlias(rhs, _)) =>
-            val result = sym.copySymDenotation(info = TypeAlias(rhs))
-            result.removeAnnotation(defn.OpaqueAliasAnnot)
-            result.resetFlag(Opaque)
-            result.resetFlag(Deferred)
-            result
-          case _ =>
-            sym
-        }
+      if (sym.is(Opaque)) {
+        val result = sym.copySymDenotation(info = TypeAlias(sym.opaqueAlias))
+        result.removeAnnotation(defn.OpaqueAliasAnnot)
+        result.resetFlag(Opaque | Deferred)
+        result
+      }
       else sym
   }
 

compiler/src/dotty/tools/dotc/typer/Namer.scala

@@ -110,11 +110,10 @@ trait NamerContextOps { this: Context =>
     }
     if (ctx.owner.is(Module)) {
       val opaq = ctx.owner.companionOpaqueType
-      opaq.getAnnotation(defn.OpaqueAliasAnnot) match {
-        case Some(Annotation.OpaqueAlias(rhs, _)) =>
-          localCtx = localCtx.setFreshGADTBounds
-          localCtx.gadt.setBounds(opaq, TypeAlias(rhs))
-        case _ =>
+      val alias = opaq.opaqueAlias
+      if (alias.exists) {
+        localCtx = localCtx.setFreshGADTBounds
+        localCtx.gadt.setBounds(opaq, TypeAlias(alias))
       }
     }
     localCtx