dart-lang#1401. [Patterns] Logical-or tests added

Author: sgrekhov

LanguageFeatures/Patterns/logical_or_A01_t01.dart

@@ -0,0 +1,48 @@
+// 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.
+
+/// @assertion logicalOrPattern ::= ( logicalOrPattern '|' )? logicalAndPattern
+///
+/// A pair of patterns separated by | matches if either of the branches match
+///
+/// A logical-or pattern may match even if one of its branches does not. That
+/// means that any variables in the non-matching branch would not be
+/// initialized. To avoid problems stemming from that, the following
+/// restrictions apply:
+///
+/// The two branches must define the same set of variables.
+///
+/// If the left branch matches, the right branch is not evaluated. This
+/// determines which value the variable gets if both branches would have
+/// matched. In that case, it will always be the value from the left branch.
+///
+/// @description Checks logical-or pattern in a switch expression
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=patterns
+
+import "../../Utils/expect.dart";
+
+enum Color {
+  white,
+  red,
+  yellow,
+  blue,
+  black;
+}
+
+bool isPrimary(Color color) {
+  return switch (color) {
+    case Color.red | Color.yellow | Color.blue => true;
+    default => false;
+  };
+}
+
+main() {
+  Expect.isFalse(Color.black);
+  Expect.isFalse(Color.white);
+  Expect.isTrue(Color.red);
+  Expect.isTrue(Color.yellow);
+  Expect.isTrue(Color.blue);
+}

LanguageFeatures/Patterns/logical_or_A01_t02.dart

@@ -0,0 +1,38 @@
+// 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.
+
+/// @assertion logicalOrPattern ::= ( logicalOrPattern '|' )? logicalAndPattern
+///
+/// A pair of patterns separated by | matches if either of the branches match
+///
+/// A logical-or pattern may match even if one of its branches does not. That
+/// means that any variables in the non-matching branch would not be
+/// initialized. To avoid problems stemming from that, the following
+/// restrictions apply:
+///
+/// The two branches must define the same set of variables.
+///
+/// If the left branch matches, the right branch is not evaluated. This
+/// determines which value the variable gets if both branches would have
+/// matched. In that case, it will always be the value from the left branch.
+///
+/// @description Checks logical-or subpattern in a switch expression
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=patterns
+
+import "../../Utils/expect.dart";
+
+bool matches(List list) => switch (list) {
+  case [1 | 2, 3] => true;
+  default => false;
+};
+
+main() {
+  Expect.isFalse([0, 3]);
+  Expect.isFalse([2, 2]);
+  Expect.isFalse([2, 3, 4]);
+  Expect.isTrue([1, 3]);
+  Expect.isTrue([2, 3]);
+}

LanguageFeatures/Patterns/logical_or_A02_t01.dart

@@ -0,0 +1,46 @@
+// 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.
+
+/// @assertion logicalOrPattern ::= ( logicalOrPattern '|' )? logicalAndPattern
+///
+/// A pair of patterns separated by | matches if either of the branches match
+///
+/// A logical-or pattern may match even if one of its branches does not. That
+/// means that any variables in the non-matching branch would not be
+/// initialized. To avoid problems stemming from that, the following
+/// restrictions apply:
+///
+/// The two branches must define the same set of variables.
+///
+/// If the left branch matches, the right branch is not evaluated. This
+/// determines which value the variable gets if both branches would have
+/// matched. In that case, it will always be the value from the left branch.
+///
+/// @description Checks logical-or pattern in a switch statements
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=patterns
+
+import "patterns_lib.dart";
+import "../../Utils/expect.dart";
+
+void test(Shape shape, double expectedArea, Type expectedType, bool match) {
+  switch (shape) {
+    case Square(area: var s) | Circle(area: var s):
+      Expect.equals(expectedArea, s);
+      Expect.equals(expectedType, shape.runtimeType);
+      Expect.isTrue(match);
+      break;
+    default:
+      Expect.equals(expectedArea, s);
+      Expect.equals(expectedType, shape.runtimeType);
+      Expect.isFalse(match);
+  }
+}
+
+main() {
+  test(Circle(1), 3.14, Circle, true);
+  test(Square(2), 4, Square, true);
+  test(Rectangle(2, 1), 2, Rectangle, false);
+}

LanguageFeatures/Patterns/logical_or_A02_t02.dart

@@ -0,0 +1,44 @@
+// 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.
+
+/// @assertion logicalOrPattern ::= ( logicalOrPattern '|' )? logicalAndPattern
+///
+/// A pair of patterns separated by | matches if either of the branches match
+///
+/// A logical-or pattern may match even if one of its branches does not. That
+/// means that any variables in the non-matching branch would not be
+/// initialized. To avoid problems stemming from that, the following
+/// restrictions apply:
+///
+/// The two branches must define the same set of variables.
+///
+/// If the left branch matches, the right branch is not evaluated. This
+/// determines which value the variable gets if both branches would have
+/// matched. In that case, it will always be the value from the left branch.
+///
+/// @description Checks logical-or subpattern in a switch statement
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=patterns
+
+import "../../Utils/expect.dart";
+
+bool matches(List list) {
+  bool result = false;
+  switch (list) {
+    case [1 | 2, 3]:
+      result = true;
+    default:
+  };
+  return result;
+}
+
+main() {
+  Expect.isFalse([0, 3]);
+  Expect.isFalse([2, 2]);
+  Expect.isFalse([2, 3, 4]);
+  Expect.isTrue([1, 3]);
+  Expect.isTrue([2, 3]);
+}
+

