hasOuterParam -> needsOuterParam

Author: changvvb

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,8 +245,8 @@ 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 =
+  /** Class constructor needs an outer argument. Can be called only after phase ExplicitOuter. */
+  def needsOuterParam(cls: ClassSymbol)(using Context): Boolean =
     !cls.is(Trait) && needsOuterAlways(cls)
 
   /** 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