Remove asserts from minified program.

lib/compiler/implementation/dart_backend/backend.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.
 
+const bool REMOVE_ASSERTS = false;
+
 class ElementAst {
   final Node ast;
   final TreeElements treeElements;
 
   ElementAst(this.ast, this.treeElements);
 
-  factory ElementAst.rewrite(ast, treeElements) {
-    final rewriter = new FunctionBodyRewriter(treeElements);
+  factory ElementAst.rewrite(compiler, ast, treeElements) {
+    final rewriter = new FunctionBodyRewriter(compiler, treeElements);
     return new ElementAst(rewriter.visit(ast), rewriter.cloneTreeElements);
   }
 
   ElementAst.forClassLike(this.ast)
       : this.treeElements = new TreeElementMapping();
 }
 
 class AggregatedTreeElements extends TreeElementMapping {
   final List<TreeElements> treeElements;
 
@@ skipping 30 matching lines @@
   VariableListAst(ast) : super(ast, new AggregatedTreeElements());
 
   add(VariableElement element, TreeElements treeElements) {
     AggregatedTreeElements e = this.treeElements;
     e[element.cachedNode] = element;
     e.treeElements.add(treeElements);
   }
 }
 
 class FunctionBodyRewriter extends CloningVisitor {
-  FunctionBodyRewriter(originalTreeElements) : super(originalTreeElements);
+  final Compiler compiler;
+
+  FunctionBodyRewriter(this.compiler, originalTreeElements)
+      : super(originalTreeElements);
 
   visitFunctionExpression(FunctionExpression node) {
-    shouldOmit(Statement statement) => statement is EmptyStatement;
+    shouldOmit(Statement statement) {
+      if (statement is EmptyStatement) return true;
+      if (statement is ExpressionStatement) {
+        Send send = statement.expression.asSend();
+        if (send !== null) {
+          Element element = originalTreeElements[send];
+          if (REMOVE_ASSERTS && element === compiler.assertMethod) {
+            return true;
+          }
+        }
+      }
+      return false;
+    }
 
     rewriteBody(Statement body) {
       if (body is !Block) return visit(body);
       Block block = body;
       NodeList statements = block.statements;
       LinkBuilder<Statement> builder = new LinkBuilder<Statement>();
       for (Statement statement in statements.nodes) {
         if (!shouldOmit(statement)) builder.addLast(visit(statement));
       }
       return new Block(rewriteNodeList(statements, builder.toLink()));
@@ skipping 114 matching lines @@
                   new ElementAst.forClassLike(parse(element)));
     };
     newClassElementCallback = (ClassElement classElement) {
       if (!shouldOutput(classElement)) return;
       addClass(classElement);
     };
 
     resolvedElements.forEach((element, treeElements) {
       if (!shouldOutput(element)) return;
 
-      var elementAst = new ElementAst.rewrite(parse(element), treeElements);
+      var elementAst = new ElementAst.rewrite(compiler, parse(element), treeElements);

[Roman, 2012/09/18 09:57:43]

80 chars

       if (element.isField()) {
         final list = (element as VariableElement).variables;
         elementAst = elementAsts.putIfAbsent(
             list, () => new VariableListAst(parse(list)));
         (elementAst as VariableListAst).add(element, treeElements);
         element = list;
       }
 
       if (element.isMember()) {
         ClassElement enclosingClass = element.getEnclosingClass();
@@ skipping 135 matching lines @@
 }
 
 compareElements(e0, e1) {
   int result = compareBy((e) => e.getLibrary().uri.toString())(e0, e1);
   if (result != 0) return result;
   return compareBy((e) => e.position().charOffset)(e0, e1);
 }
 
 List<Element> sortElements(Collection<Element> elements) =>
     sorted(elements, compareElements);