Change assert implementation to not depend on a top-level function called 'assert'.

tests/standalone/assert_test.dart

 // Copyright (c) 2011, 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.
 // VMOptions=--enable_asserts
 //
 // Dart test program testing assert statements.
 
 class AssertTest {
   static test() {
     int i = 0;
@@ skipping 31 matching lines @@
     }
     return i;
   }
 
   static testMain() {
     Expect.equals(1, test());
     Expect.equals(1, testClosure());
   }
 }
 
+// A function that accepts 0-2 arguments.
+void poly([a, b]) {
+  polyCount++;
+  polyArg = a;
+}
+// First argument of most recent call to poly.
+var polyArg = 0;
+// Number of calls to poly.
+var polyCount = 0;
+
+class SuperGet {
+  get assert => poly;
+}
+
+class SuperMethod {
+  assert([a, b]) => poly(a, b);
+}
+
+class SuperField {
+  var assert;
+  SuperField() : assert = poly;
+}
+
+class SuperNon {
+  noSuchMethod(x, y) => poly.apply(y);
+}
+
+class SubGet extends SuperGet {
+  void getAssert() {
+    assert;
+  }
+  void assert0() {
+    assert();
+  }
+  void assert1(x) {
+    assert(x);
+  }
+  void assertExp1(x) {
+    var z = assert(x);
+  }
+  void assert2(x) {
+    assert(x, x);
+  }
+}
+
+class SubMethod extends SuperMethod {
+  void getAssert() {
+    assert;
+  }
+  void assert0() {
+    assert();
+  }
+  void assert1(x) {
+    assert(x);
+  }
+  void assertExp1(x) {
+    var z = assert(x);
+  }
+  void assert2(x) {
+    assert(x, x);
+  }
+}
+
+class SubField extends SuperField {
+  void getAssert() {
+    assert;
+  }
+  void assert0() {
+    assert();
+  }
+  void assert1(x) {
+    assert(x);
+  }
+  void assertExp(x) {
+    var z = assert(x);
+  }
+  void assert2(x) {
+    assert(x, x);
+  }
+}
+
+class SubNon extends SuperNon {
+  void getAssert() {
+    assert;
+  }
+  assert0() {
+    assert();
+  }
+  void assert1(x) {
+    assert(x);
+  }
+  void assertExp(x) {
+    var z = assert(x);
+  }
+  void assert2(x) {
+    assert(x, x);
+  }
+}
+
+
+testSuperAssert() {
+  var get = new SubGet();
+  var method = new SubMethod();
+  var field = new SubField();
+  var non = new SubNon();
+
+  function expectCallsPoly(code) {
+    int oldPolyCount = polyCount;
+    int newPolyArg = polyArg + 1;
+    code(newPolyArg);
+    Expect.equals(oldPolyCount + 1, polyCount);
+    Expect.equals(newPolyArg, polyArg);
+  }
+
+  expectAssert(code, [bool noArgument = false]) {
+    int oldPolyCount = polyCount;
+    try {
+      code(polyArg + 1);
+      Expect.fail();
+    } on AssertionError catch (e) {
+    }
+    Expect.equals(oldPolyCount, polyCount);
+  }
+
+  void testAssert(object) {
+    object.getAssert();  // Doesn't fail.
+    expectCallsPoly(object.assert0(), true);  // Not an assert.
+    expectAssert(object.assert1);  // Is real assert.
+    expectCallsPoly(object.assertExp);  // Not an assert in expression position.
+    expectCallsPoly(object.assert2);  // Not an assert with two arguments.
+  }
+
+  testAssert(get);
+  testAssert(method);
+  testAssert(field);
+  testAssert(non);

[Johnni Winther, 2012/09/05 09:07:05]

I see no tests for when an assert method is in lexical scope.

[Lasse Reichstein Nielsen, 2012/09/05 12:51:20]

True, let's add that too. I'll add a lexicalAssert on the superclasses.
This only tests that a superclass-scoped assert is correctly called except for
the exact assert syntax.

Also moved this to language.

+}
+
 main() {
   AssertTest.testMain();
 }