Fix .toTuple insertion (#22028)

SIP 58 postulates an implicit insertion ot `.toTuple` when the target is
a tuple and the source is a named tuple. This was previously not fully
implemented. The implementation did not follow aliases or upper bounds
when deciding whether something was a named tuple. This is fixed in this
PR.

Author: odersky

Diff for: compiler/src/dotty/tools/dotc/core/TypeUtils.scala

@@ -145,6 +145,15 @@ class TypeUtils:
       case defn.NamedTuple(_, _) => true
       case _ => false
 
+    def derivesFromNamedTuple(using Context): Boolean = self match
+      case defn.NamedTuple(_, _) => true
+      case tp: MatchType =>
+        tp.bound.derivesFromNamedTuple || tp.reduced.derivesFromNamedTuple
+      case tp: TypeProxy => tp.superType.derivesFromNamedTuple
+      case tp: AndType => tp.tp1.derivesFromNamedTuple || tp.tp2.derivesFromNamedTuple
+      case tp: OrType => tp.tp1.derivesFromNamedTuple && tp.tp2.derivesFromNamedTuple
+      case _ => false
+
     /** Drop all named elements in tuple type */
     def stripNamedTuple(using Context): Type = self.normalized.dealias match
       case defn.NamedTuple(_, vals) =>

Diff for: compiler/src/dotty/tools/dotc/interactive/Completion.scala

@@ -543,7 +543,7 @@ object Completion:
             .groupByName
 
       val qualTpe = qual.typeOpt
-      if qualTpe.isNamedTupleType then
+      if qualTpe.derivesFromNamedTuple then
         namedTupleCompletionsFromType(qualTpe)
       else if qualTpe.derivesFrom(defn.SelectableClass) then
         val pre = if !TypeOps.isLegalPrefix(qualTpe) then Types.SkolemType(qualTpe) else qualTpe

Diff for: compiler/src/dotty/tools/dotc/transform/PatternMatcher.scala

@@ -107,7 +107,7 @@ object PatternMatcher {
         // TODO: Drop Case once we use everywhere else `isPatmatGenerated`.
 
     private def dropNamedTuple(tree: Tree): Tree =
-      val tpe = tree.tpe.widen
+      val tpe = tree.tpe.widenDealias
       if tpe.isNamedTupleType then tree.cast(tpe.stripNamedTuple) else tree
 
     /** The plan `let x = rhs in body(x)` where `x` is a fresh variable */

Diff for: compiler/src/dotty/tools/dotc/typer/Implicits.scala

@@ -876,7 +876,7 @@ trait Implicits:
        || inferView(dummyTreeOfType(from), to)
             (using ctx.fresh.addMode(Mode.ImplicitExploration).setExploreTyperState()).isSuccess
           // TODO: investigate why we can't TyperState#test here
-       || from.widen.isNamedTupleType && to.derivesFrom(defn.TupleClass)
+       || from.widen.derivesFromNamedTuple && to.derivesFrom(defn.TupleClass)
            && from.widen.stripNamedTuple <:< to
        )
 

Diff for: compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -2706,7 +2706,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
             body1.isInstanceOf[RefTree] && !isWildcardArg(body1)
             || body1.isInstanceOf[Literal]
           val symTp =
-            if isStableIdentifierOrLiteral || pt.isNamedTupleType then pt
+            if isStableIdentifierOrLiteral || pt.dealias.isNamedTupleType then pt
               // need to combine tuple element types with expected named type
             else if isWildcardStarArg(body1)
                     || pt == defn.ImplicitScrutineeTypeRef
@@ -4644,7 +4644,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         case _: SelectionProto =>
           tree // adaptations for selections are handled in typedSelect
         case _ if ctx.mode.is(Mode.ImplicitsEnabled) && tree.tpe.isValueType =>
-          if tree.tpe.widen.isNamedTupleType && pt.derivesFrom(defn.TupleClass) then
+          if tree.tpe.derivesFromNamedTuple && pt.derivesFrom(defn.TupleClass) then
             readapt(typed(untpd.Select(untpd.TypedSplice(tree), nme.toTuple)))
           else if pt.isRef(defn.AnyValClass, skipRefined = false)
               || pt.isRef(defn.ObjectClass, skipRefined = false)

Diff for: tests/pos/named-tuple-downcast.scala

@@ -0,0 +1,20 @@
+type Person = (name: String, age: Int)
+
+val Bob: Person = (name = "Bob", age = 33)
+
+type SI = (String, Int)
+
+def id[X](x: X): X = x
+val x: (String, Int) = Bob
+val y: SI = id(Bob)
+val and: Person & String = ???
+val _: SI = and
+val or: Person | (name: "Bob", age: 33) = ???
+val _: SI = or
+
+class C[P <: Person](p: P):
+  val x: (String, Int) = p
+
+
+
+