Preserve trailing commas for enums with members when commas are preserved (#1703)

This PR changes the formatter to have it maintain trailing commas of last enum constants when there are members.

So:
```dart
enum E { a, b, c,; int x; }
```

Becomes:
```dart
enum E {
  a,
  b,
  c,
  ;

  int x;
}
```
Instead of:

```dart
enum E {
  a,
  b,
  c;

  int x;
}
```

Fixes #1678 
Fixes #1729

Additionally, a similar style choice was presented in #1660 (comment)

**Affected users**:
- Those passing the `trailing_commas: preserve` config option and adding a trailing comma to their enum cases.
- Users who don't already pass a trailing comma, aren't affected. So this PR shouldn't have undesirable effects on existing users.

**Benefits**:
- Maintains developer's intent
- Less churn when adding additional member cases
(Personally, I always add a trailing semicolon to avoid churn and to also make it even clearer this is an advanced enum with members.)

**Downsides**:
- 7 additional logical lines of code to maintain

**Additional considerations**:
I also considered implementing this for `enum E { a, b,; }`, however, that would require more drastic changes to the formatter as far as I can tell.

Additionally, in this case the trailing semicolon provides fewer benefits:
- churn when adding new members is the same if there was a trailing semicolon or not
- giving the enum other members also only amounts to new lines being added rather than changed so again, no real churn.

**Notes**
- One test was changed due to this being a change in behavior.
- This was surprisingly easy and enjoyable to implement (compliment to the existing code base).
- I didn't make any changes to the `CHANGELOG.md` since this trailing commas preservation hasn't shipped yet so its behaviour is still undefined.

Author: jellynoone

lib/src/front_end/ast_node_visitor.dart

@@ -673,14 +673,26 @@ final class AstNodeVisitor extends ThrowingAstVisitor<void> with PieceFactory {
           builder.leftBracket(node.leftBracket);
 
           for (var constant in node.constants) {
+            var isLast = constant == node.constants.last;
+            var treatAsLast = isLast;
+            if (isLast && formatter.trailingCommas == TrailingCommas.preserve) {
+              treatAsLast = constant.commaAfter == null;
+            }
             builder.addCommentsBefore(constant.firstNonCommentToken);
             builder.add(
               createEnumConstant(
                 constant,
-                isLastConstant: constant == node.constants.last,
+                isLastConstant: treatAsLast,
                 semicolon: node.semicolon,
               ),
             );
+            // If this the last constant and wasn't treated as last, we need
+            // to append the ending semicolon.
+            if (isLast && !treatAsLast) {
+              if (node.semicolon case var token?) {
+                builder.add(tokenPiece(token));
+              }
+            }
           }
 
           // Insert a blank line between the constants and members.

test/tall/preserve_trailing_commas/enum.unit

@@ -25,13 +25,14 @@ enum E {e,;}
 enum E {
   e,
 }
->>> Remove trailing comma and split if there are members.
+>>> Preserve trailing comma and split if there are members.
 enum E { a, b, c,; int x; }
 <<<
 enum E {
   a,
   b,
-  c;
+  c,
+  ;
 
   int x;
 }