anchor.diff:              ast.right.visit(this, _Mode.Expression)));
     }
   
  -  dynamic visitChain(compiler_ast.Chain ast, dynamic context) {
  -    _visitingRoot = false;
  -    _Mode mode = context;
  +  dynamic visitChain(compiler_ast.Chain ast, _Mode mode) {
  +    _visitingRoot = false;
       ensureStatementMode(mode, ast);
       return visitAll(ast.expressions, mode);
     }
   
  -  dynamic visitConditional(compiler_ast.Conditional ast, dynamic context) {
  -    _visitingRoot = false;
  -    _Mode mode = context;
  +  dynamic visitConditional(compiler_ast.Conditional ast, _Mode mode) {
  +    _visitingRoot = false;
       o.Expression value = ast.condition.visit(this, _Mode.Expression);
       return convertToStatementIfNeeded(
           mode,
  
positive.code:             ast.falseExp.visit(this, _Mode.Expression)));
    }
  
    dynamic visitEmptyExpr(compiler_ast.EmptyExpr ast, dynamic context) {
      _Mode mode = context;
      final value = _isBoolType(_boundType)
          ? new o.LiteralExpr(true, o.BOOL_TYPE)
          : new o.LiteralExpr('', o.STRING_TYPE);
      return convertToStatementIfNeeded(mode, value);
    }
  
    dynamic visitPipe(compiler_ast.BindingPipe ast, dynamic context) {
      _visitingRoot = false;
      _Mode mode = context;
      var input = ast.exp.visit(this, _Mode.Expression);
      var args = visitAll(ast.args, _Mode.Expression) as List<o.Expression>;
      var value = _nameResolver.callPipe(ast.name, input, args);
      return convertToStatementIfNeeded(mode, value);
    }
  
    dynamic visitFunctionCall(compiler_ast.FunctionCall ast, dynamic context) {
      _visitingRoot = false;
      _Mode mode = context;
      return convertToStatementIfNeeded(
          mode,
          ast.target
  
negative.code:     assert(_nameResolver != null);
    }
  
    dynamic visitBinary(compiler_ast.Binary ast, _Mode mode) {
      _visitingRoot = false;
      o.BinaryOperator op;
      switch (ast.operation) {
        case "+":
          op = o.BinaryOperator.Plus;
  