Implement tear-off closure operator #

tests/language/tearoff_basic_test.dart

Index: tests/language/tearoff_basic_test.dart
diff --git a/tests/language/tearoff_basic_test.dart b/tests/language/tearoff_basic_test.dart
new file mode 100644
index 0000000000000000000000000000000000000000..303d38efc34bd8d06a90c88c20d0a631012c42a5
--- /dev/null
+++ b/tests/language/tearoff_basic_test.dart
@@ -0,0 +1,166 @@
+// Copyright (c) 2015, 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.
+
+// Basic test for tear-off closures.
+
+import "package:expect/expect.dart";
+import "tearoff_basic_lib.dart" as P;
+import "tearoff_basic_lib.dart" deferred as D;
+
+class C {
+  var v = 99;
+  final fv = 444;
+
+  operator + (a) { return v + a; }
+  get sugus => "sugus";
+  set frosch(a) { v = "ribbit $a"; }
+  foo() => "kuh";
+
+  static var st;
+  static final stfin = 1000;
+  static stfoo([p1 = 100]) => p1 * 10;
+  static get stg => "stg";
+  static set sts(x) { st = x; }
+}
+
+
+testStatic() {
+  // Closurize static variable.
+  var a = C#st=;
+  a(100);
+  Expect.equals(100, C.st);
+  var b = C#st;
+  Expect.equals(100, b());
+
+  // Closurize static final variable.
+  a = C#stfin;
+  Expect.equals(1000, a());
+  Expect.throws(() => C#stfin= );  // Final variable has no setter.
+
+  // Closurize static method.
+  a = C#stfoo;
+  Expect.equals(1000, a());
+  Expect.equals(90, a(9));
+
+  // Closurize static getter.
+  a = C#stg;
+  Expect.equals("stg", a());
+
+  // Closurize static setter.
+  Expect.throws(() => C#sts);  // No setter/method named sts exists.
+  a = C#sts=;
+  a("pflug");
+  Expect.equals("pflug", C.st);
+
+  // Can't closurize instance method via class literal.
+  Expect.throws(() => C#foo);
+
+  // Extracted closures must be equal.
+  Expect.isTrue(C#st == C#st);
+  Expect.isTrue(C#st= == C#st=);
+  Expect.isTrue(C#stfin == C#stfin);
+  Expect.isTrue(C#stfoo == C#stfoo);
+  Expect.isTrue(C#stg == C#stg);
+  Expect.isTrue(C#sts= == C#sts=);
+}
+
+testInstance() {
+  var o = new C();
+  var p = new C();
+  var a, b;
+
+  // Closurize instance variable.
+  a = o#v;
+  Expect.equals(99, a());
+  b = p#v=;
+  b(999);
+  Expect.equals(999, p.v);
+  Expect.equals(99, a());
+
+  // Closurize final instance variable.
+  Expect.throws(() => o#fv=);  // Final variable has not setter.
+  a = o#fv;
+  Expect.equals(444, a());
+
+  // Closurize instance method.
+  a = o#foo;
+  Expect.equals("kuh", a());
+
+  // Closurize operator.
+  a = o#+;
+  Expect.equals(100, o + 1);
+  Expect.equals(100, a(1));
+
+  // Closurize instance getter.
+  a = o#sugus;
+  Expect.equals("sugus", a());
+  Expect.throws(() => o#sugus=);
+
+  // Closurize instance setter.
+  a = o#frosch=;
+  a("!");
+  Expect.equals("ribbit !", o.v);
+  Expect.throws(() => o#frosch);
+
+  // Extracted closures must be equal.
+  Expect.isTrue(o#v == o#v);
+  Expect.isTrue(o#v= == o#v=);
+  Expect.isTrue(o#fv == o#fv);
+  Expect.isTrue(o#foo == o#foo);
+  Expect.isTrue(o#+ == o#+);
+  Expect.isTrue(o#sugus == o#sugus);
+  Expect.isTrue(o#frosch= == o#frosch=);
+}
+
+testPrefix() {
+  // Closurize top-level variable.
+  var a = P#cvar;
+  Expect.equals(6, a());
+  var b = P#cvar=;
+  b(7);
+  Expect.equals(7, a());
+
+  // Closurize final top-level variable.
+  a = P#cfinvar;
+  Expect.equals("set in stone", a());
+  Expect.throws(() => P#cfinvar=);
+
+  // Closurize top-level function.
+  a = P#cfunc;
+  Expect.equals("cfunc", a());
+
+  // Closurize top-level getter.
+  a = P#cget;
+  Expect.equals("cget", a());
+
+  // Closurize top-level getter.
+  a = P#cset=;
+  a(99);
+  Expect.equals(99, P.cvar);
+
+  Expect.throws(() => P#ZZ);  // Cannot closurize class.
+
+  // Extracted closures must be equal.
+  Expect.isTrue(P#cvar == P#cvar);
+  Expect.isTrue(P#cvar= == P#cvar=);
+  Expect.isTrue(P#cfinvar == P#cfinvar);
+  Expect.isTrue(P#cfunc == P#cfunc);
+  Expect.isTrue(P#cget == P#cget);
+  Expect.isTrue(P#cset= == P#cset=);
+}
+
+testDeferred() {
+  Expect.throws(() => D#cfunc);
+  D.loadLibrary().then((_) {
+    var a = D#cfunc;
+    Expect.equals("cfunc", a());
+  });
+}
+
+main() {
+  testStatic();
+  testInstance();
+  testPrefix();
+  testDeferred();
+}