Generative enums don't work if used alongside const constructors of classes

[srikrsna]

The code snippet below doesn't work,

enum Gaps {
  one(6);

  final SizedBox vBox, hBox, box;
  final double size;
  const Gaps(this.size)
      : box = const SizedBox(width: size, height: size),
        hBox = const SizedBox(width: size),
        vBox = const SizedBox(height: size);
}

It doesn't recognize size as constant. Am I missing something here because as far as I understand it is only possible to use generative enums with const values.

[eernstg]

This is actually working as intended. The parameter declaration this.size introduces a local variable into a special scope which is only accessible in the initializer list, and this means that we can use size const SomeClass(this.size): .../*here!*/...;.

But even though size is in scope in the initializer list, it is not a constant expression, it is only potentially constant. The consequence is that it is an error to use size in a constant object expression (like const SizedBox(height: size)). In short, a constant object expression must be a constant expression, and hence it must evaluate to a specific object (not a different object for every invocation of the enclosing constructor).

We have had a lot of proposals for relaxing this restriction, and in particular #823 is specifically a proposal to allow using a constructor parameter in a constant object expression.

[eernstg]

@srikrsna, I'd recommend that you close this issue and vote on #823, and comment on #823 if anything is new relative to that issue!

[srikrsna]

@eernstg, #823 is related to classes where there is a possibility of parameters not being a constant, but this is specific to enums and as I understand they always have to be constant, don't they?

[eernstg]

That is true, an enum desugars to a class where it is guaranteed that the set of instances is known at compile-time, and each of them is the value of a const variable. So, unlike any other kind of constant constructor, it's known that it will only be invoked as part of constant expression evaluation.

I added a reference to this issue in #823, and then I'll change the labels of this issue to be a request for a generalization of enum constant constructors.

[lrhn]

It is a place where we could loosen the restriction that a const expression must evaluate to the same value every time it's evaluated, because we know that it's only evaluated (at most) once per element of the enum, so we won't risk an exploding number of constant objects.

It's still making it harder for our implementation teams to handle that exception, and we'd have to introduce special semantic rules just for enum constructors. I'd recommend, as workaround, to just rewrite it as:

enum Gaps {
  one(6, SizedBox(width: 6, height: 6), SizedBox(width: 6), SizedBox(height: 6));

  final SizedBox vBox, hBox, box;
  final double size;
  const Gaps(this.size, this.box, this.hbox, this.vBox);
}

Not as convenient, but there is only a finite number of enum elements to write.