Show real type names in error messages

[Blaisorblade]

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

[LPTK]

I was really confused because of this at first, when reading Dotty error messages. I absolutely concur that error messages should not make up facts such as "Expr' is a trait", a fortiori when Expr' is a valid name in other functional languages and even in some forks of Scalac.

Also, the current where clause is very uninformative – "Expr is an object"... okay, which object exactly?

Instead, why not change the where clause to actual Scala syntax, which would make its meaning much more intuitive? For example, say we have a mismatch between types involving my.module.Expr and other.module.Expr; it could look like:

   |                                    found:    (Expr, Expr0)
   |                                    required: (Expr0, Expr)
   |                                    
   |                                    as interpreted under:
   |                                              import my.module.Expr
   |                                              import other.module.{Expr => Expr0}

Or, which I would personally find better, keep a shortened prefix (only in case of ambiguity obviously):

   |                                    found:    (mm.Expr, om.Expr)
   |                                    required: (om.Expr, mm.Expr)
   |                                    
   |                                    as interpreted under:
   |                                              import my.{module => mm}
   |                                              import other.{module => om}

[smarter]

I'm not a fan of either solution 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: Expr₁, Expr₂, we could also differentiate them using colors.

[LPTK]

having to read error message "as interpreted under a given set of renaming" is likely to endlessly confuse beginners

Isn't that exactly what is being done now, but with less clarity?

How will users know which types Expr₁ and Expr₂ are, if you're not going to list the set of renamings?

[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

[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.

[ckipp01]

Reading through this, it's a bit hard to actually pinpoint what we're trying to fix compared to where we're at now. In the linked issue some of the code samples that were marked failing now work, and the output is a bit different as well. Is there a minimal code sample that can be provided here to show what exactly it is we're trying to fix/enhance?