`lazy val` parameters and overrides

[spamegg1]

Compiler version

3.3.1

Minimized example

trait Spam:
  lazy val egg: Int

// Attempting to override a `lazy val` with a class parameter which is a `val`
class Spammy(val egg: Int) extends Spam

Output Error/Warning message

-- [E164] Declaration Error: ----------------------------------------------------------
1 |class Spammy(val egg: Int) extends Spam
  |                 ^
  |                 error overriding lazy value egg in trait Spam of type Int;
  |                   value egg of type Int must be declared lazy to override a lazy value
1 error found

Why this Error/Warning was not helpful

The message was unhelpful because... it suggests to add the lazy modifier in front of the class parameter val. But that is already not allowed:

class Spammy(lazy val egg: Int) extends Spam
//                    ^
//                    error: parameter may not be `lazy`

Suggested improvement

It could be made more helpful by... saying something like overriding a lazy val with a parameter is impossible, since the overriding value must be declared lazy but parameters cannot be lazy.

A Note on Scala 2

Scala 2 also has a related but different issue. When attempting to use a lazy val as a class parameter, it suggests using a call-by-name parameter:

// This is Scala 2.13
scala> trait Spam {
     |   val egg: Int
     | }
trait Spam

scala> class Spammy(lazy val egg: Int) extends Spam
                          ^
       error: lazy modifier not allowed here. Use call-by-name parameters instead

which suggests adding => in front of the type, but that is already not allowed for val parameters:

// This is Scala 2.13
scala> class Spammy(val egg: => Int) extends Spam
                              ^
       error: `val` parameters may not be call-by-name

It could be made more helpful by saying something like Use call-by-name parameters that are not vals instead.

I guess what I did could be considered "user error" but it's quite natural for newcomers to try these and get confused.

[odersky]

In this case it's really hard to guess what the user wanted to achieve. Maybe it's essential that it is a val, and the lazy is optional? I am not sure there's a clear way to improve the reporting here. Maybe the best thing we could do is to actually make lazy vals in classes compile.

[spamegg1]

I agree it's an unusual situation. It arose when I was trying to port some Scala 2 library to Scala 3. https://github.com/cascala/galileo/blob/master/src/main/scala/expr/LinAlg.scala

In Scala 2, a lazy val is able to override a val (as the above library does) but this is not allowed in Scala 3. So I was trying to find ways around this. I tried to make the val lazy in the trait declaration itself, but that led to problems since some of them were being received (with the same name) as class parameters by subclasses. Then I tried the above...

I suppose someone else might not attempt to do this naturally, although I think the error message is still confusing because it suggests adding lazy in front of a class parameter, which is not allowed. The override keyword is allowed in front of a class parameter val, right? But lazy is not...

scala> class Spammy2(override val egg: Int) extends Spam
-- [E164] Declaration Error: -------------------------------------------------------------------------------------------
1 |class Spammy2(override val egg: Int) extends Spam
  |                           ^
  |                           error overriding lazy value egg in trait Spam of type Int;
  |                             value egg of type Int must be declared lazy to override a lazy value
1 error found
                                                                                                                        
scala> class Spammy2(override lazy val egg: Int) extends Spam
-- Error: --------------------------------------------------------------------------------------------------------------
1 |class Spammy2(override lazy val egg: Int) extends Spam
  |                                ^
  |                                parameter may not be `lazy`
1 error found

// This is OK
scala> trait Spam:
     |   val egg: Int = 5
     | 
// defined trait Spam
                                                                                                                        
scala> class Spammy2(override val egg: Int) extends Spam
// defined class Spammy2

It could be chalked up to my own ignorance of the language mechanisms but I still think it's confusing...