Final val of Java enum is not a constant value

[som-snytt]

Compiler version

3.5.2

Minimized code

class C:

  final val Seconds = java.util.concurrent.TimeUnit.SECONDS
  //inline val SecondSeconds = java.util.concurrent.TimeUnit.SECONDS // not a literal

  @OutputTimeUnit(Seconds)
  def f(): Unit = ()

  @OutputTimeUnit(java.util.concurrent.TimeUnit.SECONDS)
  def ok(): Unit = ()

where

import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.util.concurrent.TimeUnit;

@Inherited
@Target({ElementType.METHOD,ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface OutputTimeUnit {

    /**
     * @return Time unit to use.
     */
    TimeUnit value();

}

Output

7 |  @OutputTimeUnit(Seconds)
  |                  ^^^^^^^
  |                  Annotation argument is not a constant

Expectation

Works as in Scala 2.

Spec says platform enum is a constant value expression; Seconds is a constant value definition.

[dwijnand]

I'm not sure I agree with that. Marking it final makes it illegal to override. And by "constant" I think annotations mean a statically constant value. Which java.util.concurrent.TimeUnit.SECONDS is, but I believe this breaks down because final val Seconds isn't typed to be that precise - in Scala 3. So unless we can prove that the reason Scala 3 doesn't type final val Seconds as precisely as Scala 2 did is invalid, I think this isn't a bug.

[som-snytt]

The spec still says about a constant value definition:

References to the constant value x are themselves treated as constant expressions; in the generated code they are replaced by the definition's right-hand side e.

It's no excuse to say Scala 3 has inline and enum, so it can't handle constant values any more, because it is somehow confused about how to type it.

[lrytz]

EnumTag was removed in ab257d62ae, so a ConstantType can no longer represent a Java enum value. Unlike Scala 2.

I agree @som-snytt that this is a regression. On the other hand, Scala 2 is also incomplete. The spec says

A constant value definition is of the form
final val x = e
where e is a constant expression. [...] References to the constant value x are themselves treated as constant expressions.
...
"constant expression" depends on the platform, but they include at least
...

• An element of an enumeration from the underlying platform
• A literal array, of the form Array(c1,…,cn)(c1​,…,cn​)

But the following doesn't work in Scala 2:

public @interface Ann {
  int i() default 0;
  int[] is() default {};
}

scala> object T { final val x = 3; final val xs = Array(4, 5) }
object T

scala> @Ann(i = T.x) class C
class C

scala> @Ann(is = T.xs) class C
                   ^
       error: annotation argument needs to be a constant; found: T.xs

scala> @Ann(is = Array(4, 5)) class C
class C

Maybe there's a different solution to make this work than supporting enum values and array literals in Constant?