anchor.diff:      return replaceNgSpace(value.replaceAll('\n', '').trimRight());
     }
   
  -  dynamic visitInterpolation(compiler_ast.Interpolation ast, _Mode mode) {
  -    _visitingRoot = false;
  -    _ensureExpressionMode(mode, ast);
  -
  +  @override
  +  o.Expression visitInterpolation(compiler_ast.Interpolation ast, _) {
       final expressionsAreString =
           ast.expressions.every((ast) => isString(ast, _metadata.analyzedClass));
   
  
positive.code:   }
  }
  
  dynamic /* o.Expression | o.Statement */ _convertToStatementIfNeeded(
      _Mode mode, o.Expression expr) {
    if (identical(mode, _Mode.Statement)) {
      return expr.toStmt();
    } else {
      return expr;
    }
  }
  
  void _ensureStatementMode(_Mode mode, compiler_ast.AST ast) {
    if (!identical(mode, _Mode.Statement)) {
      throwFailure('Expected a statement, but saw "$ast"');
    }
  }
  
  void _ensureExpressionMode(_Mode mode, compiler_ast.AST ast) {
    if (!identical(mode, _Mode.Expression)) {
      throwFailure('Expected an expression, but saw "$ast"');
    }
  }
  
  void _flattenStatements(dynamic arg, List<o.Statement> output) {
    if (arg is List) {
      for (var entry in arg) {
        _flattenStatements(entry, output);
      }
    } else {
      output.add(arg as o.Statement);
    }
  }
  
  bool _isBoolType(o.OutputType type) {
    if (type == o.BOOL_TYPE) return true;
    if (type is o.ExternalType) {
  
negative.code:   /// pure proxy fields for collection literals.
    final o.OutputType _boundType;
  
    _AstToExpressionVisitor(
      this._nameResolver,
      this._implicitReceiver,
      this._metadata,
      this._boundType,
    ) {
      assert(_nameResolver != null);
    }
  
    @override
    o.Expression visitBinary(compiler_ast.Binary ast, _) {
      o.BinaryOperator op;
      switch (ast.operation) {
        case "+":
  