Format class declarations. (#1309)

Format class declarations.

This handles all of the stuff that can appear outside of the braces in
a class declaration:

- The `class` keyword and any class modifiers.
- The name.
- Type parameters, if any.
- The `extends`, `with`, and/or `implements` clauses.
- The `native` clause.

It doesn't handle members yet.

It also handles ensuring there is a blank line before and after class
declarations. In the process of doing that, I also migrated over similar
code for function declarations where we ensure there is a blank line
after non-empty functions.

Author: munificent

lib/src/ast_extensions.dart

@@ -33,6 +33,8 @@ extension AstNodeExtensions on AstNode {
       body = node.body;
     } else if (node is FunctionDeclarationStatement) {
       body = node.functionDeclaration.functionExpression.body;
+    } else if (node is FunctionDeclaration) {
+      body = node.functionExpression.body;
     }
 
     return body is BlockFunctionBody && body.block.statements.isNotEmpty;

lib/src/front_end/ast_node_visitor.dart

@@ -6,6 +6,7 @@ import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/source/line_info.dart';
 
+import '../ast_extensions.dart';
 import '../constants.dart';
 import '../dart_formatter.dart';
 import '../piece/block.dart';
@@ -76,7 +77,17 @@ class AstNodeVisitor extends ThrowingAstVisitor<void>
       }
 
       for (var declaration in node.declarations) {
+        var hasBody = declaration is ClassDeclaration ||
+            declaration is EnumDeclaration ||
+            declaration is ExtensionDeclaration;
+
+        // Add a blank line before types with bodies.
+        if (hasBody) sequence.addBlank();
+
         sequence.visit(declaration);
+
+        // Add a blank line after type or function declarations with bodies.
+        if (hasBody || declaration.hasNonEmptyBody) sequence.addBlank();
       }
     } else {
       // Just formatting a single statement.
@@ -194,7 +205,26 @@ class AstNodeVisitor extends ThrowingAstVisitor<void>
 
   @override
   void visitClassDeclaration(ClassDeclaration node) {
-    throw UnimplementedError();
+    createType(
+        node.metadata,
+        [
+          node.abstractKeyword,
+          node.baseKeyword,
+          node.interfaceKeyword,
+          node.finalKeyword,
+          node.sealedKeyword,
+          node.mixinKeyword,
+        ],
+        node.classKeyword,
+        node.name,
+        node.typeParameters,
+        node.extendsClause,
+        node.withClause,
+        node.implementsClause,
+        node.nativeClause,
+        node.leftBracket,
+        node.members,
+        node.rightBracket);
   }
 
   @override
@@ -375,7 +405,7 @@ class AstNodeVisitor extends ThrowingAstVisitor<void>
 
   @override
   void visitExtendsClause(ExtendsClause node) {
-    throw UnimplementedError();
+    assert(false, 'This node is handled by PieceFactory.createType().');
   }
 
   @override
@@ -601,7 +631,7 @@ class AstNodeVisitor extends ThrowingAstVisitor<void>
 
   @override
   void visitImplementsClause(ImplementsClause node) {
-    throw UnimplementedError();
+    assert(false, 'This node is handled by PieceFactory.createType().');
   }
 
   @override
@@ -794,7 +824,10 @@ class AstNodeVisitor extends ThrowingAstVisitor<void>
 
   @override
   void visitNativeClause(NativeClause node) {
-    throw UnimplementedError();
+    space();
+    token(node.nativeKeyword);
+    space();
+    visit(node.name);
   }
 
   @override
@@ -1268,7 +1301,7 @@ class AstNodeVisitor extends ThrowingAstVisitor<void>
 
   @override
   void visitWithClause(WithClause node) {
-    throw UnimplementedError();
+    assert(false, 'This node is handled by PieceFactory.createType().');
   }
 
   @override

lib/src/front_end/delimited_list_builder.dart

@@ -3,11 +3,11 @@
 // BSD-style license that can be found in the LICENSE file.
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
-import 'package:dart_style/src/front_end/comment_writer.dart';
 
 import '../comment_type.dart';
 import '../piece/list.dart';
 import '../piece/piece.dart';
+import 'comment_writer.dart';
 import 'piece_factory.dart';
 
 /// Incrementally builds a [ListPiece], handling commas, comments, and

lib/src/front_end/piece_factory.dart

@@ -15,6 +15,7 @@ import '../piece/infix.dart';
 import '../piece/list.dart';
 import '../piece/piece.dart';
 import '../piece/postfix.dart';
+import '../piece/type.dart';
 import 'ast_node_visitor.dart';
 import 'comment_writer.dart';
 import 'delimited_list_builder.dart';
@@ -59,24 +60,44 @@ mixin PieceFactory implements CommentWriter {
   /// if (condition) {
   /// } else {}
   /// ```
-  void createBlock(Block block, {bool forceSplit = false}) {
-    token(block.leftBracket);
+  void createBody(Token leftBracket, List<AstNode> contents, Token rightBracket,
+      {bool forceSplit = false}) {
+    token(leftBracket);
     var leftBracketPiece = pieces.split();
 
     var sequence = SequenceBuilder(this);
-    for (var node in block.statements) {
+    for (var node in contents) {
       sequence.visit(node);
+
+      // If the node has a non-empty braced body, then require a blank line
+      // between it and the next node.
+      if (node.hasNonEmptyBody) sequence.addBlank();
     }
 
     // Place any comments before the "}" inside the block.
-    sequence.addCommentsBefore(block.rightBracket);
+    sequence.addCommentsBefore(rightBracket);
 
-    token(block.rightBracket);
+    token(rightBracket);
     var rightBracketPiece = pieces.take();
 
     pieces.give(BlockPiece(
         leftBracketPiece, sequence.build(), rightBracketPiece,
-        alwaysSplit: forceSplit || block.statements.isNotEmpty));
+        alwaysSplit: forceSplit || contents.isNotEmpty));
+  }
+
+  /// Creates a [BlockPiece] for a given [Block].
+  ///
+  /// If [forceSplit] is `true`, then the block will split even if empty. This
+  /// is used, for example, with empty blocks in `if` statements followed by
+  /// `else` clauses:
+  ///
+  /// ```
+  /// if (condition) {
+  /// } else {}
+  /// ```
+  void createBlock(Block block, {bool forceSplit = false}) {
+    createBody(block.leftBracket, block.statements, block.rightBracket,
+        forceSplit: forceSplit);
   }
 
   /// Creates a piece for a `break` or `continue` statement.
@@ -387,6 +408,74 @@ 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,
+      ExtendsClause? extendsClause,
+      WithClause? withClause,
+      ImplementsClause? implementsClause,
+      NativeClause? nativeClause,
+      Token leftBracket,
+      List<AstNode> members,
+      Token rightBracket) {
+    if (metadata.isNotEmpty) throw UnimplementedError('Type metadata.');
+    if (members.isNotEmpty) throw UnimplementedError('Type members.');
+
+    modifiers.forEach(modifier);
+    token(keyword);
+    space();
+    token(name);
+    visit(typeParameters);
+    var header = pieces.split();
+
+    var clauses = <ClausePiece>[];
+
+    void typeClause(Token keyword, List<AstNode> types) {
+      token(keyword);
+      var keywordPiece = pieces.split();
+
+      var typePieces = <Piece>[];
+      for (var type in types) {
+        visit(type);
+        commaAfter(type);
+        typePieces.add(pieces.split());
+      }
+
+      clauses.add(ClausePiece(keywordPiece, typePieces));
+    }
+
+    if (extendsClause != null) {
+      typeClause(extendsClause.extendsKeyword, [extendsClause.superclass]);
+    }
+
+    if (withClause != null) {
+      typeClause(withClause.withKeyword, withClause.mixinTypes);
+    }
+
+    if (implementsClause != null) {
+      typeClause(
+          implementsClause.implementsKeyword, implementsClause.interfaces);
+    }
+
+    ClausesPiece? clausesPiece;
+    if (clauses.isNotEmpty) {
+      clausesPiece =
+          ClausesPiece(clauses, allowLeadingClause: extendsClause != null);
+    }
+
+    visit(nativeClause);
+    space();
+    createBody(leftBracket, members, rightBracket);
+    var body = pieces.take();
+
+    pieces.give(TypePiece(header, clausesPiece, body));
+  }
+
   /// Creates a [ListPiece] for a type argument or type parameter list.
   void createTypeList(
       Token leftBracket, Iterable<AstNode> elements, Token rightBracket) {

lib/src/piece/block.dart

@@ -28,7 +28,7 @@ class BlockPiece extends Piece {
   }
 
   @override
-  List<State> get additionalStates => const [State.split];
+  List<State> get additionalStates => [if (contents.isNotEmpty) State.split];
 
   @override
   void format(CodeWriter writer, State state) {

lib/src/piece/clause.dart

@@ -70,20 +70,49 @@ import 'piece.dart';
 /// This ensures that when any wrapping occurs, the keywords are always at the
 /// beginning of the line.
 class ClausesPiece extends Piece {
+  /// State where we split between the clauses but not before the first one.
+  static const State _betweenClauses = State(1);
+
   final List<ClausePiece> _clauses;
 
-  ClausesPiece(this._clauses);
+  /// If `true`, then we're allowed to split between the clauses without
+  /// splitting before the first one too.
+  ///
+  /// This is used for class declarations where the `extends` clauses is treated
+  /// a little specially because it's a deeper coupling to the class and so we
+  /// want it to stay on the top line even if the other clauses split, like:
+  ///
+  /// ```
+  /// class BaseClass extends Derived
+  ///     implements OtherThing {
+  ///   ...
+  /// }
+  /// ```
+  final bool _allowLeadingClause;
+
+  ClausesPiece(this._clauses, {bool allowLeadingClause = false})
+      : _allowLeadingClause = allowLeadingClause;
 
   @override
-  List<State> get additionalStates => const [State.split];
+  List<State> get additionalStates =>
+      [if (_allowLeadingClause) _betweenClauses, State.split];
 
   @override
   void format(CodeWriter writer, State state) {
-    // If any of the lists inside any of the clauses split, split at the
-    // keywords too.
-    writer.setAllowNewlines(state == State.split);
     for (var clause in _clauses) {
-      writer.splitIf(state == State.split, indent: Indent.expression);
+      if (_allowLeadingClause && clause == _clauses.first) {
+        // Before the leading clause, only split when in the fully split state.
+        // A split inside the first clause forces a split before the keyword.
+        writer.splitIf(state == State.split, indent: Indent.expression);
+        writer.setAllowNewlines(state == State.split);
+      } else {
+        // For the other clauses (or if there is no leading one), split in the
+        // fully split state and any split inside and clause forces all of them
+        // to split.
+        writer.setAllowNewlines(state != State.unsplit);
+        writer.splitIf(state != State.unsplit, indent: Indent.expression);
+      }
+
       writer.format(clause);
     }
   }
@@ -112,6 +141,9 @@ class ClausePiece extends Piece {
 
   @override
   void format(CodeWriter writer, State state) {
+    // If any of the parts inside the clause split, split the list.
+    writer.setAllowNewlines(state != State.unsplit);
+
     writer.format(_keyword);
     for (var part in _parts) {
       writer.splitIf(state == State.split, indent: Indent.expression);

lib/src/piece/type.dart

@@ -0,0 +1,40 @@
+// Copyright (c) 2023, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+import '../back_end/code_writer.dart';
+import 'clause.dart';
+import 'piece.dart';
+
+/// Piece for a type declaration with a body containing members.
+///
+/// Used for class, enum, and extension declarations.
+class TypePiece extends Piece {
+  /// The leading keywords and modifiers, type name, and type parameters.
+  final Piece _header;
+
+  /// The `extends`, `with`, and/or `implements` clauses, if there are any.
+  final ClausesPiece? _clauses;
+
+  /// The `native` clause, if any, and the type body.
+  final Piece _body;
+
+  TypePiece(this._header, this._clauses, this._body);
+
+  @override
+  void format(CodeWriter writer, State state) {
+    writer.format(_header);
+    if (_clauses case var clauses?) writer.format(clauses);
+    writer.space();
+    writer.format(_body);
+  }
+
+  @override
+  void forEachChild(void Function(Piece piece) callback) {
+    callback(_header);
+    if (_clauses case var clauses?) callback(clauses);
+    callback(_body);
+  }
+
+  @override
+  String toString() => 'Type';
+}