anchor.diff:  List<CompileEventListener> collectEventListeners(List<BoundEventAst> hostEvents,
       List<DirectiveAst> dirs, CompileElement compileElement) {
     List<CompileEventListener> eventListeners = [];
  -  hostEvents.forEach((hostEvent) {
  +  for (var hostEvent in hostEvents) {
       compileElement.view.bindings
           .add(new CompileBinding(compileElement, hostEvent));
       var listener = CompileEventListener.getOrCreate(
           compileElement, hostEvent.name, eventListeners);
       listener.addAction(hostEvent, null, null);
  -  });
  +  }
     var i = -1;
  -  dirs.forEach((directiveAst) {
  +  for (var directiveAst in dirs) {
       i++;
       var directiveInstance = compileElement.directiveInstances[i];
  -    directiveAst.hostEvents.forEach((hostEvent) {
  +    for (var hostEvent in directiveAst.hostEvents) {
         compileElement.view.bindings
             .add(new CompileBinding(compileElement, hostEvent));
         var listener = CompileEventListener.getOrCreate(
             compileElement, hostEvent.name, eventListeners);
         listener.addAction(hostEvent, directiveAst.directive, directiveInstance);
  -    });
  -  });
  -  eventListeners.forEach((listener) => listener.finishMethod());
  +    }
  +  }
  +  for (int i = 0, len = eventListeners.length; i < len; i++) {
  +    eventListeners[i].finishMethod();
  +  }
     return eventListeners;
   }
   
   void bindDirectiveOutputs(DirectiveAst directiveAst,
       o.Expression directiveInstance, List<CompileEventListener> eventListeners) {
     directiveAst.directive.outputs.forEach((observablePropName, eventName) {
  -    eventListeners
  -        .where((listener) => listener.eventName == eventName)
  -        .toList()
  -        .forEach((listener) {
  +    for (int i = 0, len = eventListeners.length; i < len; i++) {
  +      CompileEventListener listener = eventListeners[i];
  +      if (listener.eventName != eventName) continue;
         listener.listenToDirective(directiveInstance, observablePropName);
  -    });
  +    }
     });
   }
   
   void bindRenderOutputs(List<CompileEventListener> eventListeners) {
  -  eventListeners.forEach((listener) => listener.listenToRenderer());
  +  for (int i = 0, len = eventListeners.length; i < len; i++) {
  +    CompileEventListener listener = eventListeners[i];
  +    listener.listenToRenderer();
  +  }
   }
   
   o.Expression convertStmtIntoExpression(o.Statement stmt) {
  
positive.code:     if (lastIndex >= 0) {
        var lastStatement = actionStmts[lastIndex];
        var returnExpr = convertStmtIntoExpression(lastStatement);
        var preventDefaultVar =
            o.variable('pd_${ this . _actionResultExprs . length}');
        this._actionResultExprs.add(preventDefaultVar);
        if (returnExpr != null) {
          // Note: We need to cast the result of the method call to dynamic,
          // as it might be a void method!
  
negative.code:             .toDeclStmt(null, [o.StmtModifier.Final]);
        }
      }
      _method.addStmts(actionStmts);
    }
  
    void finishMethod() {
      var markPathToRootStart = _hasComponentHostListener
          ? compileElement.appViewContainer.prop('componentView')
          : o.THIS_EXPR;
      o.Expression resultExpr = o.literal(true);
      for (var i = 0, len = _actionResultExprs.length; i < len; i++) {
        resultExpr = resultExpr.and(_actionResultExprs[i]);
      }
      List<o.Statement> stmts = <o.Statement>[
        markPathToRootStart.callMethod('markPathToRootAsCheckOnce', []).toStmt()
      ]
        ..addAll(_method.finish())
        ..add(new o.ReturnStatement(resultExpr));
  
      compileElement.view.eventHandlerMethods.add(new o.ClassMethod(
          this._methodName,
          [this._eventParam],
          stmts,
  