Fix #4342: When calling a Scala 2.x method with an outer parameter, adapt to the old behavior in picking the outer parameter's type, i.e., prefer the enclosing class's self type, rather than the enclosing class itself.

Author: gsps

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

@@ -336,12 +336,26 @@ object ExplicitOuter {
   class OuterOps(val ictx: Context) extends AnyVal {
     private implicit def ctx: Context = ictx
 
+    /** Scala 2.x and Dotty don't always agree on what should be the type of the outer parameter,
+     *  so we replicate the old behavior when passing arguments to methods coming from Scala 2.x.
+     */
+    private def outerType(cls: ClassSymbol): Type = {
+      val encl = cls.owner.enclosingClass
+      if (cls.is(Scala2x))
+        encl.asClass.classInfo.selfInfo match {
+          case tp: TypeRef => tp.classSymbol.typeRef
+          case self: Symbol => self.typeRef
+          case _ => encl.typeRef
+        }
+      else encl.typeRef
+    }
+
     /** If `cls` has an outer parameter add one to the method type `tp`. */
     def addParam(cls: ClassSymbol, tp: Type): Type =
       if (hasOuterParam(cls)) {
         val mt @ MethodTpe(pnames, ptypes, restpe) = tp
         mt.derivedLambdaType(
-          nme.OUTER :: pnames, cls.owner.enclosingClass.typeRef :: ptypes, restpe)
+          nme.OUTER :: pnames, outerType(cls) :: ptypes, restpe)
       } else tp
 
     /** If function in an apply node is a constructor that needs to be passed an