Add tests for the user-definable >>> operator.

Change-Id: I485d8cae7499fd31a69f279c64c3f465241a474d
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/180843
Commit-Queue: Lasse R.H. Nielsen <[email protected]>
Reviewed-by: Erik Ernst <[email protected]>

Author: lrhn

tests/language/operator/operator_triple_shift_error_test.dart

@@ -0,0 +1,72 @@
+// Copyright (c) 2021, 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.
+
+// SharedOptions=--enable-experiment=triple-shift
+
+// Can only be declared with exactly one required positional parameter.
+class C2 {
+  Object? operator >>>(arg1, arg2) => arg1;
+  //               ^
+  // [cfe] Operator '>>>' should have exactly one parameter.
+  //               ^^^
+  // [analyzer] COMPILE_TIME_ERROR.WRONG_NUMBER_OF_PARAMETERS_FOR_OPERATOR
+}
+
+class CO1 {
+  Object? operator >>>([arg1]) => arg1;
+  //                    ^^^^
+  // [cfe] An operator can't have optional parameters.
+  // [analyzer] COMPILE_TIME_ERROR.OPTIONAL_PARAMETER_IN_OPERATOR
+}
+
+class C1O1 {
+  Object? operator >>>(arg1, [arg2]) => arg1;
+  //               ^
+  // [cfe] Operator '>>>' should have exactly one parameter.
+  //                          ^^^^
+  // [analyzer] COMPILE_TIME_ERROR.OPTIONAL_PARAMETER_IN_OPERATOR
+}
+
+class C1N1 {
+  Object? operator >>>(arg1, {arg2}) => arg1;
+  //               ^
+  // [cfe] Operator '>>>' should have exactly one parameter.
+  //                          ^^^^
+  // [analyzer] COMPILE_TIME_ERROR.OPTIONAL_PARAMETER_IN_OPERATOR
+}
+
+class C0 {
+  Object? operator >>>() => 0;
+  //               ^
+  // [cfe] Operator '>>>' should have exactly one parameter.
+  //               ^^^
+  // [analyzer] COMPILE_TIME_ERROR.WRONG_NUMBER_OF_PARAMETERS_FOR_OPERATOR
+}
+
+// Operators cannot be generic.
+class Gen {
+  Object? operator >>> <T>(T arg1) => arg1;
+  //                    ^
+  // [cfe] Types parameters aren't allowed when defining an operator.
+  //                   ^^^
+  // [analyzer] SYNTACTIC_ERROR.TYPE_PARAMETERS_ON_OPERATOR
+}
+
+// Operators cannot be static.
+class Static {
+  /**/ static Object? operator >>>(arg) => arg;
+  //   ^^^^^^
+  // [cfe] Operators can't be static.
+  // [analyzer] SYNTACTIC_ERROR.STATIC_OPERATOR
+}
+
+main() {
+  C0();
+  CO1();
+  C1O1();
+  C1N1();
+  C2();
+  Gen();
+  Static();
+}

tests/language/operator/operator_triple_shift_test.dart

@@ -0,0 +1,77 @@
+// Copyright (c) 2021, 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.
+
+// SharedOptions=--enable-experiment=triple-shift
+
+import "package:expect/expect.dart";
+
+class C {
+  static int ctr = 0;
+  final Object? _text;
+  C([Object? text]) : _text = text ?? "${++ctr}";
+
+  // It's possible to declare a `>>>` operator.
+  C operator >>>(arg) => C("(${++ctr}:$_text>>>$arg)");
+
+  // + binds more strongly than `>>`, `>>>` and `<<`.
+  C operator +(arg) => C("(${++ctr}:$_text+$arg)");
+  // Both `>>` and `<<` binds exactly as strongly as `>>>`.
+  C operator >>(arg) => C("(${++ctr}:$_text>>$arg)");
+  C operator <<(arg) => C("(${++ctr}:$_text<<$arg)");
+  // & binds less strongly than `>>`, `>>>` and `<<`.
+  C operator &(arg) =>  C("(${++ctr}:$_text&$arg)");
+
+  String toString() => "${_text}";
+}
+
+class NSM {
+  noSuchMethod(i) => i.memberName;
+}
+
+// Valid in extensions too.
+extension ShiftIt<T> on T {
+  List<T> operator >>>(int count) => List<T>.filled(count, this);
+}
+
+main() {
+  // It's possible to use the `>>>` operator.
+  // Evaluation is left-to-right.
+  Expect.equals("(3:1>>>2)", "${C() >>> C()}");
+
+  var c = C();
+  Expect.equals("4", "$c");
+  c >>>= C();
+  Expect.equals("(6:4>>>5)", "$c");
+
+  // Precedence is as expected.
+  // Different precedence than + (which binds stronger) and & (which doesn't).
+  Expect.equals("(11:(9:7+8)>>>10)", "${C() + C() >>> C()}");
+  Expect.equals("(16:12>>>(15:13+14))", "${C() >>> C() + C()}");
+  Expect.equals("(23:(19:17+18)>>>(22:20+21))", "${C() + C() >>> C() + C()}");
+  Expect.equals("(28:(26:24>>>25)&27)", "${C() >>> C() & C()}");
+  Expect.equals("(33:29&(32:30>>>31))", "${C() & C() >>> C()}");
+  Expect.equals("(40:(38:34&(37:35>>>36))&39)", "${C() & C() >>> C() & C()}");
+
+  // Same precedence as `>>` and `<<`, left associative.
+  Expect.equals("(45:(43:41>>>42)>>44)", "${C() >>> C() >> C()}");
+  Expect.equals("(50:(48:46>>47)>>>49)", "${C() >> C() >>> C()}");
+  Expect.equals("(55:(53:51>>>52)<<54)", "${C() >>> C() << C()}");
+  Expect.equals("(60:(58:56<<57)>>>59)", "${C() << C() >>> C()}");
+  Expect.equals("(67:(65:(63:61<<62)>>>64)>>66)",
+      "${C() << C() >>> C() >> C()}");
+
+  /// The `>>>` Symbol works.
+  var literalSymbol = #>>>;
+  var constSymbol = const Symbol(">>>");
+  var newSymbol = new Symbol(">>>");
+  Expect.identical(literalSymbol, constSymbol);
+  Expect.equals(literalSymbol, newSymbol);
+
+  dynamic n = NSM();
+  var nsmSymbol = n >>> 42;
+  Expect.equals(nsmSymbol, literalSymbol);
+
+  var o = Object();
+  Expect.listEquals([o, o, o, o, o], o >>> 5);
+}