Type matching on structural types does not work (nor gives an error)

[p-pavel]

Compiler version

3.1.2

Minimized code

type F[t] =
  t match
    case {type A = Float} => Int
    case {type A = Int} => String

val a: F[{type A = Float}] = 10
val b: F[{type A = Int}] = "asd" // Found:("asd" : String) Required: F[Object{A = Int}]

Output

Found:("asd" : String) Required: F[Object{A = Int}]

Expectation

I expect the compiler to either do the right match (accepting string value for val b) or give some diagnostic about the limitation of match types not playing with structural patterns

[prolativ]

There used to be a workaround for that

type FAux[A0] = {type A = A0}

type F[t] =
  t match
    case FAux[a] => a match
      case Float => Int
      case Int => String

val a: F[{type A = Float}] = 10
val b: F[{type A = Int}] = "asd"

however this stopped working because of the regression #15319.
The original example from this issue seems to have never worked.

[odersky]

In main I see the following diagnostic:

7 |val b: F[{type A = Int}] = "asd" // Found:("asd" : String) Required: F[Object{A = Int}]
  |                           ^^^^^
  |               Found:    ("asd" : String)
  |               Required: F[Object{A = Int}]
  |
  |               Note: a match type could not be fully reduced:
  |
  |                 trying to reduce  F[Object{A = Int}]
  |                 failed since selector  Object{A = Int}
  |                 does not match  case Object{A = Float} => Int
  |                 and cannot be shown to be disjoint from it either.
  |                 Therefore, reduction cannot advance to the remaining case
  |
  |                   case Object{A = Int} => String
  |

So it explains what goes wrong, but we should be able to make the disjointness check more precise, so that this passes.