Format mixin application classes. (#1310)

Format mixin application classes.

This mostly reuses the existing createType() code with a couple of
tweaks since mixin application classes don't have bodies and have the
"= Superclass" part before the "with" clause.

You'll notice that the modifiers test case here takes a couple of
seconds to run. That's because the new back end's line splitter doesn't
do any memoization or divide and conquering, so it's brute-forcing the
whole compilation unit to figure out which of the mixin applications
need splitting.

I don't think it's intolerable yet as far as how long it takes the tests
to run, but this means it's probably a good time for me to start
looking into optimization soon.

Author: munificent

lib/src/front_end/ast_node_visitor.dart

@@ -217,19 +217,38 @@ class AstNodeVisitor extends ThrowingAstVisitor<void>
         ],
         node.classKeyword,
         node.name,
-        node.typeParameters,
-        node.extendsClause,
-        node.withClause,
-        node.implementsClause,
-        node.nativeClause,
-        node.leftBracket,
-        node.members,
-        node.rightBracket);
+        typeParameters: node.typeParameters,
+        extendsClause: node.extendsClause,
+        withClause: node.withClause,
+        implementsClause: node.implementsClause,
+        nativeClause: node.nativeClause,
+        body: (
+          leftBracket: node.leftBracket,
+          members: node.members,
+          rightBracket: node.rightBracket
+        ));
   }
 
   @override
   void visitClassTypeAlias(ClassTypeAlias node) {
-    throw UnimplementedError();
+    createType(
+        node.metadata,
+        [
+          node.abstractKeyword,
+          node.baseKeyword,
+          node.interfaceKeyword,
+          node.finalKeyword,
+          node.sealedKeyword,
+          node.mixinKeyword,
+        ],
+        node.typedefKeyword,
+        node.name,
+        equals: node.equals,
+        superclass: node.superclass,
+        typeParameters: node.typeParameters,
+        withClause: node.withClause,
+        implementsClause: node.implementsClause,
+        semicolon: node.semicolon);
   }
 
   @override

lib/src/front_end/piece_factory.dart

@@ -408,29 +408,46 @@ mixin PieceFactory implements CommentWriter {
     pieces.give(builder.build());
   }
 
