GADT patmat doesn't narrow class type parameters

[abgruszecki]

scala> enum Expr[T] {
           case IExpr(value: Int) extends Expr[Int]
           case BExpr(value: Boolean) extends Expr[Boolean]

           def join(other: Expr[T]): Expr[T] = (this, other) match {
             case (IExpr(i1), IExpr(i2)) => IExpr(i1 + i2)
             case (BExpr(b1), BExpr(b2)) => BExpr(b1 & b2)
           }
         }
6 |      case (IExpr(i1), IExpr(i2)) => IExpr(i1 + i2)
  |                                     ^^^^^^^^^^^^^^
  |                                     found:    Expr[Int]
  |                                     required: Expr[T]
  |
7 |      case (BExpr(b1), BExpr(b2)) => BExpr(b1 & b2)
  |                                     ^^^^^^^^^^^^^^
  |                                     found:    Expr[Boolean]
  |                                     required: Expr[T]
  |

This is similar to an old issue where class/trait parameters aren't narrowed.

[allanrenucci]

The issue is not specific to enums:

sealed trait Expr[T] {
  import Expr._

   def join(other: Expr[T]): Expr[T] = (this, other) match {
     case (IExpr(i1), IExpr(i2)) => IExpr(i1 + i2)
     case (BExpr(b1), BExpr(b2)) => BExpr(b1 & b2)
   }
}

object Expr {
  case class IExpr(value: Int) extends Expr[Int]
  case class BExpr(value: Boolean) extends Expr[Boolean]
}

15 |     case (IExpr(i1), IExpr(i2)) => IExpr(i1 + i2)
   |                                    ^^^^^^^^^^^^^^
   |                                    found:    Expr.IExpr
   |                                    required: Expr'[T]
   |                                    
   |                                    where:    Expr  is a object
   |                                              Expr' is a trait
16 |     case (BExpr(b1), BExpr(b2)) => BExpr(b1 & b2)
   |                                    ^^^^^^^^^^^^^^
   |                                    found:    Expr.BExpr
   |                                    required: Expr'[T]
   |                                    
   |                                    where:    Expr  is a object
   |                                              Expr' is a trait

[Blaisorblade]

It seems method params aren't refined, but trait params are. Using this isn't necessary to trigger the error.

For instance, works:

trait Expr[T]
case class IExpr(value: Int) extends Expr[Int]
case class BExpr(value: Boolean) extends Expr[Boolean]
object Foo {
  def foo[T] = {
    def join(one: Expr[T], other: Expr[T]): Expr[T] = (one, other) match {
      case (IExpr(i1), IExpr(i2)) => IExpr(i1 + i2)
      case (BExpr(b1), BExpr(b2)) => BExpr(b1 & b2)
    }
  }
}

Fails:

object Foo {
  sealed trait Expr[T] {
    import Expr._

    def join(one: Expr[T], other: Expr[T]): Expr[T] = (one, other) match {
      case (IExpr(i1), IExpr(i2)) => IExpr(i1 + i2)
      case (BExpr(b1), BExpr(b2)) => BExpr(b1 & b2)
    }
  }

  object Expr {
    case class IExpr(value: Int) extends Expr[Int]
    case class BExpr(value: Boolean) extends Expr[Boolean]
  }
}

Writing Expr' in the error seems a (separate?) bug.

[smarter]

Writing Expr' in the error seems a (separate?) bug.

Quotes after type names are used in error messages to distinguish between several types with the same name (we could also use colors or Unicode subscripts if supported by the terminal, but quotes work everywhere)

[abgruszecki]

@Blaisorblade AFAIU, the first example works because the T used in def join(one: Expr[T], other: Expr[T]): Expr[T] is the one from def foo[T] - it's a method param. In contrast, in the second example the T is the one from sealed trait Expr[T] - it's a trait param.

[Blaisorblade]

Quotes after type names are used in error messages to distinguish between several types with the same name (we could also use colors or Unicode subscripts if supported by the terminal, but quotes work everywhere)

I know, and I'm fine with that for T and T', but the trait here is really called Expr not Expr'.

@AleksanderBG Yes, IIUC, that's what I meant with

It seems method params aren't refined, but trait params are.

[smarter]

I know, and I'm fine with that for T and T', but the trait here is really called Expr not Expr'.

So how do you propose to distinguish between the object Expr and the trait Expr in error messages?

[LPTK]

So how do you propose to distinguish between the object Expr and the trait Expr in error messages?

Why would the compiler's error messages not follow the Scala fact that a value and a type sharing the same name are not ambiguous? (They live in different namespaces.) At the very least it should not have to introduce a difference between the name of a class and its companion object.

I propose:

   |                                    where: value Expr is an object
   |                                            type Expr is a trait

[Blaisorblade]

I had a problem with this because Expr' isn't something that exists, and it even looks like actual syntax (which it isn't), and I'm fine with alpha-renaming variables but classes aren't. I think @LPTK's idea is good here, but for cases where it doesn't work I'd maybe use Expr@1 and Expr@2 and write "where Expr@1 is type Expr in ... and Expr@2 is value Expr in ...". This phrasing would arguably be already better now.

Anyway, I opened #4355 for this.

[abgruszecki]

Well, this was actually implemented in #11222, we just forgot about this particular issue. Closing now.