Generalize import combinator pieces to other clauses. (#1308)

Generalize import combinator pieces to other clauses.

For imports and exports, there is logic around how to split and format
the "show" and "hide" combinators. I plan to use the same logic for
"extends", "implements", and "with" clauses in classes so this
generalizes that code to not be specific to imports.

It's also a little simpler and cleaner now.

Author: munificent

lib/src/constants.dart

@@ -79,7 +79,4 @@ class Indent {
 
   /// The ":" on a wrapped constructor initialization list.
   static const constructorInitializer = 4;
-
-  /// A split name in a show or hide combinator.
-  static const combinatorName = 8;
 }

lib/src/front_end/piece_factory.dart

@@ -5,11 +5,12 @@ import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
 
 import '../ast_extensions.dart';
+import '../piece/adjacent.dart';
 import '../piece/assign.dart';
 import '../piece/block.dart';
+import '../piece/clause.dart';
 import '../piece/function.dart';
 import '../piece/if.dart';
-import '../piece/import.dart';
 import '../piece/infix.dart';
 import '../piece/list.dart';
 import '../piece/piece.dart';
@@ -224,9 +225,8 @@ mixin PieceFactory implements CommentWriter {
     token(keyword);
     space();
     visit(directive.uri);
-    var directivePiece = pieces.take();
+    var importPieces = [pieces.take()];
 
-    Piece? configurationsPiece;
     if (directive.configurations.isNotEmpty) {
       var configurations = <Piece>[];
       for (var configuration in directive.configurations) {
@@ -235,44 +235,49 @@ mixin PieceFactory implements CommentWriter {
         configurations.add(pieces.take());
       }
 
-      configurationsPiece = PostfixPiece(configurations);
+      importPieces.add(PostfixPiece(configurations));
     }
 
-    Piece? asClause;
     if (asKeyword != null) {
       pieces.split();
       token(deferredKeyword, after: space);
       token(asKeyword);
       space();
       visit(prefix);
-      asClause = PostfixPiece([pieces.take()]);
+      importPieces.add(PostfixPiece([pieces.take()]));
     }
 
-    var combinators = <ImportCombinator>[];
-    for (var combinatorNode in directive.combinators) {
-      pieces.split();
-      token(combinatorNode.keyword);
-      var combinator = ImportCombinator(pieces.take());
-      combinators.add(combinator);
-
-      switch (combinatorNode) {
-        case HideCombinator(hiddenNames: var names):
-        case ShowCombinator(shownNames: var names):
-          for (var name in names) {
-            pieces.split();
-            token(name.token);
-            commaAfter(name);
-            combinator.names.add(pieces.take());
-          }
-        default:
-          throw StateError('Unknown combinator type $combinatorNode.');
+    if (directive.combinators.isNotEmpty) {
+      var combinators = <ClausePiece>[];
+      for (var combinatorNode in directive.combinators) {
+        pieces.split();
+        token(combinatorNode.keyword);
+        var combinatorKeyword = pieces.split();
+
+        switch (combinatorNode) {
+          case HideCombinator(hiddenNames: var names):
+          case ShowCombinator(shownNames: var names):
+            var parts = <Piece>[];
+            for (var name in names) {
+              pieces.split();
+              token(name.token);
+              commaAfter(name);
+              parts.add(pieces.take());
+            }
+
+            var combinator = ClausePiece(combinatorKeyword, parts);
+            combinators.add(combinator);
+          default:
+            throw StateError('Unknown combinator type $combinatorNode.');
+        }
       }
+
+      importPieces.add(ClausesPiece(combinators));
     }
 
     token(directive.semicolon);
 
-    pieces.give(ImportPiece(
-        directivePiece, configurationsPiece, asClause, combinators));
+    pieces.give(AdjacentPiece(importPieces));
   }
 
   /// Creates a single infix operation.

lib/src/piece/adjacent.dart

@@ -0,0 +1,27 @@
+// 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 'piece.dart';
+
+/// A simple piece that just writes its child pieces one after the other.
+class AdjacentPiece extends Piece {
+  final List<Piece> _pieces;
+
+  AdjacentPiece(this._pieces);
+
+  @override
+  void format(CodeWriter writer, State state) {
+    for (var piece in _pieces) {
+      writer.format(piece);
+    }
+  }
+
+  @override
+  void forEachChild(void Function(Piece piece) callback) {
+    _pieces.forEach(callback);
+  }
+
+  @override
+  String toString() => 'Adjacent';
+}

lib/src/piece/clause.dart

@@ -0,0 +1,130 @@
+// 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 '../constants.dart';
+import 'piece.dart';
+
+/// A list of "clauses" where each clause starts with a keyword and has a
+/// comma-separated list of items under it.
+///
+/// Used for `show` and `hide` combinators in import and export directives, and
+/// `extends`, `implements`, and `with` clauses in type declarations.
+///
+/// Clauses can be chained on one line if they all fit, like:
+///
+/// ```
+/// import 'animals.dart' show Ant, Bat hide Cat, Dog;
+/// ```
+///
+/// Or can split before all of the clauses, like:
+///
+/// ```
+/// import 'animals.dart'
+///     show Ant, Bat
+///     hide Cat, Dog;
+/// ```
+///
+/// They can also split before every item in any of the clauses. If they do so,
+/// then the clauses must split too. So these are allowed:
+///
+/// ```
+/// import 'animals.dart'
+///     show
+///         Ant,
+///         Bat
+///     hide Cat, Dog;
+///
+/// import 'animals.dart'
+///     show Ant, Bat
+///     hide
+///         Cat,
+///         Dog;
+///
+/// import 'animals.dart'
+///     show
+///         Ant,
+///         Bat
+///     hide
+///         Cat,
+///         Dog;
+/// ```
+///
+/// But these are not:
+///
+/// ```
+/// // Wrap list but not keyword:
+/// import 'animals.dart' show
+///         Ant,
+///         Bat
+///     hide Cat, Dog;
+///
+/// // Wrap one keyword but not both:
+/// import 'animals.dart'
+///     show Ant, Bat hide Cat, Dog;
+///
+/// import 'animals.dart' show Ant, Bat
+///     hide Cat, Dog;
+/// ```
+///
+/// This ensures that when any wrapping occurs, the keywords are always at the
+/// beginning of the line.
+class ClausesPiece extends Piece {
+  final List<ClausePiece> _clauses;
+
+  ClausesPiece(this._clauses);
+
+  @override
+  List<State> get additionalStates => const [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);
+      writer.format(clause);
+    }
+  }
+
+  @override
+  void forEachChild(void Function(Piece piece) callback) {
+    _clauses.forEach(callback);
+  }
+
+  @override
+  String toString() => 'Clauses';
+}
+
+/// A keyword followed by a comma-separated list of items described by that
+/// keyword.
+class ClausePiece extends Piece {
+  final Piece _keyword;
+
+  /// The list of items in the clause.
+  final List<Piece> _parts;
+
+  ClausePiece(this._keyword, this._parts);
+
+  @override
+  List<State> get additionalStates => const [State.split];
+
+  @override
+  void format(CodeWriter writer, State state) {
+    writer.format(_keyword);
+    for (var part in _parts) {
+      writer.splitIf(state == State.split, indent: Indent.expression);
+      writer.format(part);
+    }
+  }
+
+  @override
+  void forEachChild(void Function(Piece piece) callback) {
+    callback(_keyword);
+    _parts.forEach(callback);
+  }
+
+  @override
+  String toString() => 'Clause';
+}