[cfe] Add temporary testing framework for pattern desugarings

Part of #49749

Change-Id: Ifb46078eb24b5c5288847ae95f1a0e584830335e
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/259180
Commit-Queue: Chloe Stefantsova <[email protected]>
Reviewed-by: Johnni Winther <[email protected]>

Author: chloestefantsova

pkg/front_end/lib/src/fasta/kernel/internal_ast.dart

@@ -5119,3 +5119,55 @@ class WildcardBinder extends Binder {
     return "WildcardBinder(${toStringInternal()})";
   }
 }
+
+class PatternVariableDeclaration extends Statement {
+  final Binder binder;
+  final Expression initializer;
+
+  PatternVariableDeclaration(this.binder, this.initializer);
+
+  @override
+  R accept<R>(StatementVisitor<R> visitor) {
+    if (visitor is Printer || visitor is Precedence || visitor is Transformer) {
+      // Allow visitors needed for toString and replaceWith.
+      return visitor.defaultStatement(this);
+    }
+    return unsupported(
+        "${runtimeType}.accept on ${visitor.runtimeType}", -1, null);
+  }
+
+  @override
+  R accept1<R, A>(StatementVisitor1<R, A> visitor, A arg) {
+    return unsupported(
+        "${runtimeType}.accept1 on ${visitor.runtimeType}", -1, null);
+  }
+
+  @override
+  void toTextInternal(AstPrinter printer) {
+    binder.toTextInternal(printer);
+    printer.write(" = ");
+    printer.writeExpression(initializer);
+  }
+
+  @override
+  void transformChildren(Transformer v) {
+    unsupported(
+        "${runtimeType}.transformChildren on ${v.runtimeType}", -1, null);
+  }
+
+  @override
+  void transformOrRemoveChildren(RemovingTransformer v) {
+    unsupported("${runtimeType}.transformOrRemoveChildren on ${v.runtimeType}",
+        -1, null);
+  }
+
+  @override
+  void visitChildren(Visitor v) {
+    unsupported("${runtimeType}.visitChildren on ${v.runtimeType}", -1, null);
+  }
+
+  @override
+  String toString() {
+    return "PatternVariableDeclaration(${toStringInternal()})";
+  }
+}

pkg/front_end/test/patterns/desugaring_test.dart

@@ -0,0 +1,84 @@
+// Copyright (c) 2022, 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 'package:kernel/ast.dart';
+import 'package:kernel/text/ast_to_text.dart';
+
+import 'package:front_end/src/fasta/kernel/internal_ast.dart';
+
+void runTests() {
+  checkExpected(
+      makeSimpleComponentWithPatternVariableDeclaration(
+          new PatternVariableDeclaration(
+              new ListBinder(const DynamicType(), [new WildcardBinder(null)]),
+              new IntLiteral(0))),
+      makeExpectationOfSimpleComponentWithPatternVariableDeclaration(
+          "PatternVariableDeclaration"));
+}
+
+Component makeSimpleComponentWithPatternVariableDeclaration(
+    PatternVariableDeclaration patternVariableDeclaration) {
+  Uri fileUri = Uri.parse("test:///test.dart");
+  Uri importUri = Uri.parse("test.dart");
+
+  Block body = new Block([patternVariableDeclaration]);
+  FunctionNode functionNode = new FunctionNode(body);
+  Procedure procedure = new Procedure(
+      new Name("test"), ProcedureKind.Method, functionNode,
+      fileUri: fileUri);
+  Library library =
+      new Library(importUri, procedures: [procedure], fileUri: fileUri);
+  Component component = new Component(libraries: [library]);
+  return component;
+}
+
+String makeExpectationOfSimpleComponentWithPatternVariableDeclaration(
+    String patternVariableDeclarationExpectation) {
+  return """
+main = <No Member>;
+library from "test.dart" as test {
+
+  method test() → dynamic {
+    ${patternVariableDeclarationExpectation}
+  }
+}
+""";
+}
+
+void checkExpected(Component component, String expected) {
+  String actual = componentToString(component);
+  if (actual != expected) {
+    // This is a very primitive substitute for the diff output of the actual
+    // expectation tests.
+    List<String> actualLines = actual.split("\n");
+    List<String> expectedLines = expected.split("\n");
+    StringBuffer output = new StringBuffer();
+    if (actualLines.length < expectedLines.length) {
+      output.writeln("Actual output is shorter than the expected.");
+    } else if (actualLines.length > expectedLines.length) {
+      output.writeln("Actual output is longer than the expected.");
+    }
+    int minLines = actualLines.length < expectedLines.length
+        ? actualLines.length
+        : expectedLines.length;
+    for (int i = 0; i < minLines; i++) {
+      // Include one line of the difference.
+      if (actualLines[i] != expectedLines[i]) {
+        output.writeln(
+            "Line $i is different in the actual output and the expected.\n"
+            "Actual  : ${actualLines[i]}\n"
+            "Expected: ${expectedLines[i]}");
+        break;
+      }
+    }
+    output.writeln("Full actual output:\n${'=' * 72}\n${actual}\n${'=' * 72}");
+    output.writeln(
+        "Full expected output:\n${'=' * 72}\n${expected}\n${'=' * 72}");
+    throw new StateError("${output}");
+  }
+}
+
+void main(List<String> args) {
+  runTests();
+}