LanguageFeatures/Patterns/logical_or_A03_t01.dart

@@ -0,0 +1,46 @@
+// 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.
+
+/// @assertion logicalOrPattern ::= ( logicalOrPattern '|' )? logicalAndPattern
+///
+/// A pair of patterns separated by | matches if either of the branches match
+///
+/// A logical-or pattern may match even if one of its branches does not. That
+/// means that any variables in the non-matching branch would not be
+/// initialized. To avoid problems stemming from that, the following
+/// restrictions apply:
+///
+/// The two branches must define the same set of variables.
+///
+/// If the left branch matches, the right branch is not evaluated. This
+/// determines which value the variable gets if both branches would have
+/// matched. In that case, it will always be the value from the left branch.
+///
+/// @description Checks that it is a compile-time error if two branches of
+/// logical-or pattern define different sets of variables
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=patterns
+
+import "patterns_lib.dart";
+
+main() {
+  Shape shape = Circle(1);
+  switch (shape) {
+    case Square(area: var s1) | Circle(area: var s2):
+//                                               ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+      print("Square or Circle");
+      break;
+    case Rectangle(x: var x, y: var width) | Rectangle(:var x, :var y):
+//                                                                  ^
+// [analyzer] unspecified
+// [cfe] unspecified
+      print("Rectangle");
+      break;
+    default:
+      print("Other");
+  }
+}

LanguageFeatures/Patterns/logical_or_A04_t01.dart

@@ -0,0 +1,67 @@
+// 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.
+
+/// @assertion logicalOrPattern ::= ( logicalOrPattern '|' )? logicalAndPattern
+///
+/// A pair of patterns separated by | matches if either of the branches match
+///
+/// A logical-or pattern may match even if one of its branches does not. That
+/// means that any variables in the non-matching branch would not be
+/// initialized. To avoid problems stemming from that, the following
+/// restrictions apply:
+///
+/// The two branches must define the same set of variables.
+///
+/// If the left branch matches, the right branch is not evaluated. This
+/// determines which value the variable gets if both branches would have
+/// matched. In that case, it will always be the value from the left branch.
+///
+/// @description Checks that if the left branch matches, the right branch is not
+/// evaluated
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=patterns
+
+import "patterns_lib.dart";
+import "../../Utils/expect.dart";
+
+main() {
+  Shape shape1 = Square(1);
+  switch (shape1) {
+    case Square(area: var s) | Point(area: var s):
+      Expect.equals(1, s);
+      break;
+    default:
+      print("Other");
+  }
+
+  Shape shape2 = Circle(1);
+  switch (shape2) {
+    case Square(area: var s) | Circle(area: var s) | Point(area: var s):
+      Expect.equals(3.14, s);
+      break;
+    default:
+      print("Other");
+  }
+
+  Shape shape3 = Circle(1);
+  switch (shape3) {
+    case Circle(area: var s) | Point(area: var s) | Square(area: var s):
+      Expect.equals(3.14, s);
+      break;
+    default:
+      print("Other");
+  }
+
+  Expect.throws(() {
+    Shape shape4 = Point();
+    switch (shape4) {
+      case Square(area: var s) | Point(area: var s):
+        print("Square or Point");
+        break;
+      default:
+        print("Other");
+    }
+  });
+}

LanguageFeatures/Patterns/logical_or_A04_t02.dart

@@ -0,0 +1,42 @@
+// 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.
+
+/// @assertion logicalOrPattern ::= ( logicalOrPattern '|' )? logicalAndPattern
+///
+/// A pair of patterns separated by | matches if either of the branches match
+///
+/// A logical-or pattern may match even if one of its branches does not. That
+/// means that any variables in the non-matching branch would not be
+/// initialized. To avoid problems stemming from that, the following
+/// restrictions apply:
+///
+/// The two branches must define the same set of variables.
+///
+/// If the left branch matches, the right branch is not evaluated. This
+/// determines which value the variable gets if both branches would have
+/// matched. In that case, it will always be the value from the left branch.
+///
+/// @description Checks that if both branches matches then value from the left
+/// branch is taken
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=patterns
+
+import "../../Utils/expect.dart";
+
+class Shape {
+  int counter = 0;
+  double get area => counter++;
+}
+
+main() {
+  Shape shape = Shape();
+  switch (shape) {
+    case Shape(area: var s) | Shape(area: var s) | Shape(area: var s):
+      Expect.equals(0, s);
+      break;
+    default:
+      print("Other");
+  }
+}

LanguageFeatures/Patterns/patterns_lib.dart

@@ -0,0 +1,40 @@
+// 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.
+
+/// @description Defines data commonly used by Patterns tests
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=patterns
+
+library patterns_lib;
+
+abstract class Shape {
+  double get area;
+}
+
+class Square implements Shape {
+  final double length;
+  Square(this.length);
+
+  double get area => length * length;
+}
+
+class Circle implements Shape {
+  final double radius;
+  Circle(this.radius);
+
+  double get area => 3.14 * radius * radius;
+}
+
+class Rectangle implements Shape {
+  final double x, y;
+  Rectangle(this.x, this.y);
+
+  double get area => x * y;
+}
+
+class Point implements Shape {
+  Point();
+  Never get area => throw Exception("Point has no area");
+}