update test

update

Author: changvvb

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

@@ -2,10 +2,9 @@ package dotty.tools.dotc
 package core
 
 import Contexts._, Symbols._, Types._, Flags._, Scopes._, Decorators._, NameOps._
-import Denotations._
-import SymDenotations.LazyType, Names.Name, StdNames.nme
+import Denotations._, SymDenotations._
+import Names.Name, StdNames.nme
 import ast.untpd
-import dotty.tools.dotc.core.SymDenotations.NoDenotation
 
 /** Extension methods for contexts where we want to keep the ctx.<methodName> syntax */
 object ContextOps:
@@ -35,19 +34,17 @@ object ContextOps:
               if (elem.name == name) return elem.sym.denot // return self
             }
             val pre = ctx.owner.thisType
-            if (ctx.isJava) {
-              javaFindMember(name, pre, required, excluded)
-            } else {
-              pre.findMember(name, pre, required, excluded)
-            }
+            if (ctx.isJava) then javaFindMember(name, pre, required, excluded)
+            else pre.findMember(name, pre, required, excluded)
           }
           else // we are in the outermost context belonging to a class; self is invisible here. See inClassContext.
             ctx.owner.findMember(name, ctx.owner.thisType, required, excluded)
         else
           ctx.scope.denotsNamed(name).filterWithFlags(required, excluded).toDenot(NoPrefix)
       }
 
-    final def javaFindMember(name: Name,  pre: Type, required: FlagSet = EmptyFlags, excluded: FlagSet = EmptyFlags): Denotation = {
+    // Only invoke this when ctx.isJava == true
+    final def javaFindMember(name: Name, pre: Type, required: FlagSet = EmptyFlags, excluded: FlagSet = EmptyFlags): Denotation =
       inContext(ctx) {
         val preSym = pre.typeSymbol
         val denot = pre.findMember(name, pre, required, excluded)
@@ -56,11 +53,11 @@ object ContextOps:
           // In Java code, static innner classes, which we model as members of the companion object,
           // can be referenced from an ident in a subclass or by a selection prefixed by the subclass.
           val toSearch = if (preSym.is(Flags.Module)) then
-            if pre.typeSymbol.sourceModule.companionClass.exists then
-              pre.typeSymbol.sourceModule.companionClass.asClass.baseClasses.tail
+            if preSym.companionClass.exists then
+              preSym.companionClass.asClass.nonSelfBaseClasses
             else Nil
           else
-            preSym.asClass.baseClasses.tail
+            preSym.asClass.nonSelfBaseClasses
 
           toSearch.iterator.map { bc =>
             val pre1 = bc.thisType
@@ -69,14 +66,12 @@ object ContextOps:
               case NoDenotation =>
                 val companionModule = pre1.typeSymbol.companionClass
                 val pre2 = companionModule.thisType
-                val result = pre2.findMember(name, pre2, required, excluded)
-                result
+                pre2.findMember(name, pre2, required, excluded)
               case denot => denot
             }
           }.find(_.exists).getOrElse(NoDenotation)
         }
       }
-    }
 
     /** A fresh local context with given tree and owner.
     *  Owner might not exist (can happen for self valdefs), in which case

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

@@ -1866,6 +1866,9 @@ object SymDenotations {
     def baseClasses(implicit onBehalf: BaseData, ctx: Context): List[ClassSymbol] =
       baseData._1
 
+    def nonSelfBaseClasses(implicit onBehalf: BaseData, ctx: Context): List[ClassSymbol] =
+      baseClasses.tail
+
     /** Like `baseClasses.length` but more efficient. */
     def baseClassesLength(using BaseData, Context): Int =
       // `+ 1` because the baseClassSet does not include the current class unlike baseClasses

compiler/test/dotc/run-test-pickling.blacklist

@@ -35,5 +35,5 @@ varargs-abstract
 zero-arity-case-class.scala
 i12194.scala
 i12753
-t1638
-t1638-2
+t6138
+t6138-2