Add outer param when java inner class instantiated

compiler/src/dotty/tools/dotc/transform/Erasure.scala

@@ -931,7 +931,7 @@ object Erasure {
 
     /** The outer parameter definition of a constructor if it needs one */
     private def outerParamDefs(constr: Symbol)(using Context): List[ValDef] =
-      if constr.isConstructor && hasOuterParam(constr.owner.asClass) then
+      if constr.isConstructor && needsOuterParam(constr.owner.asClass) then
         constr.info match
           case MethodTpe(outerName :: _, outerType :: _, _) =>
             val outerSym = newSymbol(constr, outerName, Flags.Param, outerType)

compiler/src/dotty/tools/dotc/transform/ExplicitOuter.scala

@@ -245,9 +245,9 @@ object ExplicitOuter {
   private def hasOuter(cls: ClassSymbol)(using Context): Boolean =
     needsOuterIfReferenced(cls) && outerAccessor(cls).exists
 
-  /** Class constructor takes an outer argument. Can be called only after phase ExplicitOuter. */
-  def hasOuterParam(cls: ClassSymbol)(using Context): Boolean =
-    !cls.is(Trait) && needsOuterIfReferenced(cls) && outerAccessor(cls).exists
+  /** Class constructor needs an outer argument. Can be called only after phase ExplicitOuter. */
+  def needsOuterParam(cls: ClassSymbol)(using Context): Boolean =
+    !cls.is(Trait) && needsOuterIfReferenced(cls) && (cls.is(JavaDefined) || outerAccessor(cls).exists)
 
   /** Tree references an outer class of `cls` which is not a static owner.
    */
@@ -357,7 +357,7 @@ object ExplicitOuter {
 
     /** If `cls` has an outer parameter add one to the method type `tp`. */
     def addParam(cls: ClassSymbol, tp: Type): Type =
-      if (hasOuterParam(cls)) {
+      if (needsOuterParam(cls)) {
         val mt @ MethodTpe(pnames, ptypes, restpe) = tp
         mt.derivedLambdaType(
           nme.OUTER :: pnames, outerClass(cls).typeRef :: ptypes, restpe)
@@ -378,7 +378,7 @@ object ExplicitOuter {
           case TypeApply(Select(r, nme.asInstanceOf_), args) =>
             outerArg(r) // cast was inserted, skip
         }
-        if (hasOuterParam(cls))
+        if (needsOuterParam(cls))
           methPart(fun) match {
             case Select(receiver, _) => outerArg(receiver).withSpan(fun.span) :: Nil
           }
@@ -390,7 +390,7 @@ object ExplicitOuter {
      *  argument, the singleton list with the argument, otherwise Nil.
      */
     def argsForNew(cls: ClassSymbol, tpe: Type): List[Tree] =
-      if (hasOuterParam(cls)) singleton(fixThis(outerPrefix(tpe))) :: Nil
+      if (needsOuterParam(cls)) singleton(fixThis(outerPrefix(tpe))) :: Nil
       else Nil
 
     /** A path of outer accessors starting from node `start`. `start` defaults to the

tests/run/10838/A.java

@@ -0,0 +1,3 @@
+public class A {
+  public class B {}
+}

tests/run/10838/Test.scala

@@ -0,0 +1,6 @@
+object Test {
+  def main(args: Array[String]): Unit = {
+    val a = new A
+    new a.B
+  }
+}