Cook raw types in Java sources

This means we can drop the special treatment of EtxExpansion for Java classes
in TypeComparer.

Author: odersky

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

@@ -602,14 +602,8 @@ class TypeComparer(initctx: Context) extends ConstraintHandling[AbsentContext] w
             finally comparedTypeLambdas = saved
           case _ =>
             val tparams1 = tp1.typeParams
-            if (tparams1.nonEmpty)
-              return recur(tp1.EtaExpand(tparams1), tp2) || fourthTry
-            tp2 match {
-              case EtaExpansion(tycon2) if tycon2.symbol.isClass && tycon2.symbol.is(JavaDefined) =>
-                return recur(tp1, tycon2)
-              case _ =>
-            }
-            fourthTry
+            tparams1.nonEmpty && recur(tp1.EtaExpand(tparams1), tp2)
+            || fourthTry
         }
         compareTypeLambda
       case OrType(tp21, tp22) =>
@@ -772,14 +766,9 @@ class TypeComparer(initctx: Context) extends ConstraintHandling[AbsentContext] w
       case tp1: RecType =>
         isNewSubType(tp1.parent)
       case tp1: HKTypeLambda =>
-        def compareHKLambda = tp1 match {
-          case EtaExpansion(tycon1) if tycon1.symbol.isClass && tycon1.symbol.is(JavaDefined) =>
-            recur(tycon1, tp2)
-          case _ => tp2 match {
-            case tp2: HKTypeLambda => false // this case was covered in thirdTry
-            case _ => tp2.typeParams.hasSameLengthAs(tp1.paramRefs) && isSubType(tp1.resultType, tp2.appliedTo(tp1.paramRefs))
-          }
-        }
+        def compareHKLambda = tp2 match
+          case tp2: HKTypeLambda => false // this case was covered in thirdTry
+          case _ => tp2.typeParams.hasSameLengthAs(tp1.paramRefs) && isSubType(tp1.resultType, tp2.appliedTo(tp1.paramRefs))
         compareHKLambda
       case AndType(tp11, tp12) =>
         val tp2a = tp2.dealiasKeepRefiningAnnots

compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala

@@ -33,8 +33,8 @@ object ClassfileParser {
   /** Replace raw types with wildcard applications */
   def cook(implicit ctx: Context): TypeMap = new TypeMap {
     def apply(tp: Type): Type = tp match {
-      case tp: TypeRef if tp.symbol.typeParams.nonEmpty =>
-        AppliedType(tp, tp.symbol.typeParams.map(Function.const(TypeBounds.empty)))
+      case tp: TypeRef if tp.typeParams.nonEmpty =>
+        AppliedType(tp, tp.typeParams.map(Function.const(TypeBounds.empty)))
       case tp @ AppliedType(tycon, args) =>
         // disregard tycon itself, but map over it to visit the prefix
         tp.derivedAppliedType(mapOver(tycon), args.mapConserve(this))
@@ -44,6 +44,8 @@ object ClassfileParser {
       case tp @ TempClassInfoType(parents, _, _) =>
         val parents1 = parents.mapConserve(this)
         if (parents eq parents1) tp else tp.copy(parentTypes = parents1)
+      case tp: ClassInfo =>
+        tp.derivedClassInfo(classParents = tp.classParents.mapConserve(this))
       case _ =>
         mapOver(tp)
     }

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

@@ -6,6 +6,7 @@ import core._
 import ast._
 import Trees._, StdNames._, Scopes._, Denotations._, Comments._
 import Contexts._, Symbols._, Types._, SymDenotations._, Names._, NameOps._, Flags._, Decorators._
+import classfile.ClassfileParser
 import NameKinds.DefaultGetterName
 import TypeApplications.TypeParamInfo
 import ast.desugar, ast.desugar._
@@ -919,6 +920,9 @@ class Namer { typer: Typer =>
       end if
     }
 
+    protected def cookIfJava(tp: Type)(using Context): Type =
+      if ctx.compilationUnit.isJava then ClassfileParser.cook.apply(tp) else tp
+
     /** Intentionally left without `implicit ctx` parameter. We need
      *  to pick up the context at the point where the completer was created.
      */
@@ -929,7 +933,7 @@ class Namer { typer: Typer =>
       denot.info = typeSig(sym)
       invalidateIfClashingSynthetic(denot)
       Checking.checkWellFormed(sym)
-      denot.info = avoidPrivateLeaks(sym)
+      denot.info = cookIfJava(avoidPrivateLeaks(sym))
     }
   }
 
@@ -1288,7 +1292,7 @@ class Namer { typer: Typer =>
 
       Checking.checkWellFormed(cls)
       if (isDerivedValueClass(cls)) cls.setFlag(Final)
-      cls.info = avoidPrivateLeaks(cls)
+      cls.info = cookIfJava(avoidPrivateLeaks(cls))
       cls.baseClasses.foreach(_.invalidateBaseTypeCache()) // we might have looked before and found nothing
       cls.setNoInitsFlags(parentsKind(parents), untpd.bodyKind(rest))
       if (cls.isNoInitsClass) cls.primaryConstructor.setFlag(StableRealizable)