[dart2dart] Make removal of asserts and forcing type strips go under

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(compiler, ast, treeElements) {
-    final rewriter = new FunctionBodyRewriter(compiler, 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();
 }
 
 class AggregatedTreeElements extends TreeElementMapping {
   final List<TreeElements> treeElements;
 
@@ skipping 31 matching lines @@
 
   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)
+  FunctionBodyRewriter(this.compiler, originalTreeElements, this.stripAsserts)
       : super(originalTreeElements);
 
   visitBlock(Block block) {
     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) {
+          if (stripAsserts && element === compiler.assertMethod) {
             return true;
           }
         }
       }
       return false;
     }
 
     rewiteStatement(Statement statement) {
       if (statement is Block) {
         Link statements = statement.statements.nodes;
@@ skipping 13 matching lines @@
       if (!shouldOmit(statement)) {
         builder.addLast(visit(rewiteStatement(statement)));
       }
     }
     return new Block(rewriteNodeList(statements, builder.toLink()));
   }
 }
 
 class DartBackend extends Backend {
   final List<CompilerTask> tasks;
-  final bool forceCutDeclarationTypes;
+  final bool forceStripTypes;
+  final bool stripAsserts;
   // TODO(antonm): make available from command-line options.
   final bool outputAst = false;
 
   Map<Element, TreeElements> get resolvedElements =>
       compiler.enqueuer.resolution.resolvedElements;
 
   /**
    * Tells whether it is safe to remove type declarations from variables,
    * functions parameters. It becomes not safe if:
    * 1) TypeError is used somewhere in the code,
@@ skipping 52 matching lines @@
         }
         // Check all supertypes.
         if (element.allSupertypes !== null) {
           workQueue.addAll(element.allSupertypes.toList());
         }
       }
     }
     return true;
   }
 
-  DartBackend(Compiler compiler, this.forceCutDeclarationTypes)
+  DartBackend(Compiler compiler, List<String> strips)
       : tasks = <CompilerTask>[],
+        forceStripTypes = strips.indexOf('types') != -1,
+        stripAsserts = strips.indexOf('asserts') != -1,
         super(compiler);
 
   void enqueueHelpers(Enqueuer world) {
     // Right now resolver doesn't always resolve interfaces needed
     // for literals, so force them. TODO(antonm): fix in the resolver.
     final LITERAL_TYPE_NAMES = const [
       'Map', 'List', 'num', 'int', 'double', 'bool'
     ];
     final coreLibrary = compiler.coreLibrary;
     for (final name in LITERAL_TYPE_NAMES) {
@@ skipping 97 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(compiler, parse(element), treeElements);
+      var elementAst = new ElementAst.rewrite(
+          compiler, parse(element), treeElements, stripAsserts);
       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 55 matching lines @@
     makePlaceholders(element) {
       collector.collect(element);
       if (element is ClassElement) {
         classMembers[element].forEach(makePlaceholders);
       }
     }
     topLevelElements.forEach(makePlaceholders);
     // Create renames.
     Map<Node, String> renames = new Map<Node, String>();
     Map<LibraryElement, String> imports = new Map<LibraryElement, String>();
-    bool shouldCutDeclarationTypes = forceCutDeclarationTypes
+    bool shouldCutDeclarationTypes = forceStripTypes
         || (compiler.enableMinification
             && isSafeToRemoveTypeDeclarations(classMembers));
     renamePlaceholders(
         compiler, collector, renames, imports,
         fixedMemberNames, shouldCutDeclarationTypes);
 
     // Sort elements.
     final sortedTopLevels = sortElements(topLevelElements);
     final sortedClassMembers = new Map<ClassElement, List<Element>>();
     classMembers.forEach((classElement, members) {
@@ skipping 139 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);