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

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.
 
 interface TreeElements {
   Element operator[](Node node);
   Selector getSelector(Send send);
   DartType getType(TypeAnnotation annotation);
   bool isParameterChecked(Element element);
 }
@@ skipping 936 matching lines @@
   }
 }
 
 class ResolverVisitor extends CommonResolverVisitor<Element> {
   final TreeElementMapping mapping;
   final Element enclosingElement;
   final TypeResolver typeResolver;
   bool inInstanceContext;
   Scope scope;
   ClassElement currentClass;
+  ExpressionStatement currentExpressionStatement;
   bool typeRequired = false;
   StatementScope statementScope;
   int allowedCategory = ElementCategory.VARIABLE | ElementCategory.FUNCTION;
 
   ResolverVisitor(Compiler compiler, Element element)
     : this.mapping  = new TreeElementMapping(),
       this.enclosingElement = element,
       // When the element is a field, we are actually resolving its
       // initial value, which should not have access to instance
       // fields.
@@ skipping 164 matching lines @@
   }
 
   visitDoWhile(DoWhile node) {
     visitLoopBodyIn(node, node.body, new BlockScope(scope));
     visit(node.condition);
   }
 
   visitEmptyStatement(EmptyStatement node) { }
 
   visitExpressionStatement(ExpressionStatement node) {
+    ExpressionStatement oldExpressionStatement = currentExpressionStatement;
+    currentExpressionStatement = node;
     visit(node.expression);
+    currentExpressionStatement = oldExpressionStatement;
   }
 
   visitFor(For node) {
     Scope blockScope = new BlockScope(scope);
     visitIn(node.initializer, blockScope);
     visitIn(node.condition, blockScope);
     visitIn(node.update, blockScope);
     visitLoopBodyIn(node, node.body, blockScope);
   }
 
@@ skipping 33 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 whether [node] is the body of the current expression statement. */

[ahe, 2012/09/06 22:25:53]

body -> expression.

[Lasse Reichstein Nielsen, 2012/09/07 10:18:57]

Done.

