Named Tuple binding from IArray.unapplySeq pattern can't select fields.

[bishabosha]

Compiler version

3.6.2-RC3

Minimized code

//> using options -experimental -language:experimental.namedTuples
val dirs = IArray(
  (dx = 0, dy = 1), // up
  (dx = 1, dy = 0), // right
  (dx = 0, dy = -1), // down
  (dx = -1, dy = 0), // left
)

val IArray(Up @ _, _, _, _) = dirs

def Test = println(Up.dx)

Output

-- [E008] Not Found Error: -----------------------------------------------------
10 |def Test = println(Up.dx)
   |                   ^^^^^
   |value dx is not a member of Array.UnapplySeqWrapper[? <: (dx : Int, dy : Int)]#T
1 error found

Expectation

selection should work, like it does if the pattern were Array.unapplySeq or Seq.unapplySeq

[smarter]

The logic in

scala3/compiler/src/dotty/tools/dotc/core/TypeUtils.scala

Line 131 in 285cd40

(if normalize then self.normalized else self).dealias match

only dealiases/normalizes the type before checking if it's a NamedTuple, so it doesn't work on any proper subtype of a NamedTuple:

object Test:
  def foo[T <: (x: Int, y: String)](tup: T): Int =
    tup.x // error
  
  def bar[T](tup: (x: Int, y: String) & T): Int =
    tup.x // error

[smarter]

It seems like there's a lot of inconsistencies in how we check whether something is a NamedTuple, sometimes we do .dealias, sometimes .normalized, sometimes .widen, or .widenDealias, ... I think "derivesFromNamedTuple" has it right:

scala3/compiler/src/dotty/tools/dotc/core/TypeUtils.scala

Lines 148 to 155 in 285cd40

	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

What about just moving all that logic in the NamedTuple extractor so we can just do case NamedTuple(...) everywhere without having to sprinkle some combination of .widen/.dealias/.normalize ?

[soronpo]

And provide that as macro API too