Definitions within Enum should report errors

[b-studios]

Compiler version

Latest dotty on Scastie (3.2.0-RC1)

Minimized code

enum MyEnum {
  case class Foo(n: Int)

  case Constructor(field: Foo)
}

Output

enum MyEnum {
  case class Foo(n: Int)

  case Constructor(field: Foo)
  // Not found: type Foo  ^^^
}

Expectation

If definitions within enums cannot be referred to, they should be forbidden. The error message in this case should be something along the lines of:

enum MyEnum {
  case class Foo(n: Int)
 // case class definitions in enum not allowed. 

  case Constructor(field: Foo) 
}

[som-snytt]

There is some guidance under "Restrictions":

https://dotty.epfl.ch/docs/reference/enums/enums.html

Enum case declarations are similar to secondary constructors: they are scoped outside of the enum template, despite being declared within it. This means that enum case declarations cannot access inner members of the enum class.

Sample utility:

enum MyEnum {
  case class Foo(n: Int)
  def foo: Foo =
    this match
      case Constructor(x) => Foo(x)

  //case Constructor(field: Foo)
  case Constructor(i: Int)
}

@main def test() = println {
  import MyEnum.*
  Constructor(42).foo
}

[Kordyjan]

As it is right now it can be really confusing. I wonder if we can improve the error reported to explain why the symbol is not visible.

[bishabosha]

its only within the enum cases that Foo is not visible, it would be visible inside methods e.g.

[som-snytt]

I think the words I quoted would be helpful in the error message. Something like:

Note that enum case declarations cannot access inner members of the enum class. Enum case declarations are similar to secondary constructors: they are scoped outside of the enum template, despite being declared within it.

That is a lot of words, but it is an edge case. Users are likely to see the message at some point, because it is a gotcha for enums, but thereafter, they would not be likely to see the message over and over.

[b-studios]

its only within the enum cases that Foo is not visible, it would be visible inside methods e.g.

If this is true, why doesn't qualifying it work?

enum MyEnum {
  case class Foo(n: Int)

  case Constructor(field: MyEnum.Foo)
}

[bishabosha]

in your example, Foo is an inner class of the MyEnum class, not a member of the MyEnum object, if you don't want it to be an inner member of MyEnum class then you should create a separate MyEnum object and put Foo there

[b-studios]

I see, thanks @bishabosha. I think this is horribly confusing :)

[som-snytt]

The example at the doc link includes putting the member in the companion and how to reference it.

I agree it's unfortunately confusing.