+  bool isExpressionStatementBody(Node node) {

[ahe, 2012/09/06 22:25:53]

I don't like calling this a "body". isExpressionStatementExpression is more
accurate.

[Lasse Reichstein Nielsen, 2012/09/07 10:18:57]

Done.

+    return currentExpressionStatement !== null &&
+        currentExpressionStatement.expression === node;
+  }
+
   Element resolveSend(Send node) {
     Selector selector = resolveSelector(node);
 
     if (node.receiver === null) {
+      // If this send is the body of an expression statement, and is on the

[ahe, 2012/09/06 22:25:53]

body -> expression

[Lasse Reichstein Nielsen, 2012/09/07 10:18:57]

Done.

+      // form "assert(expr);", and there is no declaration with name "assert"
+      // in the lexical scope, then this is actually an assertion.
+      if (isExpressionStatementBody(node) &&
+          selector.isAssertSyntax() &&
+          !isAssertInLexicalScope()) {
+        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;
 
     Element target;
@@ skipping 163 matching lines @@
     // we need to register that fact that we may be calling a closure
     // with the same arguments.
     if (node.isCall &&
         (Element.isInvalid(target) ||
          target.isGetter() ||
          Elements.isClosureSend(node, target))) {
       Selector call = new Selector.callClosureFrom(selector);
       world.registerDynamicInvocation(call.name, call);
     }
 
-    // TODO(ngeoffray): We should do the check in
-    // visitExpressionStatement instead.
-    if (target === compiler.assertMethod && !node.isCall) {
-      // We can only use assert by calling it.
-      if (!inInstanceContext) {
-        error(node, MessageKind.MISSING_ARGUMENTS_TO_ASSERT, [node]);
-      }
-      target = null;
-    }
-
     // TODO(ngeoffray): Warn if target is null and the send is
     // unqualified.
     useElement(node, target);
     registerSend(selector, target);
     return node.isPropertyAccess ? target : null;
   }
 
   visitSendSet(SendSet node) {
     Element target = resolveSend(node);
     Element setter = target;
@@ skipping 1148 matching lines @@
     return e;
   }
 }
 
 class Scope {
   final Element element;
   final Scope parent;
 
   Scope(this.parent, this.element);
   abstract Element add(Element element);
-  abstract Element lookup(SourceString name);
+
+  Element lookup(SourceString name) {
+    Element result = localLookup(name);
+    if (result != null) return result;
+    return parent.lookup(name);
+  }
+
+  Element lexicalLookup(SourceString name) {
+    Element result = localLookup(name);
+    if (result != null) return result;
+    return parent.lexicalLookup(name);
+  }
+
+  abstract Element localLookup(SourceString name);
 }
 
 /**
  * [TypeDeclarationScope] defines the outer scope of a type declaration in
  * which the declared type variables and the entities in the enclosing scope are
  * available but where declared and inherited members are not available. This
  * scope is only used for class/interface declarations during resolution of the
  * class hierarchy. In all other cases [ClassScope] is used.
  */
 class TypeDeclarationScope extends Scope {
   TypeDeclarationElement get element => super.element;
 
   TypeDeclarationScope(parent, TypeDeclarationElement element)
       : super(parent, element) {
     assert(parent !== null);
   }
 
   Element add(Element newElement) {
     throw "Cannot add element to TypeDeclarationScope";
   }
 
   /**
    * Looks up [name] within the type variables declared in [element].
    */
   Element lookupTypeVariable(SourceString name) {
     return null;
   }
 
-  Element lookup(SourceString name) {
+  Element localLookup(SourceString name) {
     Link<DartType> typeVariableLink = element.typeVariables;
     while (!typeVariableLink.isEmpty()) {
       TypeVariableType typeVariable = typeVariableLink.head;
       if (typeVariable.name == name) {
         return typeVariable.element;
       }
       typeVariableLink = typeVariableLink.tail;
     }
-
-    return parent.lookup(name);
+    return null;
   }
 
   String toString() =>
       '$element${element.typeVariables} > $parent';
 }
 
 class MethodScope extends Scope {
   final Map<SourceString, Element> elements;
 
   MethodScope(Scope parent, Element element)
       : super(parent, element),
         this.elements = new Map<SourceString, Element>() {
     assert(parent !== null);
   }
 
-  Element lookup(SourceString name) {
-    Element found = elements[name];
-    if (found !== null) return found;
-    return parent.lookup(name);
-  }
+  Element localLookup(SourceString name) => elements[name];
 
   Element add(Element newElement) {
     if (elements.containsKey(newElement.name)) {
       return elements[newElement.name];
     }
     elements[newElement.name] = newElement;
     return newElement;
   }
 
   String toString() => '$element${elements.getKeys()} > $parent';
 }
 
 class BlockScope extends MethodScope {
   BlockScope(Scope parent) : super(parent, parent.element);
 
   String toString() => 'block${elements.getKeys()} > $parent';
 }
 
 /**
  * [ClassScope] defines the inner scope of a class/interface declaration in
  * which declared members, declared type variables, entities in the enclosing
  * scope and inherited members are available, in the given order.
  */
 class ClassScope extends TypeDeclarationScope {
   ClassScope(Scope parentScope, ClassElement element)
       : super(parentScope, element);
 
-  Element lookup(SourceString name) {
+  Element localLookup(SourceString name) {
     ClassElement cls = element;
     Element result = cls.lookupLocalMember(name);
     if (result !== null) return result;
-    result = super.lookup(name);
-    if (result != null) return result;
+    return super.localLookup(name);
+  }
+
+  Element lookup(SourceString name) {
+    Element result = super.lookup(name);
+    if (result !== null) return result;
+    ClassElement cls = element;
     return cls.lookupSuperMember(name);
   }
 
   Element add(Element newElement) {
     throw "Cannot add an element in a class scope";
   }
 
   String toString() => '$element > $parent';
 }
 
 class TopScope extends Scope {
   LibraryElement get library => element;
 
   TopScope(LibraryElement library) : super(null, library);
-  Element lookup(SourceString name) {
-    return library.find(name);
-  }
+
+  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';
 }