Enables codegen support in polymer

pkg/template_binding/lib/src/template_iterator.dart

 // Copyright (c) 2013, 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 template_binding;
 
 // This code is a port of what was formerly known as Model-Driven-Views, now
 // located at:
 //     https://github.com/polymer/TemplateBinding
 //     https://github.com/polymer/NodeBind
 
 // TODO(jmesserly): not sure what kind of boolean conversion rules to
 // apply for template data-binding. HTML attributes are true if they're
 // present. However Dart only treats "true" as true. Since this is HTML we'll
 // use something closer to the HTML rules: null (missing) and false are false,
 // everything else is true.
 // See: https://github.com/polymer/TemplateBinding/issues/59
 bool _toBoolean(value) => null != value && false != value;
 
+// Dart note: this was added to decouple the MustacheTokens.parse function from
+// the rest of template_binding.
+_getDelegateFactory(name, node, delegate) {
+  if (delegate == null) return null;
+  return (pathString) => delegate.prepareBinding(pathString, name, node);
+}
+
 _InstanceBindingMap _getBindings(Node node, BindingDelegate delegate) {
   if (node is Element) {
     return _parseAttributeBindings(node, delegate);
   }
 
   if (node is Text) {
-    var tokens = MustacheTokens.parse(node.text, 'text', node, delegate);
+    var tokens = MustacheTokens.parse(node.text,
+        _getDelegateFactory('text', node, delegate));
     if (tokens != null) return new _InstanceBindingMap(['text', tokens]);
   }
 
   return null;
 }
 
 void _addBindings(Node node, model, [BindingDelegate delegate]) {
   final bindings = _getBindings(node, delegate);
   if (bindings != null) {
     _processBindings(node, bindings, model);
   }
 
   for (var c = node.firstChild; c != null; c = c.nextNode) {
     _addBindings(c, model, delegate);
   }
 }
 
 MustacheTokens _parseWithDefault(Element element, String name,
     BindingDelegate delegate) {
 
   var v = element.attributes[name];
   if (v == '') v = '{{}}';
-  return MustacheTokens.parse(v, name, element, delegate);
+  return MustacheTokens.parse(v, _getDelegateFactory(name, element, delegate));
 }
 
 _InstanceBindingMap _parseAttributeBindings(Element element,
     BindingDelegate delegate) {
 
   var bindings = null;
   var ifFound = false;
   var bindFound = false;
   var isTemplateNode = isSemanticTemplate(element);
 
   element.attributes.forEach((name, value) {
     // Allow bindings expressed in attributes to be prefixed with underbars.
     // We do this to allow correct semantics for browsers that don't implement
     // <template> where certain attributes might trigger side-effects -- and
     // for IE which sanitizes certain attributes, disallowing mustache
     // replacements in their text.
     while (name[0] == '_') {
       name = name.substring(1);
     }
 
     if (isTemplateNode &&
         (name == 'bind' || name == 'if' || name == 'repeat')) {
       return;
     }
 
-    var tokens = MustacheTokens.parse(value, name, element, delegate);
+    var tokens = MustacheTokens.parse(value,
+        _getDelegateFactory(name, element, delegate));
     if (tokens != null) {
       if (bindings == null) bindings = [];
       bindings..add(name)..add(tokens);
     }
   });
 
   if (isTemplateNode) {
     if (bindings == null) bindings = [];
     var result = new _TemplateBindingMap(bindings)
         .._if = _parseWithDefault(element, 'if', delegate)
         .._bind = _parseWithDefault(element, 'bind', delegate)
         .._repeat = _parseWithDefault(element, 'repeat', delegate);
 
     // Treat <template if> as <template bind if>
     if (result._if != null && result._bind == null && result._repeat == null) {
-      result._bind = MustacheTokens.parse('{{}}', 'bind', element, delegate);
+      result._bind = MustacheTokens.parse('{{}}',
+          _getDelegateFactory('bind', element, delegate));
     }
 
     return result;
   }
 
   return bindings == null ? null : new _InstanceBindingMap(bindings);
 }
 
 _processOneTimeBinding(String name, MustacheTokens tokens, Node node, model) {
 
@@ skipping 431 matching lines @@
     _closed = true;
   }
 }
 
 // Dart note: the JavaScript version just puts an expando on the array.
 class _BoundNodes {
   final List<Node> nodes;
   final List<Bindable> instanceBindings;
   _BoundNodes(this.nodes, this.instanceBindings);
 }