fix comments

Author: changvvb

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

@@ -34,7 +34,7 @@ object ContextOps:
               if (elem.name == name) return elem.sym.denot // return self
             }
             val pre = ctx.owner.thisType
-            if (ctx.isJava) then javaFindMember(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.
@@ -43,34 +43,40 @@ object ContextOps:
           ctx.scope.denotsNamed(name).filterWithFlags(required, excluded).toDenot(NoPrefix)
       }
 
-    // Only invoke this when ctx.isJava == true
     final def javaFindMember(name: Name, pre: Type, required: FlagSet = EmptyFlags, excluded: FlagSet = EmptyFlags): Denotation =
+      assert(ctx.isJava)
       inContext(ctx) {
+
         val preSym = pre.typeSymbol
-        val denot = pre.findMember(name, pre, required, excluded)
-        if (denot.exists || preSym.isPackageObject || !preSym.isClass) denot
-        else {
-          // 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
+
+        // 1. Try to search in current type and parents
+        val directSearch = pre.findMember(name, pre, required, excluded)
+
+        // 2. Try to search in companion class if current is an object
+        def searchCompanionClass = if preSym.is(Flags.Module) then
+          preSym.companionClass.thisType.findMember(name, pre, required, excluded)
+          else NoDenotation
+
+        // 3. Try to search in companion objects of super classes.
+        // In Java code, static inner 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.
+        def searchSuperCompanionObjects =
+          val toSearch = if preSym.is(Flags.Module) then
             if preSym.companionClass.exists then
               preSym.companionClass.asClass.baseClasses
             else Nil
           else
             preSym.asClass.baseClasses
 
           toSearch.iterator.map { bc =>
-            val pre1 = bc.thisType
-            val found =  pre1.findMember(name,pre,required,excluded | Flags.TypeParam)
-            found match {
-              case NoDenotation =>
-                val companionModule = pre1.typeSymbol.companionClass
-                val pre2 = companionModule.thisType
-                pre2.findMember(name, pre2, required, excluded)
-              case denot => denot
-            }
+            val pre1 = bc.thisType.typeSymbol.companionClass.thisType
+            pre1.findMember(name, pre1, required, excluded)
           }.find(_.exists).getOrElse(NoDenotation)
-        }
+
+        if preSym.isClass then
+          directSearch orElse searchCompanionClass orElse searchSuperCompanionObjects
+        else
+          directSearch
       }
 
     /** A fresh local context with given tree and owner.

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

@@ -145,9 +145,11 @@ trait TypeAssigner {
       // this is exactly what Erasure will do.
       case _ =>
         val pre = maybeSkolemizePrefix(qualType, name)
-        var mbr = qualType.findMember(name, pre)
-        if(!mbr.exists && ctx.isJava && pre.typeSymbol.isClass)
-          mbr = ctx.javaFindMember(name,pre)
+        val mbr =
+          if ctx.isJava && pre.typeSymbol.isClass then
+            ctx.javaFindMember(name, pre)
+          else
+            qualType.findMember(name, pre)
 
         if reallyExists(mbr) then qualType.select(name, mbr)
         else if qualType.isErroneous || name.toTermName == nme.ERROR then UnspecifiedErrorType