Fix dependency status calculation for refined type aliases in method result types

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

@@ -3640,7 +3640,8 @@ object Types {
         (if status == TrueDeps then status else status | provisional).toByte
       def compute(status: DependencyStatus, tp: Type, theAcc: TypeAccumulator[DependencyStatus] | Null): DependencyStatus =
         def applyPrefix(tp: NamedType) =
-          if tp.currentSymbol.isStatic then status
+          if tp.isInstanceOf[SingletonType] && tp.currentSymbol.isStatic
+          then status // Note: a type ref with static symbol can still be dependent since the symbol might be refined in the enclosing type. See pos/15331.scala.
           else compute(status, tp.prefix, theAcc)
         if status == TrueDeps then status
         else tp match

compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala

@@ -325,7 +325,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
       case tp @ ConstantType(value) =>
         toText(value)
       case pref: TermParamRef =>
-        nameString(pref.binder.paramNames(pref.paramNum))
+        nameString(pref.binder.paramNames(pref.paramNum)) ~ lambdaHash(pref.binder)
       case tp: RecThis =>
         val idx = openRecs.reverse.indexOf(tp.binder)
         if (idx >= 0) selfRecName(idx + 1)

tests/pos/i15331.scala

@@ -0,0 +1,15 @@
+object Test:
+  trait Composable[A,B]:
+    def compose(a: A, b: B): Any
+
+  trait Arrow {type Dom; type Codom}
+
+  given composeArrows[A, Arr1 <: Arrow, Arr2 <: Arrow]: Composable[Arr1 {type Dom = A}, Arr2 {type Codom = A}] with
+    def compose(a: Arr1 {type Dom = A}, b: Arr2 {type Codom = A}): Arrow {type Dom = b.Dom; type Codom = a.Codom} = ???
+
+  object arr1 extends Arrow { type Dom = Int; type Codom = Int}
+  object arr2 extends Arrow {type Dom = Int; type Codom = Float}
+
+  // removing "transparent" alleviates the situation
+  inline transparent def compose[A, B](a: A, b: B)(using c: Composable[A,B]) = c.compose(a,b)
+  val c = compose(arr2,arr1)