Improve docs styles

wip

wip

Author: zbartyzel

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

@@ -5,6 +5,7 @@ import Contexts._, Symbols._, Types._, Flags._, Scopes._, Decorators._, NameOps.
 import Denotations._
 import SymDenotations.LazyType, 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:
@@ -34,14 +35,59 @@ object ContextOps:
               if (elem.name == name) return elem.sym.denot // return self
             }
             val pre = ctx.owner.thisType
-            pre.findMember(name, pre, required, excluded)
+            if (ctx.isJava) {
+              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 = {
+      inContext(ctx) {
+        val result = {
+          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
+              if pre.typeSymbol.sourceModule.companionClass.exists then
+                pre.typeSymbol.sourceModule.companionClass.asClass.baseClasses.tail
+              else Nil
+            else
+              preSym.asClass.baseClasses.tail
+
+            val result = toSearch.iterator.map { bc =>
+              val pre1 = bc.thisType
+              val found =  pre1.findMember(name,pre,required,excluded | Flags.TypeParam)
+              val result = found match {
+                case NoDenotation =>
+                  val companionModule = pre1.typeSymbol.companionClass
+                  val pre2 = companionModule.thisType
+                  val result = pre2.findMember(name, pre2, required, excluded)
+                  // println(result.symbol.fullName)
+                  result
+                case denot => denot
+              }
+              // println((bc.show,pre1.show , pre.typeSymbol.show ,result.show))
+              result
+            }.find(_.exists).getOrElse(NoDenotation)
+            result
+          }
+        }
+        // if(name.toSimpleName.toString == "InnerInterface") {
+        //   println((pre.show, result))
+        // }
+        result
+      }
+    }
+
     /** A fresh local context with given tree and owner.
     *  Owner might not exist (can happen for self valdefs), in which case
     *  no owner is set in result context

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

@@ -2049,7 +2049,12 @@ object SymDenotations {
 
     override final def findMember(name: Name, pre: Type, required: FlagSet, excluded: FlagSet)(using Context): Denotation =
       val raw = if excluded.is(Private) then nonPrivateMembersNamed(name) else membersNamed(name)
-      raw.filterWithFlags(required, excluded).asSeenFrom(pre).toDenot(pre)
+      val result = raw.filterWithFlags(required, excluded).asSeenFrom(pre).toDenot(pre)
+      // if(name.toSimpleName.toString == "StaticInner" && this.name.toSimpleName.toString.contains("OuterBase")) {
+      //   println((this.show, raw, result, required, excluded))
+      // }
+      result
+
 
     final def findMemberNoShadowingBasedOnFlags(name: Name, pre: Type,
         required: FlagSet = EmptyFlags, excluded: FlagSet = EmptyFlags)(using Context): Denotation =

compiler/src/dotty/tools/dotc/parsing/JavaParsers.scala

@@ -901,16 +901,7 @@ object JavaParsers {
             members) ++= decls
         }
       }
-      def forwarders(sdef: Tree): List[Tree] = sdef match {
-        case TypeDef(name, _) if (parentToken == INTERFACE) =>
-          var rhs: Tree = Select(Ident(parentName.toTermName), name)
-          List(TypeDef(name, rhs).withMods(Modifiers(Flags.Protected)))
-        case _ =>
-          List()
-      }
-      val sdefs = statics.toList
-      val idefs = members.toList ::: (sdefs flatMap forwarders)
-      (sdefs, idefs)
+      (statics.toList, members.toList)
     }
     def annotationParents: List[Select] = List(
       scalaAnnotationDot(tpnme.Annotation),

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

@@ -4,7 +4,7 @@ package typer
 
 import core._
 import ast._
-import Contexts._, Constants._, Types._, Symbols._, Names._, Flags._, Decorators._
+import Contexts._, ContextOps._, Constants._, Types._, Symbols._, Names._, Flags._, Decorators._
 import ErrorReporting._, Annotations._, Denotations._, SymDenotations._, StdNames._
 import util.Spans._
 import util.SrcPos
@@ -145,7 +145,10 @@ trait TypeAssigner {
       // this is exactly what Erasure will do.
       case _ =>
         val pre = maybeSkolemizePrefix(qualType, name)
-        val mbr = qualType.findMember(name, pre)
+        var mbr = qualType.findMember(name, pre)
+        if(!mbr.exists && ctx.isJava && pre.typeSymbol.isClass)
+          mbr = ctx.javaFindMember(name,pre)
+
         if reallyExists(mbr) then qualType.select(name, mbr)
         else if qualType.isErroneous || name.toTermName == nme.ERROR then UnspecifiedErrorType
         else NoType

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

@@ -367,7 +367,9 @@ class Typer extends Namer
             if (qualifies(defDenot)) {
               val found =
                 if (isSelfDenot(defDenot)) curOwner.enclosingClass.thisType
-                else {
+                else if(ctx.isJava && defDenot.symbol.isStatic) {
+                  defDenot.symbol.namedType
+                } else {
                   val effectiveOwner =
                     if (curOwner.isTerm && defDenot.symbol.maybeOwner.isType)
                       // Don't mix NoPrefix and thisType prefixes, since type comparer
@@ -379,6 +381,7 @@ class Typer extends Namer
                 }
               if !curOwner.is(Package) || isDefinedInCurrentUnit(defDenot) then
                 result = checkNewOrShadowed(found, Definition) // no need to go further out, we found highest prec entry
+                // println((found.show, defDenot.show, ctx.owner.show))
                 found match
                   case found: NamedType if curOwner.isClass && isInherited(found.denot) =>
                     checkNoOuterDefs(found.denot, ctx, ctx)
@@ -2133,6 +2136,10 @@ class Typer extends Namer
     if (sym.isOneOf(GivenOrImplicit)) checkImplicitConversionDefOK(sym)
     val tpt1 = checkSimpleKinded(typedType(tpt))
 
+    if(name.toSimpleName.toString == "create") {
+      // println((tpt,tpt1.show))
+    }
+
     val rhsCtx = ctx.fresh
     val tparamss = paramss1.collect {
       case untpd.TypeDefs(tparams) => tparams