anchor.diff:    }
   }
   
  +o.Statement _toUpdateStatement(
  +    BoundElementPropertyAst boundProp,
  +    BoundValueConverter converter,
  +    o.Expression appViewInstance,
  +    o.Expression renderNode,
  +    bool isHtmlElement,
  +    o.ReadVarExpr currValExpr) {
  +  // Wraps current value with sanitization call if necessary.
  +  o.Expression renderValue =
  +      _sanitizedValue(boundProp.securityContext, currValExpr);
  +
  +  switch (boundProp.type) {
  +    case PropertyBindingType.property:
  +      // If user asked for logging bindings, generate code to log them.
  +      if (boundProp.name == 'className') {
  +        // Handle className special case for class="binding".
  +        var updateClassExpr = appViewInstance
  +            .callMethod('updateChildClass', [renderNode, renderValue]);
  +        return updateClassExpr.toStmt();
  +      } else {
  +        return o.importExpr(DomHelpers.setProperty).callFn([
  +          renderNode,
  +          o.literal(boundProp.name),
  +          renderValue,
  +        ]).toStmt();
  +      }
  +      break;
  +    case PropertyBindingType.attribute:
  +      if (boundProp.name == 'class') {
  +        // Handle [attr.class].
  +        var updateClassExpr = appViewInstance
  +            .callMethod('updateChildClass', [renderNode, renderValue]);
  +        return updateClassExpr.toStmt();
  +      } else {
  +        if (boundProp.unit == 'if') {
  +          // Conditional attribute (i.e. [attr.disabled.if]).
  +          //
  +          // For now we treat this as a pure transform to make the
  +          // implementation simpler (and consistent with how it worked before)
  +          // - it would be a non-breaking change to optimize further.
  +          renderValue = renderValue.conditional(o.literal(''), o.NULL_EXPR);
  +        } else {
  +          // For attributes other than class convert to string if necessary.
  +          // The sanitizer returns a string, so we only check if values that
  +          // don't require sanitization need to be converted to a string.
  +          if (boundProp.securityContext == TemplateSecurityContext.none &&
  +              !converter.isString(boundProp.value)) {
  +            renderValue = renderValue.callMethod(
  +              'toString',
  +              const [],
  +              checked: converter.isNullable(boundProp.value),
  +            );
  +          }
  +        }
  +
  +        String attrNs = namespaceUris[boundProp.namespace];
  +        var params = createSetAttributeParams(
  +          renderNode,
  +          attrNs,
  +          boundProp.name,
  +          renderValue,
  +        );
  +
  +        final updateAttribute = o.importExpr(attrNs == null
  +            ? (converter.isNullable(boundProp.value)
  +                ? DomHelpers.updateAttribute
  +                : DomHelpers.setAttribute)
  +            : DomHelpers.updateAttributeNS);
  +
  +        return updateAttribute.callFn(params).toStmt();
  +      }
  +      break;
  +    case PropertyBindingType.cssClass:
  +      final renderMethod = isHtmlElement
  +          ? DomHelpers.updateClassBinding
  +          : DomHelpers.updateClassBindingNonHtml;
  +      return o.importExpr(renderMethod).callFn([
  +        renderNode,
  +        o.literal(boundProp.name),
  +        renderValue,
  +      ]).toStmt();
  +    case PropertyBindingType.style:
  +      // Convert to string if necessary.
  +      o.Expression styleValueExpr = converter.isString(boundProp.value)
  +          ? currValExpr
  +          : currValExpr.callMethod('toString', [],
  +              checked: converter.isNullable(boundProp.value));
  +      // Add units for style value if defined in template.
  +      if (boundProp.unit != null) {
  +        styleValueExpr = styleValueExpr.isBlank().conditional(
  +            o.NULL_EXPR, styleValueExpr.plus(o.literal(boundProp.unit)));
  +      }
  +      // Call Element.style.setProperty(propName, value);
  +      o.Expression updateStyleExpr = renderNode.prop('style').callMethod(
  +          'setProperty', [o.literal(boundProp.name), styleValueExpr]);
  +      return updateStyleExpr.toStmt();
  +  }
  +  throw ArgumentError.value(boundProp.type, 'PropertyBindingType',
  +      'Could not generate statement for property type.');
  +}
  +
   o.Expression _sanitizedValue(
  -    BoundElementPropertyAst boundProp, o.Expression renderValue) {
  +    TemplateSecurityContext securityContext, o.Expression renderValue) {
     String methodName;
  -  switch (boundProp.securityContext) {
  +  switch (securityContext) {
       case TemplateSecurityContext.none:
         return renderValue; // No sanitization needed.
       case TemplateSecurityContext.html:
  
positive.code:       break;
      default:
        throw ArgumentError('internal error, unexpected '
            'TemplateSecurityContext ${boundProp.securityContext}.');
    }
    var ctx = o.importExpr(Identifiers.appViewUtils).prop('sanitizer');
    return ctx.callMethod(methodName, [renderValue]);
  }
  
  void bindRenderInputs(
  
negative.code: import 'package:angular/src/core/security.dart';
  import 'package:angular_compiler/cli.dart';
  
  import 'bound_value_converter.dart';
  import 'compile_element.dart' show CompileElement, CompileNode;
  import 'compile_method.dart' show CompileMethod;
  