Rework things some:

- Move the tests to tall. The old short style formatter doesn't support
  new syntax and doesn't need to be tested.

- Add support for passing experiment flags with tests. The old way of
  doing this was to just hardcode experiments inside the formatter when
  a new feature was supported. That made sense when the formatter didn't
  know about language version, but now that it does, it should probably
  require experiment flags explicitly and tests for new features should
  enable them.

- Move the code to handle "? into visitMapLiteralEntry(). The AST node
  does have tokens for "?" and that way there's less special-case code
  getting threaded through PieceFactory.

- Add some tests for comments appearing around "?". (Comments tend to be
  a tricky corner of the formatter, so we test them heavily.)

Author: munificent

example/format.dart

@@ -78,7 +78,8 @@ Future<void> _runTest(String path, int line,
   var formatter = DartFormatter(
       languageVersion: formatTest.languageVersion,
       pageWidth: testFile.pageWidth,
-      indent: formatTest.leadingIndent);
+      indent: formatTest.leadingIndent,
+      experimentFlags: formatTest.experimentFlags);
 
   var actual = formatter.formatSource(formatTest.input);
 

lib/src/front_end/ast_node_visitor.dart

@@ -1251,8 +1251,24 @@ final class AstNodeVisitor extends ThrowingAstVisitor<void> with PieceFactory {
 
   @override
   void visitMapLiteralEntry(MapLiteralEntry node) {
-    writeAssignment(node.key, node.separator, node.value,
-        includeLeftHandSideQuestion: true, includeRightHandSideQuestion: true);
+    var leftPiece = pieces.build(() {
+      pieces.token(node.keyQuestion);
+      pieces.visit(node.key);
+    });
+
+    var operatorPiece = tokenPiece(node.separator);
+
+    var rightPiece = pieces.build(() {
+      pieces.token(node.valueQuestion);
+      pieces.visit(node.value, context: NodeContext.assignment);
+    });
+
+    pieces.add(AssignPiece(
+        left: leftPiece,
+        operatorPiece,
+        rightPiece,
+        canBlockSplitLeft: node.key.canBlockSplit,
+        canBlockSplitRight: node.value.canBlockSplit));
   }
 
   @override

lib/src/front_end/piece_factory.dart

@@ -1338,10 +1338,7 @@ mixin PieceFactory {
       AstNode leftHandSide, Token operator, AstNode rightHandSide,
       {bool includeComma = false,
       bool canBlockSplitLeft = false,
-      NodeContext leftHandSideContext = NodeContext.none,
-      bool includeLeftHandSideQuestion = false,
-      bool includeRightHandSideQuestion = false,
-      String? rightHandSidePrefix}) {
+      NodeContext leftHandSideContext = NodeContext.none}) {
     // If an operand can have block formatting, then a newline in it doesn't
     // force the operator to split, as in:
     //
@@ -1386,19 +1383,15 @@ mixin PieceFactory {
       _ => false
     };
 
-    var leftPiece = nodePiece(leftHandSide,
-        questionBefore: includeLeftHandSideQuestion,
-        context: leftHandSideContext);
+    var leftPiece = nodePiece(leftHandSide, context: leftHandSideContext);
 
     var operatorPiece = pieces.build(() {
       if (operator.type != TokenType.COLON) pieces.space();
       pieces.token(operator);
     });
 
     var rightPiece = nodePiece(rightHandSide,
-        commaAfter: includeComma,
-        questionBefore: includeRightHandSideQuestion,
-        context: NodeContext.assignment);
+        commaAfter: includeComma, context: NodeContext.assignment);
 
     pieces.add(AssignPiece(
         left: leftPiece,
@@ -1527,9 +1520,7 @@ mixin PieceFactory {
   /// If [commaAfter] is `true`, looks for a comma token after [node] and
   /// writes it to the piece as well.
   Piece nodePiece(AstNode node,
-      {bool commaAfter = false,
-      bool questionBefore = false,
-      NodeContext context = NodeContext.none}) {
+      {bool commaAfter = false, NodeContext context = NodeContext.none}) {
     var result = pieces.build(() {
       visitNode(node, context);
     });
@@ -1542,14 +1533,6 @@ mixin PieceFactory {
       }
     }
 
-    if (questionBefore) {
-      var previousToken = node.beginToken.previous!;
-      if (previousToken.lexeme == '?') {
-        var question = tokenPiece(previousToken);
-        result = AdjacentPiece([question, result]);
-      }
-    }
-
     return result;
   }
 

lib/src/testing/test_file.dart

@@ -11,6 +11,7 @@ import '../../dart_style.dart';
 
 final _indentPattern = RegExp(r'\(indent (\d+)\)');
 final _versionPattern = RegExp(r'\(version (\d+)\.(\d+)\)');
+final _experimentPattern = RegExp(r'\(experiment ([a-z-]+)\)');
 final _unicodeUnescapePattern = RegExp(r'×([0-9a-fA-F]{2,4})');
 final _unicodeEscapePattern = RegExp('[\x0a\x0c\x0d]');
 
@@ -111,6 +112,14 @@ final class TestFile {
         return '';
       });
 
+      // Let the test enable experiments for features that are supported but not
+      // released yet.
+      var experiments = <String>[];
+      description = description.replaceAllMapped(_experimentPattern, (match) {
+        experiments.add(match[1]!);
+        return '';
+      });
+
       var inputComments = readComments();
 
       var inputBuffer = StringBuffer();
@@ -160,6 +169,7 @@ final class TestFile {
           lineNumber,
           languageVersion,
           leadingIndent,
+          experiments,
           inputComments,
           outputComments));
     }
