Avoid unnecessary uses of parentSyms

`parentSyms` maps all parent types. We don't need that if we just want to
work on the superclass.

Author: odersky

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

@@ -1877,19 +1877,21 @@ object SymDenotations {
       super.info_=(tp)
     }
 
-    /** The symbols of the parent classes. */
-    def parentSyms(using Context): List[Symbol] = info match {
-      case classInfo: ClassInfo => classInfo.declaredParents.map(_.classSymbol)
+    /** The types of the parent classes. */
+    def parentTypes(using Context): List[Type] = info match
+      case classInfo: ClassInfo => classInfo.declaredParents
       case _ => Nil
-    }
+
+    /** The symbols of the parent classes. */
+    def parentSyms(using Context): List[Symbol] =
+      parentTypes.map(_.classSymbol)
 
     /** The symbol of the superclass, NoSymbol if no superclass exists */
-    def superClass(using Context): Symbol = parentSyms match {
-      case parent :: _ =>
-        if (parent.is(Trait)) NoSymbol else parent
-      case _ =>
-        NoSymbol
-    }
+    def superClass(using Context): Symbol = parentTypes match
+      case parentType :: _ =>
+        val parentCls = parentType.classSymbol
+        if parentCls.is(Trait) then NoSymbol else parentCls
+      case _ => NoSymbol
 
     /** The explicitly given self type (self types of modules are assumed to be
      *  explcitly given here).
@@ -1951,20 +1953,20 @@ object SymDenotations {
     def computeBaseData(implicit onBehalf: BaseData, ctx: Context): (List[ClassSymbol], BaseClassSet) = {
       def emptyParentsExpected =
         is(Package) || (symbol == defn.AnyClass) || ctx.erasedTypes && (symbol == defn.ObjectClass)
-      val psyms = parentSyms
-      if (psyms.isEmpty && !emptyParentsExpected)
+      val parents = parentTypes
+      if (parents.isEmpty && !emptyParentsExpected)
         onBehalf.signalProvisional()
       val builder = new BaseDataBuilder
-      def traverse(parents: List[Symbol]): Unit = parents match {
+      def traverse(parents: List[Type]): Unit = parents match {
         case p :: parents1 =>
-          p match {
+          p.classSymbol match {
             case pcls: ClassSymbol => builder.addAll(pcls.baseClasses)
             case _ => assert(isRefinementClass || p.isError || ctx.mode.is(Mode.Interactive), s"$this has non-class parent: $p")
           }
           traverse(parents1)
         case nil =>
       }
-      traverse(psyms)
+      traverse(parents)
       (classSymbol :: builder.baseClasses, builder.baseClassSet)
     }
 
@@ -2312,9 +2314,11 @@ object SymDenotations {
       var names = Set[Name]()
       def maybeAdd(name: Name) = if (keepOnly(thisType, name)) names += name
       try {
-        for (p <- parentSyms if p.isClass)
-          for (name <- p.asClass.memberNames(keepOnly))
-            maybeAdd(name)
+        for ptype <- parentTypes do
+          ptype.classSymbol match
+            case pcls: ClassSymbol =>
+              for name <- pcls.memberNames(keepOnly) do
+                maybeAdd(name)
         val ownSyms =
           if (keepOnly eq implicitFilter)
             if (this.is(Package)) Iterator.empty