Made assert 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 1249 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) {

[ahe, 2012/10/10 08:44:13]

Not sure this check is needed.

[aam-me, 2012/10/11 05:35:25]

If I understand correctly, this check is used to skip complexities of resolving
"a.b(args)" when we have just "a(args)". There are few places in listener where
Send node is created with null receiver.

[ahe, 2012/10/11 05:44:08]

Yes. I'm being stupid :-)

       // 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) &&

[ahe, 2012/10/10 08:44:13]

I don't think this check is needed. This must be the assert method. Then I think
you can get rid of isExpressionStatementExpresssion method.

-          selector.isAssertSyntax() &&
-          !isAssertInLexicalScope()) {
+          selector.isAssertSyntax()) {
         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 1573 matching lines @@
 
   Element localLookup(SourceString name) => library.find(name);
   Element lookup(SourceString name) => localLookup(name);
   Element lexicalLookup(SourceString name) => localLookup(name);
 
   Element add(Element newElement) {
     throw "Cannot add an element in the top scope";
   }
   String toString() => '$element';
 }