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.
+   * This does not find setters, since their name would be "assert=".

[ngeoffray, 2012/09/06 09:37:31]

what is this assert=? We don't create new names to setters.

[Lasse Reichstein Nielsen, 2012/09/06 11:16:14]

That's from the specification.
The name of the declaration "get foo {}" is "foo", and the name of the
declaration "set foo(x){}" is "foo=".

The specification of assert says to test whether there is a declaration named
"assert" in the lexical scope. A setter does not match this.

+   *
+   */
+  bool isAssertInLexicalScope() {
+    for (Scope scope = this.scope; scope !== null; scope = scope.parent) {

[ahe, 2012/09/06 08:50:42]

Could we make this an operation on the scope instead? For example,
lexicalLookup?

[Lasse Reichstein Nielsen, 2012/09/06 09:12:36]

How about
 for (Scope.scope in this.scope.chain) { 
? 
I.e., make a getter called chain that returns an iterable that iterates the
Scope chain?

+      Element local = scope.localLookup(const SourceString("assert"));
+      if (local !== null) {
+        if (local.isAbstractField()) {

[ahe, 2012/09/06 08:50:42]

I don't believe this implementation is correct:

assert(c) {}
class Fisk {
  set assert(x) {} // This should hide assert in this lexical scope.
  void test() {
    assert(false); // This is an assert statement, no assert in lexical scope.
  }
}

Otherwise, the scope rules are wrong.

[Lasse Reichstein Nielsen, 2012/09/06 09:12:36]

I queried Gilad, and this interpretation of the specification is correct and
intentional.

The setter does not hide the outer declaration in this loop because of the
'continue' in the case where the getter is null. I.e., only a getter can shadow
the outer declaration.
And it shouldn't, just as a Send lookup would not be stopped by only a setter
without a getter (or a SendSet by a getter without a setter).

The dart2js scope lookup doesn't account for this, which is why I stopped using
"lexicalLookup" and wrote a manual scope traversal.

+          AbstractFieldElement field = local;
+          if (field.getter === null) continue;
+        }
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /** Check whether [node] is the body of the current expression statement. */
+  bool isExpressionStatementBody(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 body 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 (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);
+  }
+
+  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 add(Element newElement) {
     throw "Cannot add an element in the top scope";
   }
   String toString() => '$element';
 }