@@ -217,6 +227,9 @@ final class FormatTest {
   /// line.
   final int leadingIndent;
 
+  /// Experiments that should be enabled when running this test.
+  final List<String> experimentFlags;
+
   FormatTest(
       this.input,
       this.output,
@@ -225,6 +238,7 @@ final class FormatTest {
       this.line,
       this.languageVersion,
       this.leadingIndent,
+      this.experimentFlags,
       this.inputComments,
       this.outputComments);
 

pubspec.yaml

@@ -9,7 +9,7 @@ environment:
   sdk: "^3.4.0"
 
 dependencies:
-  analyzer: ">=6.5.0 <8.0.0"
+  analyzer: ">=7.3.0 <8.0.0"
   args: ">=1.0.0 <3.0.0"
   collection: "^1.17.0"
   package_config: ^2.1.0

test/short/whitespace/collections.stmt

@@ -92,34 +92,4 @@ f() async {
 <<<
 f() async {
   var l = [await for (x in y) x];
-}
->>> null-aware elements
-foo1(int? x) => [
-  ?x];
-<<<
-foo1(int? x) => [?x];
->>>
-foo2(int? x) => {
-  ?x};
-<<<
-foo2(int? x) => {?x};
->>>
-bar0() => {
-  "key": #value};
-<<<
-bar0() => {"key": #value};
->>>
-bar1(int? x) => {
-  ?x: "value"};
-<<<
-bar1(int? x) => {?x: "value"};
->>>
-bar2(String? y) => {
-  "key": ?y};
-<<<
-bar2(String? y) => {"key": ?y};
->>>
-bar3(int? x, String? y) => {
-  ?x: ?y};
-<<<
-bar3(int? x, String? y) => {?x: ?y};
+}

test/tall/expression/collection_null_aware.stmt

@@ -0,0 +1,28 @@
+40 columns                              |
+>>> (experiment null-aware-elements) List element.
+var list = [  ?  x  ];
+<<<
+var list = [?x];
+>>> (experiment null-aware-elements) Set element.
+var set = {  ?  x  };
+<<<
+var set = {?x};
+>>> (experiment null-aware-elements) Map key.
+var map = {  ?  key  : value};
+<<<
+var map = {?key: value};
+>>> (experiment null-aware-elements) Map value.
+var map = { key:  ?  value  };
+<<<
+var map = {key: ?value};
+>>> (experiment null-aware-elements) Both key and value.
+var map = {  ?  key  :  ?  value  };
+<<<
+var map = {?key: ?value};
+>>> (experiment null-aware-elements) Split inside element.
+var list = [?(veryLongExpression +thatIsForcedToSplit)];
+<<<
+var list = [
+  ?(veryLongExpression +
+      thatIsForcedToSplit),
+];

test/tall/expression/collection_null_aware_comment.stmt

@@ -0,0 +1,34 @@
+40 columns                              |
+>>> (experiment null-aware-elements) Inline comment after `?`.
+var list = [  ?  /* c */  x  ];
+<<<
+var list = [? /* c */ x];
+>>> (experiment null-aware-elements)
+var map = {  ?  /* c */  key  :  ?  /* c */  value  };
+<<<
+var map = {
+  ? /* c */ key: ? /* c */ value,
+};
+>>> (experiment null-aware-elements) Line comment after `?`.
+var list = [  ?  // c
+x  ];
+<<<
+### This is an odd place for a comment so the formatting is odd, but we want to
+### at least pin it down with a test.
+var list = [
+  ? // c
+  x,
+];
+>>> (experiment null-aware-elements)
+var map = {  ?  // c
+key  :  ?  // c
+value  };
+<<<
+### This is an odd place for a comment so the formatting is odd, but we want to
+### at least pin it down with a test.
+var map = {
+  ? // c
+      key:
+      ? // c
+      value,
+};

test/utils.dart

@@ -130,7 +130,8 @@ void _testFile(TestFile testFile) {
         var formatter = DartFormatter(
             languageVersion: formatTest.languageVersion,
             pageWidth: testFile.pageWidth,
-            indent: formatTest.leadingIndent);
+            indent: formatTest.leadingIndent,
+            experimentFlags: formatTest.experimentFlags);
 
         var actual = _validateFormat(
             formatter,

tool/update_tests.dart

@@ -92,7 +92,8 @@ Future<void> _updateTestFile(TestFile testFile) async {
     var formatter = DartFormatter(
         languageVersion: formatTest.languageVersion,
         pageWidth: testFile.pageWidth,
-        indent: formatTest.leadingIndent);
+        indent: formatTest.leadingIndent,
+        experimentFlags: formatTest.experimentFlags);
 
     var actual = formatter.formatSource(formatTest.input);
 
@@ -110,6 +111,8 @@ Future<void> _updateTestFile(TestFile testFile) async {
         : DartFormatter.latestShortStyleLanguageVersion;
 
     var descriptionParts = [
+      for (var experiment in formatTest.experimentFlags)
+        '(experiment $experiment)',
       if (formatTest.leadingIndent != 0) '(indent ${formatTest.leadingIndent})',
       if (formatTest.languageVersion != defaultLanguageVersion)
         '(version ${formatTest.languageVersion.major}.'