Remove support for --force-strip=asserts from dart2dart.

sdk/lib/_internal/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.
 
 part of dart_backend;
 
 // TODO(ahe): This class is simply wrong.  This backend should use
 // elements when it can, not AST nodes.  Perhaps a [Map<Element,
 // TreeElements>] is what is needed.
 class ElementAst {
   final Node ast;
   final TreeElements treeElements;
 
   ElementAst(this.ast, this.treeElements);
 
-  factory ElementAst.rewrite(compiler, ast, treeElements, stripAsserts) {
-    final rewriter =
-        new FunctionBodyRewriter(compiler, treeElements, stripAsserts);
-    return new ElementAst(rewriter.visit(ast), rewriter.cloneTreeElements);
-  }
-
   ElementAst.forClassLike(this.ast)
       : this.treeElements = new TreeElementMapping(null);
 }
 
 // TODO(ahe): This class should not subclass [TreeElementMapping], if
 // anything, it should implement TreeElements.
 class AggregatedTreeElements extends TreeElementMapping {
   final List<TreeElements> treeElements;
 
   AggregatedTreeElements() : treeElements = <TreeElements>[], super(null);
@@ skipping 28 matching lines @@
 class VariableListAst extends ElementAst {
   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 {
-  final Compiler compiler;
-  final bool stripAsserts;
-
-  FunctionBodyRewriter(this.compiler, originalTreeElements, this.stripAsserts)
-      : super(originalTreeElements);
-
-  visitBlock(Block block) {
-    shouldOmit(Statement statement) {
-      if (statement is EmptyStatement) return true;
-      ExpressionStatement expressionStatement =
-          statement.asExpressionStatement();
-      if (expressionStatement != null) {
-        Send send = expressionStatement.expression.asSend();
-        if (send != null) {
-          Element element = originalTreeElements[send];
-          if (stripAsserts && identical(element, compiler.assertMethod)) {
-            return true;
-          }
-        }
-      }
-      return false;
-    }
-
-    rewriteStatement(Statement statement) {
-      Block block = statement.asBlock();
-      if (block != null) {
-        Link statements = block.statements.nodes;
-        if (!statements.isEmpty && statements.tail.isEmpty) {
-          Statement single = statements.head;
-          bool isDeclaration =
-              single is VariableDefinitions || single is FunctionDeclaration;
-          if (!isDeclaration) return single;
-        }
-      }
-      return statement;
-    }
-
-    NodeList statements = block.statements;
-    LinkBuilder<Statement> builder = new LinkBuilder<Statement>();
-    for (Statement statement in statements.nodes) {
-      if (!shouldOmit(statement)) {
-        builder.addLast(visit(rewriteStatement(statement)));
-      }
-    }
-    return new Block(rewriteNodeList(statements, builder.toLink()));
-  }
-}
-
 class DartBackend extends Backend {
   final List<CompilerTask> tasks;
   final bool forceStripTypes;
   final bool stripAsserts;
   // TODO(antonm): make available from command-line options.
   final bool outputAst = false;
   final Map<Node, String> renames;
   final Map<LibraryElement, String> imports;
   final Map<ClassNode, List<Node>> memberNodes;
   Map<Element, LibraryElement> reexportingLibraries;
@@ skipping 228 matching lines @@
       if (!shouldOutput(classElement)) return;
       addClass(classElement);
     };
 
     compiler.resolverWorld.instantiatedClasses.forEach(
         (ClassElement classElement) {
       if (shouldOutput(classElement)) addClass(classElement);
     });
     resolvedElements.forEach((element, treeElements) {
       if (!shouldOutput(element) || treeElements == null) return;
-      var elementAst = new ElementAst.rewrite(
-          compiler, parse(element), treeElements, stripAsserts);
+      var elementAst = new ElementAst(parse(element), treeElements);
       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 265 matching lines @@
 }
 
 compareElements(e0, e1) {
   int result = compareBy((e) => e.getLibrary().canonicalUri.toString())(e0, e1);
   if (result != 0) return result;
   return compareBy((e) => e.position().charOffset)(e0, e1);
 }
 
 List<Element> sortElements(Iterable<Element> elements) =>
     sorted(elements, compareElements);