Revert "Add optional message to assert in Dart2js - continued"

pkg/compiler/lib/src/typechecker.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.
 
 library dart2js.typechecker;
 
 import 'common/names.dart' show
     Identifiers;
 import 'common/tasks.dart' show
     CompilerTask;
@@ skipping 128 matching lines @@
 
   String get name => 'dynamic';
 
   DartType computeType(Compiler compiler) => const DynamicType();
 
   bool isCallable(Compiler compiler) => true;
 
   String toString() => 'DynamicAccess';
 }
 
+/// An access of the `assert` method.
+class AssertAccess implements ElementAccess {
+  const AssertAccess();
+
+  Element get element => null;
+
+  String get name => 'assert';
+
+  DartType computeType(Compiler compiler) {
+    return new FunctionType.synthesized(
+        const VoidType(),
+        <DartType>[const DynamicType()]);
+  }
+
+  bool isCallable(Compiler compiler) => true;
+
+  String toString() => 'AssertAccess';
+}
+
 /**
  * An access of a resolved top-level or static property or function, or an
  * access of a resolved element through [:this:].
  */
 class ResolvedAccess extends ElementAccess {
   final Element element;
 
   ResolvedAccess(Element this.element) {
     assert(element != null);
   }
@@ skipping 429 matching lines @@
   void pushCascadeType(DartType type) {
     cascadeTypes = cascadeTypes.prepend(type);
   }
 
   DartType popCascadeType() {
     DartType type = cascadeTypes.head;
     cascadeTypes = cascadeTypes.tail;
     return type;
   }
 
-  DartType visitAssert(Assert node) {
-    analyze(node.condition);
-    if (node.hasMessage) analyze(node.message);
-    return const StatementType();
-  }
-
   DartType visitBlock(Block node) {
     return analyze(node.statements);
   }
 
   DartType visitCascade(Cascade node) {
     analyze(node.expression);
     return popCascadeType();
   }
 
   DartType visitCascadeReceiver(CascadeReceiver node) {
@@ skipping 531 matching lines @@
         // This should be the case but we double-check.
         // TODO(johnniwinther): Ensure that we don't suggest malbounded types.
         return shownTypeGeneric;
       }
     }
     return null;
 
   }
 
   DartType visitSend(Send node) {
+    if (elements.isAssert(node)) {
+      return analyzeInvocation(node, const AssertAccess());
+    }
+
     Element element = elements[node];
 
     if (element != null && element.isConstructor) {
       DartType receiverType;
       if (node.receiver != null) {
         receiverType = analyze(node.receiver);
       } else if (node.selector.isSuper()) {
         // TODO(johnniwinther): Lookup super-member in class members.
         receiverType = superType;
       } else {
@@ skipping 792 matching lines @@
 
   visitTypedef(Typedef node) {
     // Do not typecheck [Typedef] nodes.
   }
 
   visitNode(Node node) {
     compiler.internalError(node,
         'Unexpected node ${node.getObjectDescription()} in the type checker.');
   }
 }