Show real type names in error messages

In #4323 I was concerned about writing incorrect names for types in error messages.

Writing Expr’ in the error seems a (separate?) bug:

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

because it’s false that “Expr' is a trait”. A bit better would be:

   |                                    where:    Expr  refers to object Expr
   |                                              Expr' refers to trait Expr

But even better would be to have a clearer syntax for these “footnotes”, something where the annotation is more clearly separate from the Scala syntax. For instance, if we use @ (which is reserved and can’t be used in types, I think):

   |                                    where:    Expr@1  refers to object Expr
   |                                              Expr@2 refers to trait Expr

[Blaisorblade]

“Expr1 is an object in package foo.bla.baz”. I just dislike using import renaming to express this.

Import renaming also seems unconvincing, but again, we shouldn’t write that Expr₁ isn’t an object, because that object is called Expr. I’d say that Expr₁ isn’t an object.

Expr@1 is almost valid Scala syntax too, and having to read error message “as interpreted under a given set of renaming” is likely to endlessly confuse beginners. My preference would be to use unicode subscripts: Expr1, Expr2, we could also differentiate them using colors.

I agree with Unicode subscripts are better if we can rely on Unicode, since they’re not allowed in Scala.

Which we probably often can. Otherwise, Expr@1 was the best idea I had within ASCII after skimming https://stackoverflow.com/a/7657692, but I’m not sure it’s much better.

[smarter]

We can also have a longer description such as “Expr₁ is an object in package foo.bla.baz”. I just dislike using import renaming to express this. Note that import renaming is not enough anyway because some types do not have a stable path, e.g.:

class Foo {
  def meth = {
    class Expr
    def expr(e: Expr) = {}

    def bla = {
      class Expr
      expr(new Expr)
    }
  }
}

Here’s the error Dotty outputs currently:

8 |      expr(new Expr)
  |               ^^^^
  |               found:    Expr
  |               required: Expr'
  |               
  |               where:    Expr  is a class in method bla
  |                         Expr' is a class in method meth