Enable strong mode in DDC, fix all warnings/errors

lib/src/js_ast/template.dart

 // Copyright (c) 2014, 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 js_ast;
 
 class TemplateManager {
   Map<String, Template> expressionTemplates = new Map<String, Template>();
   Map<String, Template> statementTemplates = new Map<String, Template>();
 
@@ skipping 287 matching lines @@
     return visit(node);
   }
 
   Instantiator visitProgram(Program node) {
     List instantiators = node.body.map(visitSplayableStatement).toList();
     return (arguments) {
       List<Statement> statements = <Statement>[];
       void add(node) {
         if (node is EmptyStatement) return;
         if (node is Iterable) {
-          statements.addAll(node);
+          for (var n in node) statements.add(n);
         } else {
           statements.add(node.toStatement());
         }
       }
       for (Instantiator instantiator in instantiators) {
         add(instantiator(arguments));
       }
       return new Program(statements);
     };
   }
 
   Instantiator visitBlock(Block node) {
     List instantiators = node.statements.map(visitSplayableStatement).toList();
     return (arguments) {
       List<Statement> statements = <Statement>[];
       void add(node) {
         if (node is EmptyStatement) return;
         if (node is Iterable) {
-          statements.addAll(node);
+          for (var n in node) statements.add(n);
         } else if (node is Block) {
           statements.addAll(node.statements);
         } else {
           statements.add(node.toStatement());
         }
       }
       for (Instantiator instantiator in instantiators) {
         add(instantiator(arguments));
       }
       return new Block(statements);
@@ skipping 145 matching lines @@
         new Catch(makeDeclaration(arguments), makeBody(arguments));
   }
 
   Instantiator visitSwitch(Switch node) {
     Instantiator makeKey = visit(node.key);
     Iterable<Instantiator> makeCases = node.cases.map(visit);
     return (arguments) {
       return new Switch(
           makeKey(arguments),
           makeCases
-              .map((Instantiator makeCase) => makeCase(arguments))
+              .map((makeCase) => makeCase(arguments) as SwitchClause)
               .toList());
     };
   }
 
   Instantiator visitCase(Case node) {
     Instantiator makeExpression = visit(node.expression);
     Instantiator makeBody = visit(node.body);
     return (arguments) {
       return new Case(makeExpression(arguments), makeBody(arguments));
     };
@@ skipping 57 matching lines @@
 
   Instantiator visitConditional(Conditional cond) {
     Instantiator makeCondition = visit(cond.condition);
     Instantiator makeThen = visit(cond.then);
     Instantiator makeOtherwise = visit(cond.otherwise);
     return (arguments) => new Conditional(makeCondition(arguments),
         makeThen(arguments), makeOtherwise(arguments));
   }
 
   Instantiator visitNew(New node) =>
-      handleCallOrNew(node, (target, arguments) => new New(target, arguments));
+      handleCallOrNew(node, (target, arguments) =>
+          new New(target, arguments as List<Expression>));
 
   Instantiator visitCall(Call node) =>
-      handleCallOrNew(node, (target, arguments) => new Call(target, arguments));
+      handleCallOrNew(node, (target, arguments) =>
+          new Call(target, arguments as List<Expression>));
 
   Instantiator handleCallOrNew(Call node, finish(target, arguments)) {
     Instantiator makeTarget = visit(node.target);
     Iterable<Instantiator> argumentMakers =
         node.arguments.map(visitSplayableExpression).toList();
 
     // TODO(sra): Avoid copying call arguments if no interpolation or forced
     // copying.
     return (arguments) {
       Node target = makeTarget(arguments);
       List<Expression> callArguments = <Expression>[];
       for (Instantiator instantiator in argumentMakers) {
         var result = instantiator(arguments);
         if (result is Iterable) {
-          callArguments.addAll(result);
+          for (var r in result) callArguments.add(r);
         } else {
           callArguments.add(result);
         }
       }
       return finish(target, callArguments.toList(growable: false));
     };
   }
 
   Instantiator visitBinary(Binary node) {
     Instantiator makeLeft = visit(node.left);
@@ skipping 47 matching lines @@
 
   Instantiator visitFunctionExpression(FunctionExpression node) {
     List<Instantiator> paramMakers = node.params.map(visitSplayable).toList();
     Instantiator makeBody = visit(node.body);
     // TODO(sra): Avoid copying params if no interpolation or forced copying.
     return (arguments) {
       List<Parameter> params = <Parameter>[];
       for (Instantiator instantiator in paramMakers) {
         var result = instantiator(arguments);
         if (result is Iterable) {
-          params.addAll(result);
+          for (var r in result) params.add(r);
         } else {
           params.add(result);
         }
       }
       var body = makeBody(arguments);
       if (node is ArrowFun) {
         return new ArrowFun(params, body);
       } else if (node is Fun) {
         return new Fun(params, body);
       } else {
@@ skipping 17 matching lines @@
 
   Instantiator visitLiteralNull(LiteralNull node) =>
       (arguments) => new LiteralNull();
 
   Instantiator visitArrayInitializer(ArrayInitializer node) {
     // TODO(sra): Implement splicing?
     List<Instantiator> elementMakers =
         node.elements.map(visit).toList(growable: false);
     return (arguments) {
       List<Expression> elements = elementMakers
-          .map((Instantiator instantiator) => instantiator(arguments))
+          .map((instantiator) => instantiator(arguments) as Expression)
           .toList(growable: false);
       return new ArrayInitializer(elements);
     };
   }
 
   Instantiator visitArrayHole(ArrayHole node) {
     return (arguments) => new ArrayHole();
   }
 
   Instantiator visitObjectInitializer(ObjectInitializer node) {
     List<Instantiator> propertyMakers =
         node.properties.map(visitSplayable).toList();
     return (arguments) {
       List<Property> properties = <Property>[];
       for (Instantiator instantiator in propertyMakers) {
         var result = instantiator(arguments);
         if (result is Iterable) {
-          properties.addAll(result);
+          for (var r in result) properties.add(r);
         } else {
           properties.add(result);
         }
       }
       return new ObjectInitializer(properties);
     };
   }
 
   Instantiator visitProperty(Property node) {
     Instantiator makeName = visit(node.name);
@@ skipping 35 matching lines @@
     List<Instantiator> makeMethods =
         node.methods.map(visitSplayableExpression).toList(growable: true);
     Instantiator makeName = visit(node.name);
     Instantiator makeHeritage = visit(node.heritage);
 
     return (arguments) {
       var methods = <Method>[];
       for (Instantiator instantiator in makeMethods) {
         var result = instantiator(arguments);
         if (result is Iterable) {
-          methods.addAll(result);
+          for (var r in result) methods.add(r);
         } else {
           methods.add(result);
         }
       }
       return new ClassExpression(
           makeName(arguments), makeHeritage(arguments), methods);
     };
   }
 
   Instantiator visitMethod(Method node) {
@@ skipping 76 matching lines @@
           structure: makeStructure(arguments),
           defaultValue: makeDefaultValue(arguments));
     };
   }
 
   @override
   Instantiator visitArrayBindingPattern(ArrayBindingPattern node) {
     List<Instantiator> makeVars = node.variables.map(this.visit).toList();
     return (arguments) {
       return new ArrayBindingPattern(
-          makeVars.map((m) => m(arguments)).toList());
+          makeVars.map((m) => m(arguments) as DestructuredVariable).toList());
     };
   }
 
   @override
   Instantiator visitObjectBindingPattern(ObjectBindingPattern node) {
     List<Instantiator> makeVars = node.variables.map(this.visit).toList();
     return (arguments) {
       return new ObjectBindingPattern(
-          makeVars.map((m) => m(arguments)).toList());
+          makeVars.map((m) => m(arguments) as DestructuredVariable).toList());
     };
   }
 
   @override
   Instantiator visitSimpleBindingPattern(SimpleBindingPattern node) =>
       (arguments) => new SimpleBindingPattern(new Identifier(node.name.name));
 }
 
 /**
  * InterpolatedNodeAnalysis determines which AST trees contain
@@ skipping 19 matching lines @@
     if (count != before) containsInterpolatedNode.add(node);
     return null;
   }
 
   visitInterpolatedNode(InterpolatedNode node) {
     containsInterpolatedNode.add(node);
     if (node.isNamed) holeNames.add(node.nameOrPosition);
     ++count;
   }
 }