-  /// Creates a class, enum, extension, etc. declaration with a body containing
-  /// members.
-  void createType(
-      NodeList<Annotation> metadata,
-      List<Token?> modifiers,
-      Token keyword,
-      Token name,
-      TypeParameterList? typeParameters,
+  /// Creates a class, enum, extension, mixin, or mixin application class
+  /// declaration.
+  ///
+  /// For all but a mixin application class, [body] should a record containing
+  /// the bracket delimiters and the list of member declarations for the type's
+  /// body.
+  ///
+  /// For mixin application classes, [body] is `null` and instead [equals],
+  /// [superclass], and [semicolon] are provided.
+  void createType(NodeList<Annotation> metadata, List<Token?> modifiers,
+      Token keyword, Token name,
+      {TypeParameterList? typeParameters,
+      Token? equals,
+      NamedType? superclass,
       ExtendsClause? extendsClause,
       WithClause? withClause,
       ImplementsClause? implementsClause,
       NativeClause? nativeClause,
-      Token leftBracket,
-      List<AstNode> members,
-      Token rightBracket) {
+      ({Token leftBracket, List<AstNode> members, Token rightBracket})? body,
+      Token? semicolon}) {
     if (metadata.isNotEmpty) throw UnimplementedError('Type metadata.');
-    if (members.isNotEmpty) throw UnimplementedError('Type members.');
+    if (body != null && body.members.isNotEmpty) {
+      throw UnimplementedError('Type members.');
+    }
 
     modifiers.forEach(modifier);
     token(keyword);
     space();
     token(name);
     visit(typeParameters);
+
+    // Mixin application classes have ` = Superclass` after the declaration
+    // name.
+    if (equals != null) {
+      space();
+      token(equals);
+      space();
+      visit(superclass);
+    }
+
     var header = pieces.split();
 
     var clauses = <ClausePiece>[];
@@ -470,10 +487,16 @@ mixin PieceFactory implements CommentWriter {
 
     visit(nativeClause);
     space();
-    createBody(leftBracket, members, rightBracket);
-    var body = pieces.take();
 
-    pieces.give(TypePiece(header, clausesPiece, body));
+    if (body != null) {
+      createBody(body.leftBracket, body.members, body.rightBracket);
+    } else {
+      token(semicolon);
+    }
+    var bodyPiece = pieces.take();
+
+    pieces.give(
+        TypePiece(header, clausesPiece, bodyPiece, hasBody: body != null));
   }
 
   /// Creates a [ListPiece] for a type argument or type parameter list.

lib/src/piece/type.dart

@@ -18,13 +18,18 @@ class TypePiece extends Piece {
   /// The `native` clause, if any, and the type body.
   final Piece _body;
 
-  TypePiece(this._header, this._clauses, this._body);
+  /// Whether the type has a `{ ... }` body or just a `;` at the end (for a
+  /// mixin application class).
+  final bool _hasBody;
+
+  TypePiece(this._header, this._clauses, this._body, {required bool hasBody})
+      : _hasBody = hasBody;
 
   @override
   void format(CodeWriter writer, State state) {
     writer.format(_header);
     if (_clauses case var clauses?) writer.format(clauses);
-    writer.space();
+    if (_hasBody) writer.space();
     writer.format(_body);
   }
 

test/declaration/mixin_application_class.unit

@@ -0,0 +1,110 @@
+40 columns                              |
+>>> Inline.
+class   SomeClass  =  Base  with  Mixin  ;
+<<<
+class SomeClass = Base with Mixin;
+>>> Split at `with`.
+class SomeClass = Base with VeryLongMixin;
+<<<
+class SomeClass = Base
+    with VeryLongMixin;
+>>> Split at `with` but not between mixins.
+class SomeClass = Base with Mixin, AnotherOne;
+<<<
+class SomeClass = Base
+    with Mixin, AnotherOne;
+>>> Split at `with` and mixins.
+class SomeClass = Base with Mixin, Another, Third, FourthOne;
+<<<
+class SomeClass = Base
+    with
+        Mixin,
+        Another,
+        Third,
+        FourthOne;
+>>> Unsplit generic mixin.
+class C = Object with M<int>;
+<<<
+class C = Object with M<int>;
+>>> Split before `with` on generic mixin.
+class C = Object with Mixin<SomeLongClass>;
+<<<
+class C = Object
+    with Mixin<SomeLongClass>;
+>>> Split in generic mixin.
+class C = Object with Mixin<VeryLongType, AnotherLongType>;
+<<<
+class C = Object
+    with
+        Mixin<
+          VeryLongType,
+          AnotherLongType
+        >;
+>>> Split within `with` but not `implements`.
+class C = Object with Mixin, Another, Third, Fourth, Fifth implements Interface;
+<<<
+class C = Object
+    with
+        Mixin,
+        Another,
+        Third,
+        Fourth,
+        Fifth
+    implements Interface;
+>>> Split within `implements` but not `with`.
+class C = Object with Mixin implements Interface, Another, Third;
+<<<
+class C = Object
+    with Mixin
+    implements
+        Interface,
+        Another,
+        Third;
+>>> Split within both `with` and `implements`.
+class C = Object with Mixin, Another, Third, Fourth, Fifth implements Interface, Another, Third;
+<<<
+class C = Object
+    with
+        Mixin,
+        Another,
+        Third,
+        Fourth,
+        Fifth
+    implements
+        Interface,
+        Another,
+        Third;
+>>> Modifiers.
+class C1 = Object with Mixin;
+base  class C2 = Object with Mixin;
+interface  class C3 = Object with Mixin;
+final  class C4 = Object with Mixin;
+sealed  class C5 = Object with Mixin;
+abstract  class C6 = Object with Mixin;
+abstract  base  class C7 = Object with Mixin;
+abstract interface  class C8 = Object with Mixin;
+abstract  final  class C9 = Object with Mixin;
+mixin  class C10 = Object with Mixin;
+base  mixin  class C11 = Object with Mixin;
+abstract  mixin  class C12 = Object with Mixin;
+abstract  base  mixin  class C13 = Object with Mixin;
+<<<
+class C1 = Object with Mixin;
+base class C2 = Object with Mixin;
+interface class C3 = Object with Mixin;
+final class C4 = Object with Mixin;
+sealed class C5 = Object with Mixin;
+abstract class C6 = Object with Mixin;
+abstract base class C7 = Object
+    with Mixin;
+abstract interface class C8 = Object
+    with Mixin;
+abstract final class C9 = Object
+    with Mixin;
+mixin class C10 = Object with Mixin;
+base mixin class C11 = Object
+    with Mixin;
+abstract mixin class C12 = Object
+    with Mixin;
+abstract base mixin class C13 = Object
+    with Mixin;

test/top_level/mixed.unit

@@ -19,4 +19,30 @@ part 'a.dart';
 <<<
 library foo;
 
-part 'a.dart';
+part 'a.dart';
+>>> Collapse extra newlines between declarations.
+
+
+
+class A {}
+
+
+
+class B = Base with Mixin;
+
+
+
+var c = 1;
+
+
+d() {}
+
+
+<<<
+class A {}
+
+class B = Base with Mixin;
+
+var c = 1;
+
+d() {}