Land Alexander's change that turns assert into a keyword.

lib/compiler/implementation/resolver.dart

 // Copyright (c) 2012, 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.
 
 abstract class TreeElements {
   Element operator[](Node node);
   Selector getSelector(Send send);
   DartType getType(TypeAnnotation annotation);
   bool isParameterChecked(Element element);
 }
@@ skipping 1394 matching lines @@
     visit(node.condition);
     visit(node.thenPart);
     visit(node.elsePart);
   }
 
   static bool isLogicalOperator(Identifier op) {
     String str = op.source.stringValue;
     return (str === '&&' || str == '||' || str == '!');
   }
 
-  /**
-   * Check the lexical scope chain for a declaration with the name "assert".
-   *
-   * This is used to detect whether "assert(x)" is actually an assertion or
-   * just a call expression.
-   * It does not check fields inherited from a superclass.
-   */
-  bool isAssertInLexicalScope() {
-    return scope.lexicalLookup(const SourceString("assert")) !== null;
-  }
-
-  /** Check if [node] is the expression of the current expression statement. */
-  bool isExpressionStatementExpression(Node node) {
-    return currentExpressionStatement !== null &&
-        currentExpressionStatement.expression === node;
-  }
-
   Element resolveSend(Send node) {
     Selector selector = resolveSelector(node);
 
     if (node.receiver === null) {
-      // If this send is the expression of an expression statement, and is on
-      // the form "assert(expr);", and there is no declaration with name
-      // "assert" in the lexical scope, then this is actually an assertion.
-      if (isExpressionStatementExpression(node) &&
-          selector.isAssertSyntax() &&
-          !isAssertInLexicalScope()) {
+      // If this send is of the form "assert(expr);", then
+      // this is an assertion.
+      if (selector.isAssert()) {
+        if (selector.argumentCount != 1) {
+          error(node.selector,
+                MessageKind.WRONG_NUMBER_OF_ARGUMENTS_FOR_ASSERT,
+                [selector.argumentCount]);
+        } else if (selector.namedArgumentCount != 0) {
+          error(node.selector,
+                MessageKind.ASSERT_IS_GIVEN_NAMED_ARGUMENTS,
+                [selector.namedArgumentCount]);
+        }
         return compiler.assertMethod;
       }
       return node.selector.accept(this);
     }
 
     var oldCategory = allowedCategory;
     allowedCategory |=
       ElementCategory.CLASS | ElementCategory.PREFIX | ElementCategory.SUPER;
     Element resolvedReceiver = visit(node.receiver);
     allowedCategory = oldCategory;
@@ skipping 1700 matching lines @@
     return result;
   }
   Element lookup(SourceString name) => localLookup(name);
   Element lexicalLookup(SourceString name) => localLookup(name);
 
   Element add(Element newElement) {
     throw "Cannot add an element in a patch library scope";
   }
   String toString() => 'PatchLibraryScope($origin,$patch)';
 }