[cfe] Add round-trip serialization support for loop nodes

The following nodes are supported now:
* ForStatement
* ForInStatement
* WhileStatement
* DoStatement

Change-Id: I42d43b949da80a631887996fac4b6a6f4c2a8c79
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/147100
Commit-Queue: Dmitry Stefantsov <[email protected]>
Reviewed-by: Johnni Winther <[email protected]>

Author: Dmitry Stefantsov

pkg/front_end/test/utils/kernel_chain.dart

@@ -373,7 +373,8 @@ class KernelTextSerialization
         }
       }
 
-      for (RoundTripStatus failure in verifier.failures) {
+      List<RoundTripStatus> failures = verifier.failures;
+      for (RoundTripStatus failure in failures) {
         LocatedMessage message = templateUnspecified
             .withArguments("\n${failure}")
             .withLocation(failure.uri, failure.offset, 1);
@@ -386,15 +387,15 @@ class KernelTextSerialization
         String filename = "${uri.toFilePath()}${suffix}";
         uri = new File(filename).uri;
         StringBuffer buffer = new StringBuffer();
-        for (RoundTripStatus status in verifier.status) {
+        for (RoundTripStatus status in verifier.takeStatus()) {
           status.printOn(buffer);
         }
         await openWrite(uri, (IOSink sink) {
           sink.write(buffer.toString());
         });
       }
 
-      if (verifier.failures.isNotEmpty) {
+      if (failures.isNotEmpty) {
         return new Result<ComponentResult>(
             null,
             context.expectationSet["TextSerializationFailure"],

pkg/kernel/lib/text/text_serialization_verifier.dart

@@ -379,7 +379,11 @@ class VerificationState {
           node.parent is Block &&
           node.name != null ||
       node is YieldStatement ||
-      node is IfStatement;
+      node is IfStatement ||
+      node is WhileStatement ||
+      node is DoStatement ||
+      node is ForStatement ||
+      node is ForInStatement && !node.isAsync;
 
   static bool isSupported(Node node) =>
       node is DartType && isDartTypeSupported(node) ||
@@ -396,7 +400,7 @@ class TextSerializationVerifier extends RecursiveVisitor<void> {
       defaultValue: false);
 
   /// List of status for all round-trip serialization attempts.
-  final List<RoundTripStatus> status = <RoundTripStatus>[];
+  final List<RoundTripStatus> _status = <RoundTripStatus>[];
 
   final CanonicalName root;
 
@@ -408,7 +412,9 @@ class TextSerializationVerifier extends RecursiveVisitor<void> {
   }
 
   /// List of errors produced during round trips on the visited nodes.
-  Iterable<RoundTripStatus> get failures => status.where((s) => s.isFailure);
+  Iterable<RoundTripStatus> get _failures => _status.where((s) => s.isFailure);
+
+  List<RoundTripStatus> get failures => _failures.toList()..sort();
 
   VerificationState get currentState => _stateStackTop;
 
@@ -472,17 +478,17 @@ class TextSerializationVerifier extends RecursiveVisitor<void> {
     } catch (exception, stackTrace) {
       String message =
           showStackTrace ? "${exception}\n${stackTrace}" : "${exception}";
-      status.add(new RoundTripDeserializationFailure(node, message,
+      _status.add(new RoundTripDeserializationFailure(node, message,
           context: lastSeenTreeNodeWithLocation));
       return null;
     }
     if (stream.moveNext()) {
-      status.add(new RoundTripDeserializationFailure(
+      _status.add(new RoundTripDeserializationFailure(
           node, "unexpected trailing text",
           context: lastSeenTreeNodeWithLocation));
     }
     if (result == null) {
-      status.add(new RoundTripDeserializationFailure(
+      _status.add(new RoundTripDeserializationFailure(
           node, "Deserialization of the following returned null: '${input}'",
           context: lastSeenTreeNodeWithLocation));
     }
@@ -497,7 +503,7 @@ class TextSerializationVerifier extends RecursiveVisitor<void> {
     } catch (exception, stackTrace) {
       String message =
           showStackTrace ? "${exception}\n${stackTrace}" : "${exception}";
-      status.add(new RoundTripInitialSerializationFailure(node, message,
+      _status.add(new RoundTripInitialSerializationFailure(node, message,
           context: lastSeenTreeNodeWithLocation));
     }
     return buffer.toString();
@@ -524,15 +530,15 @@ class TextSerializationVerifier extends RecursiveVisitor<void> {
   }
 
   void makeRoundTrip<T extends Node>(T node, TextSerializer<T> serializer) {
-    int failureCount = failures.length;
+    int failureCount = _failures.length;
     String initial = writeNode(node, serializer);
-    if (failures.length != failureCount) {
+    if (_failures.length != failureCount) {
       return;
     }
 
     // Do the round trip.
     T deserialized = readNode(node, initial, serializer);
-    if (failures.length != failureCount) {
+    if (_failures.length != failureCount) {
       return;
     }
 
@@ -542,17 +548,23 @@ class TextSerializationVerifier extends RecursiveVisitor<void> {
     }
 
     String serialized = writeNode(deserialized, serializer);
-    if (failures.length != failureCount) {
+    if (_failures.length != failureCount) {
       return;
     }
 
     if (initial != serialized) {
-      status.add(new RoundTripSecondSerializationFailure(
+      _status.add(new RoundTripSecondSerializationFailure(
           node, initial, serialized,
           context: lastSeenTreeNodeWithLocation));
     } else {
-      status.add(new RoundTripSuccess(node, initial,
+      _status.add(new RoundTripSuccess(node, initial,
           context: lastSeenTreeNodeWithLocation));
     }
   }
+
+  List<RoundTripStatus> takeStatus() {
+    List<RoundTripStatus> result = _status.toList()..sort();
+    _status.clear();
+    return result;
+  }
 }

pkg/kernel/lib/text/text_serializer.dart

@@ -1002,6 +1002,10 @@ class StatementTagger extends StatementVisitor<String>
   }
 
   String visitEmptyStatement(EmptyStatement node) => "skip";
+  String visitWhileStatement(WhileStatement node) => "while";
+  String visitDoStatement(DoStatement node) => "do-while";
+  String visitForStatement(ForStatement node) => "for";
+  String visitForInStatement(ForInStatement node) => "for-in";
 }
 
 TextSerializer<ExpressionStatement> expressionStatementSerializer = new Wrapped(
@@ -1129,6 +1133,72 @@ void unwrapEmptyStatement(EmptyStatement node) {}
 
 EmptyStatement wrapEmptyStatement(void ignored) => new EmptyStatement();
 
+TextSerializer<WhileStatement> whileStatementSerializer = new Wrapped(
+    unwrapWhileStatement,
+    wrapWhileStatement,
+    new Tuple2Serializer(expressionSerializer, statementSerializer));
+
+Tuple2<Expression, Statement> unwrapWhileStatement(WhileStatement node) {
+  return new Tuple2(node.condition, node.body);
+}
+
+WhileStatement wrapWhileStatement(Tuple2<Expression, Statement> tuple) {
+  return new WhileStatement(tuple.first, tuple.second);
+}
+
+TextSerializer<DoStatement> doStatementSerializer = new Wrapped(
+    unwrapDoStatement,
+    wrapDoStatement,
+    new Tuple2Serializer(statementSerializer, expressionSerializer));
+
+Tuple2<Statement, Expression> unwrapDoStatement(DoStatement node) {
+  return new Tuple2(node.body, node.condition);
+}
+
+DoStatement wrapDoStatement(Tuple2<Statement, Expression> tuple) {
+  return new DoStatement(tuple.first, tuple.second);
+}
+
+TextSerializer<ForStatement> forStatementSerializer = new Wrapped(
+    unwrapForStatement,
+    wrapForStatement,
+    new Bind(
+        ListSerializer(variableDeclarationSerializer),
+        new Tuple3Serializer(expressionSerializer,
+            new ListSerializer(expressionSerializer), statementSerializer)));
+
+Tuple2<List<VariableDeclaration>,
+        Tuple3<Expression, List<Expression>, Statement>>
+    unwrapForStatement(ForStatement node) {
+  return new Tuple2(
+      node.variables, new Tuple3(node.condition, node.updates, node.body));
+}
+
+ForStatement wrapForStatement(
+    Tuple2<List<VariableDeclaration>,
+            Tuple3<Expression, List<Expression>, Statement>>
+        tuple) {
+  return new ForStatement(
+      tuple.first, tuple.second.first, tuple.second.second, tuple.second.third);
+}
+
+TextSerializer<ForInStatement> forInStatementSerializer = new Wrapped(
+    unwrapForInStatement,
+    wrapForInStatement,
+    new Tuple2Serializer(expressionSerializer,
+        new Bind(variableDeclarationSerializer, statementSerializer)));
+
+Tuple2<Expression, Tuple2<VariableDeclaration, Statement>> unwrapForInStatement(
+    ForInStatement node) {
+  return new Tuple2(node.iterable, new Tuple2(node.variable, node.body));
+}
+
+ForInStatement wrapForInStatement(
+    Tuple2<Expression, Tuple2<VariableDeclaration, Statement>> tuple) {
+  return new ForInStatement(
+      tuple.second.first, tuple.first, tuple.second.second);
+}
+
 Case<Statement> statementSerializer =
     new Case.uninitialized(const StatementTagger());
 
@@ -1443,6 +1513,10 @@ void initializeSerializers() {
     "if": ifStatementSerializer,
     "if-else": ifElseStatementSerializer,
     "skip": emptyStatementSerializer,
+    "while": whileStatementSerializer,
+    "do-while": doStatementSerializer,
+    "for": forStatementSerializer,
+    "for-in": forInStatementSerializer,
   });
   functionNodeSerializer.registerTags({
     "sync": syncFunctionNodeSerializer,