From 13b834dfb73abd8eab306c37db43978216b26444 Mon Sep 17 00:00:00 2001
From: Tim van der Lippe <tvanderlippe@google.com>
Date: Tue, 1 Aug 2017 21:07:19 -0700
Subject: [PATCH 01/20] Rewrite expression parser to state machine

---
 lib/mixins/property-effects.html |  65 +----
 lib/utils/binding-parser.html    | 397 +++++++++++++++++++++++++++++++
 test/unit/property-effects.html  |   2 +-
 3 files changed, 402 insertions(+), 62 deletions(-)
 create mode 100644 lib/utils/binding-parser.html

diff --git a/lib/mixins/property-effects.html b/lib/mixins/property-effects.html
index 827c6de1a9..5d78c7cda8 100644
--- a/lib/mixins/property-effects.html
+++ b/lib/mixins/property-effects.html
@@ -13,6 +13,7 @@
 <link rel="import" href="../utils/path.html">
 <!-- for notify, reflect -->
 <link rel="import" href="../utils/case-map.html">
+<link rel="import" href="../utils/binding-parser.html">
 <link rel="import" href="property-accessors.html">
 <!-- for annotated effects -->
 <link rel="import" href="template-stamp.html">
@@ -2627,67 +2628,9 @@
        * @protected
        */
       static _parseBindings(text, templateInfo) {
-        let parts = [];
-        let lastIndex = 0;
-        let m;
-        // Example: "literal1{{prop}}literal2[[!compute(foo,bar)]]final"
-        // Regex matches:
-        //        Iteration 1:  Iteration 2:
-        // m[1]: '{{'          '[['
-        // m[2]: ''            '!'
-        // m[3]: 'prop'        'compute(foo,bar)'
-        while ((m = bindingRegex.exec(text)) !== null) {
-          // Add literal part
-          if (m.index > lastIndex) {
-            parts.push({literal: text.slice(lastIndex, m.index)});
-          }
-          // Add binding part
-          let mode = m[1][0];
-          let negate = Boolean(m[2]);
-          let source = m[3].trim();
-          let customEvent = false, notifyEvent = '', colon = -1;
-          if (mode == '{' && (colon = source.indexOf('::')) > 0) {
-            notifyEvent = source.substring(colon + 2);
-            source = source.substring(0, colon);
-            customEvent = true;
-          }
-          let signature = parseMethod(source);
-          let dependencies = [];
-          if (signature) {
-            // Inline computed function
-            let {args, methodName} = signature;
-            for (let i=0; i<args.length; i++) {
-              let arg = args[i];
-              if (!arg.literal) {
-                dependencies.push(arg);
-              }
-            }
-            let dynamicFns = templateInfo.dynamicFns;
-            if (dynamicFns && dynamicFns[methodName] || signature.static) {
-              dependencies.push(methodName);
-              signature.dynamicFn = true;
-            }
-          } else {
-            // Property or path
-            dependencies.push(source);
-          }
-          parts.push({
-            source, mode, negate, customEvent, signature, dependencies,
-            event: notifyEvent
-          });
-          lastIndex = bindingRegex.lastIndex;
-        }
-        // Add a final literal part
-        if (lastIndex && lastIndex < text.length) {
-          let literal = text.substring(lastIndex);
-          if (literal) {
-            parts.push({
-              literal: literal
-            });
-          }
-        }
-        if (parts.length) {
-          return parts;
+        const parserParts = new Polymer.BindingParser().parse(text, templateInfo);
+        if (parserParts.length) {
+          return parserParts;
         } else {
           return null;
         }
diff --git a/lib/utils/binding-parser.html b/lib/utils/binding-parser.html
new file mode 100644
index 0000000000..43cfbdda61
--- /dev/null
+++ b/lib/utils/binding-parser.html
@@ -0,0 +1,397 @@
+<!--
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+-->
+<link rel="import" href="boot.html">
+<script>
+(function() {
+    'use strict';
+
+    const BINDINGS = {
+        '{': '}',
+        '[': ']'
+    };
+
+  /**
+   * Module with utilities for converting between "dash-case" and "camelCase"
+   * identifiers.
+   *
+   * @namespace
+   * @memberof Polymer
+   * @summary Module that provides utilities for converting between "dash-case"
+   *   and "camelCase".
+   */
+  class BindingParser {
+
+    constructor() {
+        this._parts = [];
+    }
+
+    parse(text, templateInfo) {
+        this.text = text;
+        this.bindingData = {
+            dependencies: []
+        };
+
+        const STATE = {
+            INITIAL: (char, i) => {
+                //console.log('INITIAL')
+                switch (char) {
+                    case '{':
+                    case '[': {
+                        this._pushLiteral(i);
+                        this._startChar = i;
+                        return STATE.FIRSTOPENINGBINDING(char);
+                    }
+                }
+            },
+            FIRSTOPENINGBINDING: binding => (char, i) => {
+                //console.log('FIRSTOPENINGBINDING')
+                switch (char) {
+                    case binding: {
+                        this._startChar = i + 1;
+                        return STATE.FIRSTCHARACTERBINDING(binding);
+                    }
+                    default: {
+                        return STATE.INITIAL;
+                    }
+                }
+            },
+            FIRSTCHARACTERBINDING: (binding) => char => {
+                //console.log('FIRSTCHARACTERBINDING')
+                switch (char) {
+                    case '!': {
+                        this.bindingData.negate = true;
+                        this._startChar = i + 1;
+                    }
+                    default: {
+                        return STATE.BINDING(binding)
+                    }
+                }
+            },
+            BINDING: binding => (char, i) => {
+                //console.log('BINDING')
+                switch (char) {
+                    case BINDINGS[binding]: {
+                        return STATE.FIRSTCLOSINGBINDING(binding);
+                    }
+                    case '\'':
+                    case '"': {
+                        return STATE.STRING(binding, char);
+                    }
+                    case '(': {
+                        this.bindingData.signature = {
+                            methodName: text.substring(this._startChar, i).trim(),
+                            args: [],
+                            static: true
+                        };
+                        this._startChar = i + 1;
+                        return STATE.METHOD(binding)
+                    }
+                    case ':': {
+                        return STATE.FIRSTCOLON(binding)
+                    }
+                }
+            },
+            FIRSTCOLON: binding => (char, i) => {
+                switch (char) {
+                    case ':': {
+                        this.bindingData.customEvent = true;
+                        this._startCharAfterColon = i + 1;
+                        return STATE.COLONNOTIFYEVENT(binding)
+                    }
+                    default: {
+                        return STATE.BINDING(binding)
+                    }
+                }
+            },
+            COLONNOTIFYEVENT: binding => char => {
+                switch (char) {
+                    case BINDINGS[binding]: {
+                        return STATE.COLONNOTIFYEVENTFIRSTCLOSINGBINDING(binding);
+                    }
+                }
+            },
+            COLONNOTIFYEVENTFIRSTCLOSINGBINDING: binding => char => {
+                switch (char) {
+                    case BINDINGS[binding]: {
+                        this.bindingData.event = text.substring(this._startCharAfterColon, i - 1).trim();
+                        this.bindingData.mode = binding;
+                        const prop = text.substring(this._startChar, this._startCharAfterColon - 2).trim();
+                        this.bindingData.source = prop;
+                        this.bindingData.dependencies.push(prop);
+                        this._storeBindingData();
+                        this._startChar = i + 1;
+                        return STATE.INITIAL;
+                    }
+                    default: {
+                        return STATE.BINDING(binding);
+                    }
+                }
+            },
+            FIRSTCLOSINGBINDING: binding => (char, i) => {
+                //console.log('FIRSTCLOSINGBINDING')
+                switch (char) {
+                    case BINDINGS[binding]: {
+                        this.bindingData.mode = binding;
+                        const prop = text.substring(this._startChar, i - 1).trim();
+                        this.bindingData.source = prop;
+                        this.bindingData.dependencies.push(prop);
+                        this._storeBindingData();
+                        this._startChar = i + 1;
+                        return STATE.INITIAL;
+                    }
+                    default: {
+                        return STATE.BINDING(binding);
+                    }
+                }
+            },
+            STRING: (binding, quote) => {
+                let escaped = false;
+                return char => {
+                    //console.log('STRING')
+                    switch (char) {
+                        case '\\': {
+                            escaped = true;
+                            break;
+                        }
+                        case quote: {
+                            if (!escaped) {
+                                return STATE.BINDING(binding)
+                            }
+                        }
+                        default: {
+                            escaped = false;
+                        }
+                        
+                    }
+                }
+            },
+            METHOD: (binding) => {
+                let escaped = false;
+                return (char, i) => {
+                    //console.log('METHOD')
+                    switch (char) {
+                        case ')': {
+                            const methodName = this.bindingData.signature.methodName;
+                            const dynamicFns = templateInfo.dynamicFns;
+                            if (dynamicFns && dynamicFns[methodName] || this.bindingData.signature.static) {
+                                this.bindingData.dependencies.push(methodName);
+                                this.bindingData.signature.dynamicFn = true;
+                            }
+                            const name = text.substring(this._startChar, i).trim();
+                            this.bindingData.mode = binding;
+                            if (name) {
+                                this.bindingData.signature.args.push({
+                                    name 
+                                });
+                                this.bindingData.dependencies.push(name)
+                            }
+                            this._storeBindingData();
+                            return STATE.METHODCLOSED(binding)
+                        }
+                        case ',': {
+                            const name = text.substring(this._startChar, i).trim();
+                            if (name) {
+                                this.bindingData.signature.args.push({
+                                    name
+                                });
+                                this.bindingData.dependencies.push(name)
+                            }
+                            this._startChar = i + 1;
+                            break;
+                        }
+                        case '\'':
+                        case '"': {
+                            return STATE.STRINGARG(binding, char);
+                        }
+                        default: {
+                            if (char >= '0' && char <= '9' || char === '-') {
+                                return STATE.NUMBERARG(binding)
+                            }
+
+                            if (char != ' ' && char != '\n') {
+                                return STATE.VARIABLEARG(binding)
+                            }
+                        }
+                    }
+                }
+            },
+            STRINGARG: (binding, quote) => {
+                let escaped = false;
+                return char => {
+                    //console.log('STRINGARG')
+                    switch (char) {
+                        case '\\': {
+                            escaped = true;
+                            break;
+                        }
+                        case quote: {
+                            if (!escaped) {
+                                const value = text.substring(this._startChar, i)
+                                        .replace(/^\s+/, '')
+                                        .substring(1)
+                                        // replace comma entity with comma
+                                        .replace(/&comma;/g, ',')
+                                        // repair extra escape sequences; note only commas strictly need
+                                        // escaping, but we allow any other char to be escaped since its
+                                        // likely users will do this
+                                        .replace(/\\(.)/g, '\$1');
+                                this.bindingData.signature.args.push({
+                                    value,
+                                    name: value,
+                                    literal: true
+                                });
+                                this._startChar = i + 1;
+                                return STATE.METHOD(binding)
+                            }
+                        }
+                        default: {
+                            escaped = false;
+                        }
+                    }
+                }
+            },
+            NUMBERARG: binding => char => {
+                //console.log('NUMBERARG')
+                switch (char) {
+                    case ',': {
+                        const value = text.substring(this._startChar, i).trim();
+                        this.bindingData.signature.args.push({
+                            name: value,
+                            value: Number(value),
+                            literal: true
+                        });
+                        this._startChar = i + 1;
+                        return STATE.METHOD(binding)
+                    }
+                    case ')': {
+                        const methodName = this.bindingData.signature.methodName;
+                        const dynamicFns = templateInfo.dynamicFns;
+                        if (dynamicFns && dynamicFns[methodName] || this.bindingData.signature.static) {
+                            this.bindingData.dependencies.push(methodName);
+                            this.bindingData.signature.dynamicFn = true;
+                        }
+                        const value = text.substring(this._startChar, i).trim();
+                        this.bindingData.signature.args.push({
+                            name: value,
+                            value: Number(value),
+                            literal: true
+                        });
+                        this._storeBindingData();
+                        return STATE.METHODCLOSED(binding)
+                    }
+                    default: {
+                        if (char < '0' || char > '9') {
+                            return STATE.VARIABLEARG(binding)
+                        }
+                    }
+                }
+            },
+            VARIABLEARG: binding => char => {
+                //console.log('VARIABLEARG')
+                switch (char) {
+                    case ',': {
+                        const name = text.substring(this._startChar, i).trim();
+                        const arg = {
+                            name
+                        }
+                        arg.structured = Polymer.Path.isPath(name);
+                        if (arg.structured) {
+                            arg.wildcard = (name.slice(-2) == '.*');
+                            if (arg.wildcard) {
+                                arg.name = name.slice(0, -2);
+                            }
+                        }
+                        this.bindingData.signature.args.push(arg);
+                        this.bindingData.signature.static = false;
+                        this.bindingData.dependencies.push(name)
+                        this._startChar = i + 1;
+                        return STATE.METHOD(binding)
+                    }
+                    case ')': {
+                        const methodName = this.bindingData.signature.methodName;
+                        const dynamicFns = templateInfo.dynamicFns;
+                        this.bindingData.signature.static = false;
+                        if (dynamicFns && dynamicFns[methodName] || this.bindingData.signature.static) {
+                            this.bindingData.dependencies.push(methodName);
+                            this.bindingData.signature.dynamicFn = true;
+                        }
+                        const name = text.substring(this._startChar, i).trim();
+                        const arg = {
+                            name
+                        }
+                        arg.structured = Polymer.Path.isPath(name);
+                        if (arg.structured) {
+                            arg.wildcard = (name.slice(-2) == '.*');
+                            if (arg.wildcard) {
+                                arg.name = name.slice(0, -2);
+                            }
+                        }
+                        this.bindingData.signature.args.push(arg);
+                        this.bindingData.dependencies.push(name)
+                        this._storeBindingData();
+                        return STATE.METHODCLOSED(binding)
+                    }
+                }
+            },
+            METHODCLOSED: binding => char => {
+                //console.log('METHODCLOSED')
+                switch (char) {
+                    case BINDINGS[binding]: {
+                        return STATE.METHODCLOSEDBINDING(binding);
+                    }
+                }
+            },
+            METHODCLOSEDBINDING: binding => char => {
+                //console.log('METHODCLOSED')
+                switch (char) {
+                    case BINDINGS[binding]: {
+                        this._startChar = i + 1;
+                        return STATE.INITIAL();
+                    }
+                }
+            }
+        }
+
+        let state = STATE.INITIAL;
+        let i,l;
+
+        for (i=0,l=text.length; i<l; i++) {
+            state = state(text.charAt(i), i) || state;
+        }
+
+        // console.log(this._startChar, i)
+        if (this._parts.length) {
+            this._pushLiteral(i);
+        }
+
+        return this._parts;
+    }
+
+    _pushLiteral(i) {
+        const literal = this.text.substring(this._startChar || 0, i);
+        if (literal) {
+            this._parts.push({
+                literal
+            });
+        }
+    }
+
+    _storeBindingData() {
+        this._parts.push(this.bindingData);
+        this.bindingData = {
+            dependencies: []
+        };
+    }
+
+  };
+
+  Polymer.BindingParser = BindingParser;
+})();
+</script>
diff --git a/test/unit/property-effects.html b/test/unit/property-effects.html
index 2a7581fbb5..c272c04127 100644
--- a/test/unit/property-effects.html
+++ b/test/unit/property-effects.html
@@ -1252,7 +1252,7 @@
 
   test('malformed bindings ignored', function() {
     el.bool = true;
-    assert.isTrue(el.$.boundChild.textContent.indexOf('really.long.identifier.in.malformed.binding.should.be.ignored') >= 0, true);
+    assert.isFalse(el.$.boundChild.textContent.indexOf('really.long.identifier.in.malformed.binding.should.be.ignored') >= 0, true);
     assert.isTrue(el.$.boundChild.textContent.indexOf('really.long.literal.in.malformed.binding.should.be.ignored') >= 0, true);
     assert.isTrue(el.$.boundChild.textContent.indexOf('3foo') >= 0, true);
   });

From 79d05b8a22d69d403d30a085a19705436d71ca71 Mon Sep 17 00:00:00 2001
From: Tim van der Lippe <tvanderlippe@google.com>
Date: Tue, 1 Aug 2017 21:11:42 -0700
Subject: [PATCH 02/20] Fix linter warnings

---
 lib/mixins/property-effects.html | 18 -------
 lib/utils/binding-parser.html    | 85 ++++++++++++++++----------------
 2 files changed, 42 insertions(+), 61 deletions(-)

diff --git a/lib/mixins/property-effects.html b/lib/mixins/property-effects.html
index 5d78c7cda8..032bc7797a 100644
--- a/lib/mixins/property-effects.html
+++ b/lib/mixins/property-effects.html
@@ -821,24 +821,6 @@
 
   const emptyArray = [];
 
-  // Regular expressions used for binding
-  const IDENT  = '(?:' + '[a-zA-Z_$][\\w.:$\\-*]*' + ')';
-  const NUMBER = '(?:' + '[-+]?[0-9]*\\.?[0-9]+(?:[eE][-+]?[0-9]+)?' + ')';
-  const SQUOTE_STRING = '(?:' + '\'(?:[^\'\\\\]|\\\\.)*\'' + ')';
-  const DQUOTE_STRING = '(?:' + '"(?:[^"\\\\]|\\\\.)*"' + ')';
-  const STRING = '(?:' + SQUOTE_STRING + '|' + DQUOTE_STRING + ')';
-  const ARGUMENT = '(?:(' + IDENT + '|' + NUMBER + '|' +  STRING + ')\\s*' + ')';
-  const ARGUMENTS = '(?:' + ARGUMENT + '(?:,\\s*' + ARGUMENT + ')*' + ')';
-  const ARGUMENT_LIST = '(?:' + '\\(\\s*' +
-                                '(?:' + ARGUMENTS + '?' + ')' +
-                              '\\)\\s*' + ')';
-  const BINDING = '(' + IDENT + '\\s*' + ARGUMENT_LIST + '?' + ')'; // Group 3
-  const OPEN_BRACKET = '(\\[\\[|{{)' + '\\s*';
-  const CLOSE_BRACKET = '(?:]]|}})';
-  const NEGATE = '(?:(!)\\s*)?'; // Group 2
-  const EXPRESSION = OPEN_BRACKET + NEGATE + BINDING + CLOSE_BRACKET;
-  const bindingRegex = new RegExp(EXPRESSION, "g");
-
   /**
    * Create a string from binding parts of all the literal parts
    *
diff --git a/lib/utils/binding-parser.html b/lib/utils/binding-parser.html
index 43cfbdda61..06ea6b86c3 100644
--- a/lib/utils/binding-parser.html
+++ b/lib/utils/binding-parser.html
@@ -37,6 +37,7 @@
         this.bindingData = {
             dependencies: []
         };
+        /* eslint-disable no-fallthrough */
 
         const STATE = {
             INITIAL: (char, i) => {
@@ -172,52 +173,49 @@
                     }
                 }
             },
-            METHOD: (binding) => {
-                let escaped = false;
-                return (char, i) => {
-                    //console.log('METHOD')
-                    switch (char) {
-                        case ')': {
-                            const methodName = this.bindingData.signature.methodName;
-                            const dynamicFns = templateInfo.dynamicFns;
-                            if (dynamicFns && dynamicFns[methodName] || this.bindingData.signature.static) {
-                                this.bindingData.dependencies.push(methodName);
-                                this.bindingData.signature.dynamicFn = true;
-                            }
-                            const name = text.substring(this._startChar, i).trim();
-                            this.bindingData.mode = binding;
-                            if (name) {
-                                this.bindingData.signature.args.push({
-                                    name 
-                                });
-                                this.bindingData.dependencies.push(name)
-                            }
-                            this._storeBindingData();
-                            return STATE.METHODCLOSED(binding)
+            METHOD: (binding) => (char, i) => {
+                //console.log('METHOD')
+                switch (char) {
+                    case ')': {
+                        const methodName = this.bindingData.signature.methodName;
+                        const dynamicFns = templateInfo.dynamicFns;
+                        if (dynamicFns && dynamicFns[methodName] || this.bindingData.signature.static) {
+                            this.bindingData.dependencies.push(methodName);
+                            this.bindingData.signature.dynamicFn = true;
                         }
-                        case ',': {
-                            const name = text.substring(this._startChar, i).trim();
-                            if (name) {
-                                this.bindingData.signature.args.push({
-                                    name
-                                });
-                                this.bindingData.dependencies.push(name)
-                            }
-                            this._startChar = i + 1;
-                            break;
+                        const name = text.substring(this._startChar, i).trim();
+                        this.bindingData.mode = binding;
+                        if (name) {
+                            this.bindingData.signature.args.push({
+                                name 
+                            });
+                            this.bindingData.dependencies.push(name)
                         }
-                        case '\'':
-                        case '"': {
-                            return STATE.STRINGARG(binding, char);
+                        this._storeBindingData();
+                        return STATE.METHODCLOSED(binding)
+                    }
+                    case ',': {
+                        const name = text.substring(this._startChar, i).trim();
+                        if (name) {
+                            this.bindingData.signature.args.push({
+                                name
+                            });
+                            this.bindingData.dependencies.push(name)
+                        }
+                        this._startChar = i + 1;
+                        break;
+                    }
+                    case '\'':
+                    case '"': {
+                        return STATE.STRINGARG(binding, char);
+                    }
+                    default: {
+                        if (char >= '0' && char <= '9' || char === '-') {
+                            return STATE.NUMBERARG(binding)
                         }
-                        default: {
-                            if (char >= '0' && char <= '9' || char === '-') {
-                                return STATE.NUMBERARG(binding)
-                            }
 
-                            if (char != ' ' && char != '\n') {
-                                return STATE.VARIABLEARG(binding)
-                            }
+                        if (char != ' ' && char != '\n') {
+                            return STATE.VARIABLEARG(binding)
                         }
                     }
                 }
@@ -358,6 +356,7 @@
                 }
             }
         }
+        /* eslint-enable no-fallthrough */
 
         let state = STATE.INITIAL;
         let i,l;
@@ -390,7 +389,7 @@
         };
     }
 
-  };
+  }
 
   Polymer.BindingParser = BindingParser;
 })();

From 7eb1a627f9119fbbaade8f316db591b9dd84c457 Mon Sep 17 00:00:00 2001
From: Tim van der Lippe <tvanderlippe@google.com>
Date: Wed, 2 Aug 2017 14:07:15 -0700
Subject: [PATCH 03/20] Refactor to be functional and add more tests

---
 lib/mixins/property-effects.html         |   2 +-
 lib/utils/binding-parser.html            | 476 ++++++++++-------------
 test/unit/property-effects-elements.html |  10 +
 test/unit/property-effects.html          |  30 +-
 4 files changed, 240 insertions(+), 278 deletions(-)

diff --git a/lib/mixins/property-effects.html b/lib/mixins/property-effects.html
index 032bc7797a..15f9e5cdc7 100644
--- a/lib/mixins/property-effects.html
+++ b/lib/mixins/property-effects.html
@@ -2610,7 +2610,7 @@
        * @protected
        */
       static _parseBindings(text, templateInfo) {
-        const parserParts = new Polymer.BindingParser().parse(text, templateInfo);
+        const parserParts = Polymer.BindingParser.parse(text, templateInfo);
         if (parserParts.length) {
           return parserParts;
         } else {
diff --git a/lib/utils/binding-parser.html b/lib/utils/binding-parser.html
index 06ea6b86c3..fdb17fe98c 100644
--- a/lib/utils/binding-parser.html
+++ b/lib/utils/binding-parser.html
@@ -8,6 +8,7 @@
 subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
 -->
 <link rel="import" href="boot.html">
+<link rel="import" href="path.html">
 <script>
 (function() {
     'use strict';
@@ -17,6 +18,67 @@
         '[': ']'
     };
 
+    function pushLiteral(text, i, parts, startChar) {
+        const literal = text.substring(startChar || 0, i);
+        if (literal) {
+            parts.push({
+                literal
+            });
+        }
+    }
+
+    function storeMethod(bindingData, templateInfo) {
+        const methodName = bindingData.signature.methodName;
+        const dynamicFns = templateInfo.dynamicFns;
+        if (dynamicFns && dynamicFns[methodName] || bindingData.signature.static) {
+            bindingData.dependencies.push(methodName);
+            bindingData.signature.dynamicFn = true;
+        }
+    }
+
+    function storeVariableBinding(parts, bindingData, prop, i) {
+        bindingData.source = prop;
+        bindingData.dependencies.push(prop);
+        bindingData.startChar = i + 1;
+        parts.push(bindingData);
+    }
+
+    function storeMethodVariable(bindingData, text, i) {
+        const name = text.substring(bindingData.startChar, i).trim();
+        if (name) {
+            if (name === 'true' || name === 'false') {
+                bindingData.signature.args.push({
+                    name,
+                    value: name == 'true',
+                    literal: true
+                });
+            } else {
+                const arg = {
+                    name
+                }
+                arg.structured = Polymer.Path.isPath(name);
+                if (arg.structured) {
+                    arg.wildcard = (name.slice(-2) == '.*');
+                    if (arg.wildcard) {
+                        arg.name = name.slice(0, -2);
+                    }
+                }
+                bindingData.signature.args.push(arg);
+                bindingData.dependencies.push(name)
+                bindingData.signature.static = false;
+            }
+        }
+    }
+
+    function storeMethodNumber(bindingData, text, i) {
+        const value = text.substring(bindingData.startChar, i).trim();
+        bindingData.signature.args.push({
+            name: value,
+            value: Number(value),
+            literal: true
+        });
+    }
+
   /**
    * Module with utilities for converting between "dash-case" and "camelCase"
    * identifiers.
@@ -26,369 +88,231 @@
    * @summary Module that provides utilities for converting between "dash-case"
    *   and "camelCase".
    */
-  class BindingParser {
-
-    constructor() {
-        this._parts = [];
-    }
+  const BindingParser = {
 
     parse(text, templateInfo) {
-        this.text = text;
-        this.bindingData = {
-            dependencies: []
-        };
+        const parts = [];
         /* eslint-disable no-fallthrough */
 
         const STATE = {
-            INITIAL: (char, i) => {
-                //console.log('INITIAL')
-                switch (char) {
-                    case '{':
-                    case '[': {
-                        this._pushLiteral(i);
-                        this._startChar = i;
-                        return STATE.FIRSTOPENINGBINDING(char);
+            INITIAL: bindingData => {
+                let escaped = false;
+                return (char, i) => {
+                    if (char === '\\') {
+                        escaped = true;
+                    } else if ((char === '{' || char === '[') && !escaped) {
+                        return STATE.FIRSTOPENINGBINDING({
+                                mode: char,
+                                dependencies: [],
+                                startChar: bindingData.startChar
+                            });
+                    } else {
+                        escaped = false;
                     }
                 }
             },
-            FIRSTOPENINGBINDING: binding => (char, i) => {
-                //console.log('FIRSTOPENINGBINDING')
-                switch (char) {
-                    case binding: {
-                        this._startChar = i + 1;
-                        return STATE.FIRSTCHARACTERBINDING(binding);
-                    }
-                    default: {
-                        return STATE.INITIAL;
-                    }
+            FIRSTOPENINGBINDING: bindingData => (char, i) => {
+                if (char === bindingData.mode) {
+                    pushLiteral(text, i - 1, parts, bindingData.startChar);
+                    bindingData.startChar = i + 1;
+                    return STATE.FIRSTCHARACTERBINDING(bindingData);
                 }
+                return STATE.INITIAL({});
             },
-            FIRSTCHARACTERBINDING: (binding) => char => {
-                //console.log('FIRSTCHARACTERBINDING')
-                switch (char) {
-                    case '!': {
-                        this.bindingData.negate = true;
-                        this._startChar = i + 1;
-                    }
-                    default: {
-                        return STATE.BINDING(binding)
-                    }
+            FIRSTCHARACTERBINDING: (bindingData) => char => {
+                if (char === '!') {
+                    bindingData.negate = true;
+                    bindingData.startChar = i + 1;
                 }
+                return STATE.BINDING(bindingData)
             },
-            BINDING: binding => (char, i) => {
-                //console.log('BINDING')
+            BINDING: bindingData => (char, i) => {
                 switch (char) {
-                    case BINDINGS[binding]: {
-                        return STATE.FIRSTCLOSINGBINDING(binding);
+                    case BINDINGS[bindingData.mode]: {
+                        return STATE.FIRSTCLOSINGBINDING(bindingData);
                     }
                     case '\'':
                     case '"': {
-                        return STATE.STRING(binding, char);
+                        return STATE.STRING(bindingData, char);
                     }
                     case '(': {
-                        this.bindingData.signature = {
-                            methodName: text.substring(this._startChar, i).trim(),
+                        bindingData.signature = {
+                            methodName: text.substring(bindingData.startChar, i).trim(),
                             args: [],
                             static: true
                         };
-                        this._startChar = i + 1;
-                        return STATE.METHOD(binding)
+                        return STATE.METHOD(bindingData)
                     }
                     case ':': {
-                        return STATE.FIRSTCOLON(binding)
+                        return STATE.FIRSTCOLON(bindingData)
                     }
                 }
             },
-            FIRSTCOLON: binding => (char, i) => {
-                switch (char) {
-                    case ':': {
-                        this.bindingData.customEvent = true;
-                        this._startCharAfterColon = i + 1;
-                        return STATE.COLONNOTIFYEVENT(binding)
-                    }
-                    default: {
-                        return STATE.BINDING(binding)
-                    }
+            FIRSTCOLON: bindingData => (char, i) => {
+                if (char === ':') {
+                    bindingData.customEvent = true;
+                    bindingData.startCharAfterColon = i + 1;
+                    return STATE.COLONNOTIFYEVENT(bindingData)
                 }
+                return STATE.BINDING(bindingData)
             },
-            COLONNOTIFYEVENT: binding => char => {
-                switch (char) {
-                    case BINDINGS[binding]: {
-                        return STATE.COLONNOTIFYEVENTFIRSTCLOSINGBINDING(binding);
-                    }
+            COLONNOTIFYEVENT: bindingData => char => {
+                if (char === BINDINGS[bindingData.mode]) {
+                    return STATE.COLONNOTIFYEVENTFIRSTCLOSINGBINDING(bindingData);
                 }
             },
-            COLONNOTIFYEVENTFIRSTCLOSINGBINDING: binding => char => {
-                switch (char) {
-                    case BINDINGS[binding]: {
-                        this.bindingData.event = text.substring(this._startCharAfterColon, i - 1).trim();
-                        this.bindingData.mode = binding;
-                        const prop = text.substring(this._startChar, this._startCharAfterColon - 2).trim();
-                        this.bindingData.source = prop;
-                        this.bindingData.dependencies.push(prop);
-                        this._storeBindingData();
-                        this._startChar = i + 1;
-                        return STATE.INITIAL;
-                    }
-                    default: {
-                        return STATE.BINDING(binding);
-                    }
+            COLONNOTIFYEVENTFIRSTCLOSINGBINDING: bindingData => char => {
+                if (char === BINDINGS[bindingData.mode]) {
+                    bindingData.event = text.substring(bindingData.startCharAfterColon, i - 1).trim();
+                    const prop = text.substring(bindingData.startChar, bindingData.startCharAfterColon - 2).trim();
+                    storeVariableBinding(parts, bindingData, prop, i);
+                    return STATE.INITIAL(bindingData);
                 }
+                return STATE.BINDING(bindingData);
             },
-            FIRSTCLOSINGBINDING: binding => (char, i) => {
-                //console.log('FIRSTCLOSINGBINDING')
-                switch (char) {
-                    case BINDINGS[binding]: {
-                        this.bindingData.mode = binding;
-                        const prop = text.substring(this._startChar, i - 1).trim();
-                        this.bindingData.source = prop;
-                        this.bindingData.dependencies.push(prop);
-                        this._storeBindingData();
-                        this._startChar = i + 1;
-                        return STATE.INITIAL;
-                    }
-                    default: {
-                        return STATE.BINDING(binding);
-                    }
+            FIRSTCLOSINGBINDING: bindingData => (char, i) => {
+                if (char === BINDINGS[bindingData.mode]) {
+                    const prop = text.substring(bindingData.startChar, i - 1).trim();
+                    storeVariableBinding(parts, bindingData, prop, i);
+                    return STATE.INITIAL(bindingData);
                 }
+                return STATE.BINDING(bindingData);
             },
-            STRING: (binding, quote) => {
+            STRING: (bindingData, quote) => {
                 let escaped = false;
                 return char => {
-                    //console.log('STRING')
-                    switch (char) {
-                        case '\\': {
-                            escaped = true;
-                            break;
-                        }
-                        case quote: {
-                            if (!escaped) {
-                                return STATE.BINDING(binding)
-                            }
-                        }
-                        default: {
-                            escaped = false;
-                        }
-                        
+                    if (char === '\\') {
+                        escaped = true;
+                    } else if (char === quote && !escaped) {
+                        return STATE.BINDING(bindingData)
+                    } else {
+                        escaped = false;
                     }
                 }
             },
-            METHOD: (binding) => (char, i) => {
-                //console.log('METHOD')
-                switch (char) {
-                    case ')': {
-                        const methodName = this.bindingData.signature.methodName;
-                        const dynamicFns = templateInfo.dynamicFns;
-                        if (dynamicFns && dynamicFns[methodName] || this.bindingData.signature.static) {
-                            this.bindingData.dependencies.push(methodName);
-                            this.bindingData.signature.dynamicFn = true;
-                        }
-                        const name = text.substring(this._startChar, i).trim();
-                        this.bindingData.mode = binding;
-                        if (name) {
-                            this.bindingData.signature.args.push({
-                                name 
-                            });
-                            this.bindingData.dependencies.push(name)
+            METHOD: (bindingData) => {
+                bindingData.startChar = i + 1;
+                return (char, i) => {
+                    switch (char) {
+                        case ')': {
+                            storeMethodVariable(bindingData, text, i);
+                            storeMethod(bindingData, templateInfo);
+                            bindingData.startChar = i + 1;
+                            return STATE.METHODCLOSED(bindingData);
                         }
-                        this._storeBindingData();
-                        return STATE.METHODCLOSED(binding)
-                    }
-                    case ',': {
-                        const name = text.substring(this._startChar, i).trim();
-                        if (name) {
-                            this.bindingData.signature.args.push({
-                                name
-                            });
-                            this.bindingData.dependencies.push(name)
+                        case ',': {
+                            storeMethodVariable(bindingData, text, i)
+                            bindingData.startChar = i + 1;
+                            break;
                         }
-                        this._startChar = i + 1;
-                        break;
-                    }
-                    case '\'':
-                    case '"': {
-                        return STATE.STRINGARG(binding, char);
-                    }
-                    default: {
-                        if (char >= '0' && char <= '9' || char === '-') {
-                            return STATE.NUMBERARG(binding)
+                        case '\'':
+                        case '"': {
+                            return STATE.STRINGARG(bindingData, char);
                         }
+                        default: {
+                            if (char >= '0' && char <= '9' || char === '-') {
+                                return STATE.NUMBERARG(bindingData)
+                            }
 
-                        if (char != ' ' && char != '\n') {
-                            return STATE.VARIABLEARG(binding)
+                            if (char != ' ' && char != '\n') {
+                                return STATE.VARIABLEARG(bindingData)
+                            }
                         }
                     }
                 }
             },
-            STRINGARG: (binding, quote) => {
+            STRINGARG: (bindingData, quote) => {
                 let escaped = false;
                 return char => {
-                    //console.log('STRINGARG')
-                    switch (char) {
-                        case '\\': {
-                            escaped = true;
-                            break;
-                        }
-                        case quote: {
-                            if (!escaped) {
-                                const value = text.substring(this._startChar, i)
-                                        .replace(/^\s+/, '')
-                                        .substring(1)
-                                        // replace comma entity with comma
-                                        .replace(/&comma;/g, ',')
-                                        // repair extra escape sequences; note only commas strictly need
-                                        // escaping, but we allow any other char to be escaped since its
-                                        // likely users will do this
-                                        .replace(/\\(.)/g, '\$1');
-                                this.bindingData.signature.args.push({
-                                    value,
-                                    name: value,
-                                    literal: true
-                                });
-                                this._startChar = i + 1;
-                                return STATE.METHOD(binding)
-                            }
-                        }
-                        default: {
-                            escaped = false;
-                        }
+                    if (char === '\\') {
+                        escaped = true;
+                    } else if (char === quote && !escaped) {
+                        const value = text.substring(bindingData.startChar, i)
+                                .replace(/^\s+/, '')
+                                .substring(1)
+                                // replace comma entity with comma
+                                .replace(/&comma;/g, ',')
+                                // repair extra escape sequences; note only commas strictly need
+                                // escaping, but we allow any other char to be escaped since its
+                                // likely users will do this
+                                .replace(/\\(.)/g, '\$1');
+                        bindingData.signature.args.push({
+                            value,
+                            name: value,
+                            literal: true
+                        });
+                        return STATE.METHOD(bindingData)
+                    } else {
+                        escaped = false;
                     }
                 }
             },
-            NUMBERARG: binding => char => {
-                //console.log('NUMBERARG')
+            NUMBERARG: bindingData => char => {
                 switch (char) {
                     case ',': {
-                        const value = text.substring(this._startChar, i).trim();
-                        this.bindingData.signature.args.push({
-                            name: value,
-                            value: Number(value),
-                            literal: true
-                        });
-                        this._startChar = i + 1;
-                        return STATE.METHOD(binding)
+                        storeMethodNumber(bindingData, text, i);
+                        return STATE.METHOD(bindingData);
                     }
                     case ')': {
-                        const methodName = this.bindingData.signature.methodName;
-                        const dynamicFns = templateInfo.dynamicFns;
-                        if (dynamicFns && dynamicFns[methodName] || this.bindingData.signature.static) {
-                            this.bindingData.dependencies.push(methodName);
-                            this.bindingData.signature.dynamicFn = true;
-                        }
-                        const value = text.substring(this._startChar, i).trim();
-                        this.bindingData.signature.args.push({
-                            name: value,
-                            value: Number(value),
-                            literal: true
-                        });
-                        this._storeBindingData();
-                        return STATE.METHODCLOSED(binding)
+                        storeMethodNumber(bindingData, text, i);
+                        return STATE.METHODCLOSED(bindingData);
                     }
                     default: {
                         if (char < '0' || char > '9') {
-                            return STATE.VARIABLEARG(binding)
+                            return STATE.VARIABLEARG(bindingData);
                         }
                     }
                 }
             },
-            VARIABLEARG: binding => char => {
-                //console.log('VARIABLEARG')
+            VARIABLEARG: bindingData => char => {
                 switch (char) {
                     case ',': {
-                        const name = text.substring(this._startChar, i).trim();
-                        const arg = {
-                            name
-                        }
-                        arg.structured = Polymer.Path.isPath(name);
-                        if (arg.structured) {
-                            arg.wildcard = (name.slice(-2) == '.*');
-                            if (arg.wildcard) {
-                                arg.name = name.slice(0, -2);
-                            }
-                        }
-                        this.bindingData.signature.args.push(arg);
-                        this.bindingData.signature.static = false;
-                        this.bindingData.dependencies.push(name)
-                        this._startChar = i + 1;
-                        return STATE.METHOD(binding)
+                        storeMethodVariable(bindingData, text, i);
+                        return STATE.METHOD(bindingData)
                     }
                     case ')': {
-                        const methodName = this.bindingData.signature.methodName;
-                        const dynamicFns = templateInfo.dynamicFns;
-                        this.bindingData.signature.static = false;
-                        if (dynamicFns && dynamicFns[methodName] || this.bindingData.signature.static) {
-                            this.bindingData.dependencies.push(methodName);
-                            this.bindingData.signature.dynamicFn = true;
-                        }
-                        const name = text.substring(this._startChar, i).trim();
-                        const arg = {
-                            name
-                        }
-                        arg.structured = Polymer.Path.isPath(name);
-                        if (arg.structured) {
-                            arg.wildcard = (name.slice(-2) == '.*');
-                            if (arg.wildcard) {
-                                arg.name = name.slice(0, -2);
-                            }
-                        }
-                        this.bindingData.signature.args.push(arg);
-                        this.bindingData.dependencies.push(name)
-                        this._storeBindingData();
-                        return STATE.METHODCLOSED(binding)
+                        storeMethodVariable(bindingData, text, i);
+                        return STATE.METHODCLOSED(bindingData)
                     }
                 }
             },
-            METHODCLOSED: binding => char => {
-                //console.log('METHODCLOSED')
-                switch (char) {
-                    case BINDINGS[binding]: {
-                        return STATE.METHODCLOSEDBINDING(binding);
+            METHODCLOSED: bindingData => {
+                storeMethod(bindingData, templateInfo);
+                return char => {
+                    if (char === BINDINGS[bindingData.mode]) {
+                        return STATE.METHODCLOSEDBINDING(bindingData);
+                    }
+                    if (char !== ' ' && char !== '\t' && char !== '\n') {
+                        console.warn(`Invalid binding: "${text}"`);
                     }
                 }
             },
-            METHODCLOSEDBINDING: binding => char => {
-                //console.log('METHODCLOSED')
-                switch (char) {
-                    case BINDINGS[binding]: {
-                        this._startChar = i + 1;
-                        return STATE.INITIAL();
-                    }
+            METHODCLOSEDBINDING: bindingData => (char, i) => {
+                if (char === BINDINGS[bindingData.mode]) {
+                    bindingData.startChar = i + 1;
+                    parts.push(bindingData);
+                    return STATE.INITIAL(bindingData);
+                }
+                if (char !== ' ' && char !== '\t' && char !== '\n') {
+                    console.warn(`Invalid binding: "${text}"`);
                 }
             }
         }
         /* eslint-enable no-fallthrough */
 
-        let state = STATE.INITIAL;
+        let state = STATE.INITIAL({});
         let i,l;
 
         for (i=0,l=text.length; i<l; i++) {
             state = state(text.charAt(i), i) || state;
         }
 
-        // console.log(this._startChar, i)
-        if (this._parts.length) {
-            this._pushLiteral(i);
+        if (parts.length) {
+            pushLiteral(text, i, parts, parts[parts.length - 1].startChar);
         }
 
-        return this._parts;
+        return parts;
     }
-
-    _pushLiteral(i) {
-        const literal = this.text.substring(this._startChar || 0, i);
-        if (literal) {
-            this._parts.push({
-                literal
-            });
-        }
-    }
-
-    _storeBindingData() {
-        this._parts.push(this.bindingData);
-        this.bindingData = {
-            dependencies: []
-        };
-    }
-
   }
 
   Polymer.BindingParser = BindingParser;
diff --git a/test/unit/property-effects-elements.html b/test/unit/property-effects-elements.html
index aeeee70e43..83c53514b9 100644
--- a/test/unit/property-effects-elements.html
+++ b/test/unit/property-effects-elements.html
@@ -81,6 +81,12 @@
           content: '[[binding]]'
         }
       </style>
+      <span id="boundWithSlash">[[objectWithSlash.binding/with/slash]]</span> 
+      <span id="jsonContent">[["Jan", 31],["Feb", 28],["Mar", 31]]</span>
+      <span id="nonEnglishUnicode">{{objectWithNonEnglishUnicode.商品名}}</span>
+      <span id="booleanTrue">foo(field, true): {{computeWithBoolean(otherValue, true)}}</span>
+      <span id="booleanFalse">foo(field, false): {{computeWithBoolean(otherValue, false)}}</span>
+      <span id="escapeBinding">\{{escapeBinding}}\[[escapeBinding2]]</span>
   </template>
   <script>
     let ComputingBehavior = {
@@ -315,6 +321,10 @@
       computeWildcard: function(a, bInfo) {
         return a + (bInfo && bInfo.base ? bInfo.base.value  : 0);
       },
+      computeWithBoolean: function(value, bool) {
+        console.log(bool)
+        return bool ? value : value * 2;
+      },
       fireCustomNotifyingEvent: function() {
         this.customNotifyingValue = 'changed!';
         this.dispatchEvent(new CustomEvent('custom-notifying-value-changed'),
diff --git a/test/unit/property-effects.html b/test/unit/property-effects.html
index c272c04127..419b98d268 100644
--- a/test/unit/property-effects.html
+++ b/test/unit/property-effects.html
@@ -358,6 +358,34 @@
     assert.equal(el.$.boundWithDash.textContent, 'yes');
   });
 
+  test('binding with slash', function() {
+    el.objectWithSlash = {
+      'binding/with/slash': 'yes'
+    };
+    assert.equal(el.$.boundWithSlash.textContent, 'yes');
+  });
+
+  test('json should not be a binding', function() {
+    assert.equal(el.$.jsonContent.textContent, '[["Jan", 31],["Feb", 28],["Mar", 31]]');
+  });
+
+  test('binding with non-English unicode', function() {
+    el.objectWithNonEnglishUnicode = {
+      商品名: 'yes'
+    };
+    assert.equal(el.$.nonEnglishUnicode.textContent, 'yes');
+  });
+
+  test('binding with booleans', function() {
+    el.otherValue = 10;
+    assert.equal(el.$.booleanTrue.textContent, 'foo(field, true): 10');
+    assert.equal(el.$.booleanFalse.textContent, 'foo(field, false): 20');
+  });
+
+  test('escape bindings', function() {
+    assert.equal(el.$.escapeBinding.textContent, '\{{escapeBinding}}\[[escapeBinding2]]');
+  });
+
   test('class attribute without template scope not erased', function() {
     var el = document.querySelector('.class1');
     assert.notEqual(el, null, 'class without template scope is undefined');
@@ -1252,7 +1280,7 @@
 
   test('malformed bindings ignored', function() {
     el.bool = true;
-    assert.isFalse(el.$.boundChild.textContent.indexOf('really.long.identifier.in.malformed.binding.should.be.ignored') >= 0, true);
+    assert.isTrue(el.$.boundChild.textContent.indexOf('really.long.identifier.in.malformed.binding.should.be.ignored') >= 0, true);
     assert.isTrue(el.$.boundChild.textContent.indexOf('really.long.literal.in.malformed.binding.should.be.ignored') >= 0, true);
     assert.isTrue(el.$.boundChild.textContent.indexOf('3foo') >= 0, true);
   });

From 8a5525b006ffbd1dd04d2e8d3dfab63f1d63dec8 Mon Sep 17 00:00:00 2001
From: Tim van der Lippe <tvanderlippe@google.com>
Date: Wed, 2 Aug 2017 16:32:33 -0700
Subject: [PATCH 04/20] Fix linter warning

---
 lib/utils/binding-parser.html | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/utils/binding-parser.html b/lib/utils/binding-parser.html
index fdb17fe98c..11dd49f6d7 100644
--- a/lib/utils/binding-parser.html
+++ b/lib/utils/binding-parser.html
@@ -97,7 +97,7 @@
         const STATE = {
             INITIAL: bindingData => {
                 let escaped = false;
-                return (char, i) => {
+                return char => {
                     if (char === '\\') {
                         escaped = true;
                     } else if ((char === '{' || char === '[') && !escaped) {

From 8cd494795ff702027f392fb1df05293c87eab17e Mon Sep 17 00:00:00 2001
From: Tim van der Lippe <tvanderlippe@google.com>
Date: Wed, 2 Aug 2017 17:29:00 -0700
Subject: [PATCH 05/20] Remove escaping from bindings

---
 lib/utils/binding-parser.html            | 31 ++++++++++--------------
 test/unit/property-effects-elements.html |  2 --
 test/unit/property-effects.html          |  4 ---
 3 files changed, 13 insertions(+), 24 deletions(-)

diff --git a/lib/utils/binding-parser.html b/lib/utils/binding-parser.html
index 11dd49f6d7..e92a3cc32e 100644
--- a/lib/utils/binding-parser.html
+++ b/lib/utils/binding-parser.html
@@ -95,20 +95,13 @@
         /* eslint-disable no-fallthrough */
 
         const STATE = {
-            INITIAL: bindingData => {
-                let escaped = false;
-                return char => {
-                    if (char === '\\') {
-                        escaped = true;
-                    } else if ((char === '{' || char === '[') && !escaped) {
-                        return STATE.FIRSTOPENINGBINDING({
-                                mode: char,
-                                dependencies: [],
-                                startChar: bindingData.startChar
-                            });
-                    } else {
-                        escaped = false;
-                    }
+            INITIAL: bindingData => char => {
+                if ((char === '{' || char === '[')) {
+                    return STATE.FIRSTOPENINGBINDING({
+                        mode: char,
+                        dependencies: [],
+                        startChar: bindingData.startChar
+                    });
                 }
             },
             FIRSTOPENINGBINDING: bindingData => (char, i) => {
@@ -120,11 +113,13 @@
                 return STATE.INITIAL({});
             },
             FIRSTCHARACTERBINDING: (bindingData) => char => {
-                if (char === '!') {
-                    bindingData.negate = true;
-                    bindingData.startChar = i + 1;
+                if (char !== ' ' && char !== '\t' && char !== '\n') {
+                    if (char === '!') {
+                        bindingData.negate = true;
+                        bindingData.startChar = i + 1;
+                    }
+                    return STATE.BINDING(bindingData)
                 }
-                return STATE.BINDING(bindingData)
             },
             BINDING: bindingData => (char, i) => {
                 switch (char) {
diff --git a/test/unit/property-effects-elements.html b/test/unit/property-effects-elements.html
index 83c53514b9..e06574cebe 100644
--- a/test/unit/property-effects-elements.html
+++ b/test/unit/property-effects-elements.html
@@ -86,7 +86,6 @@
       <span id="nonEnglishUnicode">{{objectWithNonEnglishUnicode.商品名}}</span>
       <span id="booleanTrue">foo(field, true): {{computeWithBoolean(otherValue, true)}}</span>
       <span id="booleanFalse">foo(field, false): {{computeWithBoolean(otherValue, false)}}</span>
-      <span id="escapeBinding">\{{escapeBinding}}\[[escapeBinding2]]</span>
   </template>
   <script>
     let ComputingBehavior = {
@@ -322,7 +321,6 @@
         return a + (bInfo && bInfo.base ? bInfo.base.value  : 0);
       },
       computeWithBoolean: function(value, bool) {
-        console.log(bool)
         return bool ? value : value * 2;
       },
       fireCustomNotifyingEvent: function() {
diff --git a/test/unit/property-effects.html b/test/unit/property-effects.html
index 419b98d268..bef3730a68 100644
--- a/test/unit/property-effects.html
+++ b/test/unit/property-effects.html
@@ -382,10 +382,6 @@
     assert.equal(el.$.booleanFalse.textContent, 'foo(field, false): 20');
   });
 
-  test('escape bindings', function() {
-    assert.equal(el.$.escapeBinding.textContent, '\{{escapeBinding}}\[[escapeBinding2]]');
-  });
-
   test('class attribute without template scope not erased', function() {
     var el = document.querySelector('.class1');
     assert.notEqual(el, null, 'class without template scope is undefined');

From 423074d1c4799373c90d32f1ed4fbe0f66450df3 Mon Sep 17 00:00:00 2001
From: Tim van der Lippe <tvanderlippe@google.com>
Date: Tue, 8 Aug 2017 15:08:05 -0700
Subject: [PATCH 06/20] Rewrite parser to use switch-case instead of functions

---
 lib/utils/binding-parser.html | 317 +++++++++++++++++++---------------
 1 file changed, 179 insertions(+), 138 deletions(-)

diff --git a/lib/utils/binding-parser.html b/lib/utils/binding-parser.html
index e92a3cc32e..57babfe7b5 100644
--- a/lib/utils/binding-parser.html
+++ b/lib/utils/binding-parser.html
@@ -18,6 +18,24 @@
         '[': ']'
     };
 
+    const STATE = {
+        INITIAL: 1,
+        FIRSTOPENINGBINDING: 2,
+        FIRSTCHARACTERBINDING: 3,
+        BINDING: 4,
+        FIRSTCOLON: 5,
+        COLONNOTIFYEVENT: 6,
+        COLONNOTIFYEVENTFIRSTCLOSINGBINDING: 7,
+        FIRSTCLOSINGBINDING: 8,
+        STRING: 9,
+        METHOD: 10,
+        STRINGARG: 11,
+        NUMBERARG: 12,
+        VARIABLEARG: 13,
+        METHODCLOSED: 14,
+        METHODCLOSEDBINDING: 15
+    }
+
     function pushLiteral(text, i, parts, startChar) {
         const literal = text.substring(startChar || 0, i);
         if (literal) {
@@ -92,108 +110,132 @@
 
     parse(text, templateInfo) {
         const parts = [];
-        /* eslint-disable no-fallthrough */
+        let bindingData = {};
+        let escaped = false;
+        let quote;
 
-        const STATE = {
-            INITIAL: bindingData => char => {
-                if ((char === '{' || char === '[')) {
-                    return STATE.FIRSTOPENINGBINDING({
-                        mode: char,
-                        dependencies: [],
-                        startChar: bindingData.startChar
-                    });
-                }
-            },
-            FIRSTOPENINGBINDING: bindingData => (char, i) => {
-                if (char === bindingData.mode) {
-                    pushLiteral(text, i - 1, parts, bindingData.startChar);
-                    bindingData.startChar = i + 1;
-                    return STATE.FIRSTCHARACTERBINDING(bindingData);
+        let state = STATE.INITIAL;
+        let i,l;
+
+        for (i=0,l=text.length; i<l; i++) {
+            const char = text.charAt(i);
+            switch (state) {
+                case STATE.INITIAL: {
+                    if ((char === '{' || char === '[')) {
+                        bindingData = {
+                            mode: char,
+                            dependencies: [],
+                            startChar: bindingData.startChar
+                        };
+                        state = STATE.FIRSTOPENINGBINDING;
+                    }
+                    break;
                 }
-                return STATE.INITIAL({});
-            },
-            FIRSTCHARACTERBINDING: (bindingData) => char => {
-                if (char !== ' ' && char !== '\t' && char !== '\n') {
-                    if (char === '!') {
-                        bindingData.negate = true;
+                case STATE.FIRSTOPENINGBINDING: {
+                    if (char === bindingData.mode) {
+                        pushLiteral(text, i - 1, parts, bindingData.startChar);
                         bindingData.startChar = i + 1;
+                        state = STATE.FIRSTCHARACTERBINDING;
+                    } else {
+                        bindingData = {};
+                        state = STATE.INITIAL;
                     }
-                    return STATE.BINDING(bindingData)
+                    break;
                 }
-            },
-            BINDING: bindingData => (char, i) => {
-                switch (char) {
-                    case BINDINGS[bindingData.mode]: {
-                        return STATE.FIRSTCLOSINGBINDING(bindingData);
-                    }
-                    case '\'':
-                    case '"': {
-                        return STATE.STRING(bindingData, char);
-                    }
-                    case '(': {
-                        bindingData.signature = {
-                            methodName: text.substring(bindingData.startChar, i).trim(),
-                            args: [],
-                            static: true
-                        };
-                        return STATE.METHOD(bindingData)
+                case STATE.FIRSTCHARACTERBINDING: {
+                    if (char !== ' ' && char !== '\t' && char !== '\n') {
+                        if (char === '!') {
+                            bindingData.negate = true;
+                            bindingData.startChar = i + 1;
+                        }
+                        state = STATE.BINDING;
                     }
-                    case ':': {
-                        return STATE.FIRSTCOLON(bindingData)
+                    break;
+                }
+                case STATE.BINDING: {
+                    switch (char) {
+                        case BINDINGS[bindingData.mode]: {
+                            state = STATE.FIRSTCLOSINGBINDING;
+                            break;
+                        }
+                        case '\'':
+                        case '"': {
+                            quote = char;
+                            state = STATE.STRING;
+                            break;
+                        }
+                        case '(': {
+                            bindingData.signature = {
+                                methodName: text.substring(bindingData.startChar, i).trim(),
+                                args: [],
+                                static: true
+                            };
+                            bindingData.startChar = i + 1;
+                            state = STATE.METHOD;
+                            break;
+                        }
+                        case ':': {
+                            state = STATE.FIRSTCOLON;
+                        }
                     }
+                    break;
                 }
-            },
-            FIRSTCOLON: bindingData => (char, i) => {
-                if (char === ':') {
-                    bindingData.customEvent = true;
-                    bindingData.startCharAfterColon = i + 1;
-                    return STATE.COLONNOTIFYEVENT(bindingData)
+                case STATE.FIRSTCOLON: {
+                    if (char === ':') {
+                        bindingData.customEvent = true;
+                        bindingData.startCharAfterColon = i + 1;
+                        state = STATE.COLONNOTIFYEVENT;
+                    } else {
+                        state = STATE.BINDING;
+                    }
+                    break;
                 }
-                return STATE.BINDING(bindingData)
-            },
-            COLONNOTIFYEVENT: bindingData => char => {
-                if (char === BINDINGS[bindingData.mode]) {
-                    return STATE.COLONNOTIFYEVENTFIRSTCLOSINGBINDING(bindingData);
+                case STATE.COLONNOTIFYEVENT: {
+                    if (char === BINDINGS[bindingData.mode]) {
+                        state = STATE.COLONNOTIFYEVENTFIRSTCLOSINGBINDING;
+                    }
+                    break;
                 }
-            },
-            COLONNOTIFYEVENTFIRSTCLOSINGBINDING: bindingData => char => {
-                if (char === BINDINGS[bindingData.mode]) {
-                    bindingData.event = text.substring(bindingData.startCharAfterColon, i - 1).trim();
-                    const prop = text.substring(bindingData.startChar, bindingData.startCharAfterColon - 2).trim();
-                    storeVariableBinding(parts, bindingData, prop, i);
-                    return STATE.INITIAL(bindingData);
+                case STATE.COLONNOTIFYEVENTFIRSTCLOSINGBINDING: {
+                    if (char === BINDINGS[bindingData.mode]) {
+                        bindingData.event = text.substring(bindingData.startCharAfterColon, i - 1).trim();
+                        const prop = text.substring(bindingData.startChar, bindingData.startCharAfterColon - 2).trim();
+                        storeVariableBinding(parts, bindingData, prop, i);
+                        state = STATE.INITIAL;
+                    } else {
+                        state = STATE.BINDING;
+                    }
+                    break;
                 }
-                return STATE.BINDING(bindingData);
-            },
-            FIRSTCLOSINGBINDING: bindingData => (char, i) => {
-                if (char === BINDINGS[bindingData.mode]) {
-                    const prop = text.substring(bindingData.startChar, i - 1).trim();
-                    storeVariableBinding(parts, bindingData, prop, i);
-                    return STATE.INITIAL(bindingData);
+                case STATE.FIRSTCLOSINGBINDING: {
+                    if (char === BINDINGS[bindingData.mode]) {
+                        const prop = text.substring(bindingData.startChar, i - 1).trim();
+                        storeVariableBinding(parts, bindingData, prop, i);
+                        state = STATE.INITIAL;
+                    } else {
+                        state = STATE.BINDING;
+                    }
+                    break;
                 }
-                return STATE.BINDING(bindingData);
-            },
-            STRING: (bindingData, quote) => {
-                let escaped = false;
-                return char => {
+                case STATE.STRING: {
                     if (char === '\\') {
                         escaped = true;
                     } else if (char === quote && !escaped) {
-                        return STATE.BINDING(bindingData)
+                        state = STATE.BINDING;
                     } else {
                         escaped = false;
                     }
+                    break;
                 }
-            },
-            METHOD: (bindingData) => {
-                bindingData.startChar = i + 1;
-                return (char, i) => {
+                case STATE.METHOD: {
                     switch (char) {
                         case ')': {
                             storeMethodVariable(bindingData, text, i);
                             storeMethod(bindingData, templateInfo);
                             bindingData.startChar = i + 1;
-                            return STATE.METHODCLOSED(bindingData);
+                            storeMethod(bindingData, templateInfo);
+                            state = STATE.METHODCLOSED;
+                            break;
                         }
                         case ',': {
                             storeMethodVariable(bindingData, text, i)
@@ -202,23 +244,21 @@
                         }
                         case '\'':
                         case '"': {
-                            return STATE.STRINGARG(bindingData, char);
+                            quote = char;
+                            state = STATE.STRINGARG;
+                            break;
                         }
                         default: {
                             if (char >= '0' && char <= '9' || char === '-') {
-                                return STATE.NUMBERARG(bindingData)
-                            }
-
-                            if (char != ' ' && char != '\n') {
-                                return STATE.VARIABLEARG(bindingData)
+                                state = STATE.NUMBERARG;
+                            } else if (char != ' ' && char != '\n') {
+                                state = STATE.VARIABLEARG;
                             }
                         }
                     }
+                    break;
                 }
-            },
-            STRINGARG: (bindingData, quote) => {
-                let escaped = false;
-                return char => {
+                case STATE.STRINGARG: {
                     if (char === '\\') {
                         escaped = true;
                     } else if (char === quote && !escaped) {
@@ -236,71 +276,72 @@
                             name: value,
                             literal: true
                         });
-                        return STATE.METHOD(bindingData)
+                        bindingData.startChar = i + 1;
+                        state = STATE.METHOD;
                     } else {
                         escaped = false;
                     }
+                    break;
                 }
-            },
-            NUMBERARG: bindingData => char => {
-                switch (char) {
-                    case ',': {
-                        storeMethodNumber(bindingData, text, i);
-                        return STATE.METHOD(bindingData);
-                    }
-                    case ')': {
-                        storeMethodNumber(bindingData, text, i);
-                        return STATE.METHODCLOSED(bindingData);
-                    }
-                    default: {
-                        if (char < '0' || char > '9') {
-                            return STATE.VARIABLEARG(bindingData);
+                case STATE.NUMBERARG: {
+                    switch (char) {
+                        case ',': {
+                            storeMethodNumber(bindingData, text, i);
+                            bindingData.startChar = i + 1;
+                            state = STATE.METHOD;
+                            break;
+                        }
+                        case ')': {
+                            storeMethodNumber(bindingData, text, i);
+                            storeMethod(bindingData, templateInfo);
+                            state = STATE.METHODCLOSED;
+                            break;
+                        }
+                        default: {
+                            if (char < '0' || char > '9') {
+                                state = STATE.VARIABLEARG;
+                            }
                         }
                     }
+                    break;
                 }
-            },
-            VARIABLEARG: bindingData => char => {
-                switch (char) {
-                    case ',': {
-                        storeMethodVariable(bindingData, text, i);
-                        return STATE.METHOD(bindingData)
-                    }
-                    case ')': {
-                        storeMethodVariable(bindingData, text, i);
-                        return STATE.METHODCLOSED(bindingData)
+                case STATE.VARIABLEARG: {
+                    switch (char) {
+                        case ',': {
+                            storeMethodVariable(bindingData, text, i);
+                            bindingData.startChar = i + 1;
+                            state = STATE.METHOD;
+                            break;
+                        }
+                        case ')': {
+                            storeMethodVariable(bindingData, text, i);
+                            storeMethod(bindingData, templateInfo);
+                            state = STATE.METHODCLOSED;
+                            break;
+                        }
                     }
+                    break;
                 }
-            },
-            METHODCLOSED: bindingData => {
-                storeMethod(bindingData, templateInfo);
-                return char => {
+                case STATE.METHODCLOSED: {
                     if (char === BINDINGS[bindingData.mode]) {
-                        return STATE.METHODCLOSEDBINDING(bindingData);
-                    }
-                    if (char !== ' ' && char !== '\t' && char !== '\n') {
-                        console.warn(`Invalid binding: "${text}"`);
+                        state = STATE.METHODCLOSEDBINDING;
+                    } else if (char !== ' ' && char !== '\t' && char !== '\n') {
+                        // console.warn(`Invalid binding: "${text}"`);
                     }
+                    break;
                 }
-            },
-            METHODCLOSEDBINDING: bindingData => (char, i) => {
-                if (char === BINDINGS[bindingData.mode]) {
-                    bindingData.startChar = i + 1;
-                    parts.push(bindingData);
-                    return STATE.INITIAL(bindingData);
-                }
-                if (char !== ' ' && char !== '\t' && char !== '\n') {
-                    console.warn(`Invalid binding: "${text}"`);
+                case STATE.METHODCLOSEDBINDING: {
+                    if (char === BINDINGS[bindingData.mode]) {
+                        bindingData.startChar = i + 1;
+                        parts.push(bindingData);
+                        state = STATE.INITIAL;
+                    } else if (char !== ' ' && char !== '\t' && char !== '\n') {
+                        // console.warn(`Invalid binding: "${text}"`);
+                    }
+                    break;
                 }
             }
         }
-        /* eslint-enable no-fallthrough */
-
-        let state = STATE.INITIAL({});
-        let i,l;
-
-        for (i=0,l=text.length; i<l; i++) {
-            state = state(text.charAt(i), i) || state;
-        }
 
         if (parts.length) {
             pushLiteral(text, i, parts, parts[parts.length - 1].startChar);

From 42f7d7854d27d63a4c1ca4828216a7d5d9520433 Mon Sep 17 00:00:00 2001
From: Tim van der Lippe <tvanderlippe@google.com>
Date: Tue, 8 Aug 2017 15:10:13 -0700
Subject: [PATCH 07/20] Add performance test for binding-expressions

---
 test/perf/binding-expressions.html | 77 ++++++++++++++++++++++++++++++
 test/perf/perf-tests.html          | 27 +++++++++++
 2 files changed, 104 insertions(+)
 create mode 100644 test/perf/binding-expressions.html
 create mode 100644 test/perf/perf-tests.html

diff --git a/test/perf/binding-expressions.html b/test/perf/binding-expressions.html
new file mode 100644
index 0000000000..9b70f0b1ab
--- /dev/null
+++ b/test/perf/binding-expressions.html
@@ -0,0 +1,77 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, minimum-scale=1.0, initial-scale=1, user-scalable=yes">
+  <script src="../../bower_components/perf-tester/perf.js"></script>
+  <script src="../../bower_components/webcomponentsjs/webcomponents-lite.js"></script>
+  <link rel="import" href="../../polymer.html">
+</head>
+
+<body>
+
+<!--   <template>
+    {{compute(alaksjflkasjflkasjflkasjlfkajslkfjaslkfjaaaaaaaaaaaaaaaaaaaaaaaa)]}
+  </template>
+ -->    <!-- {{compute(tricky, 'literal\,\'zot\'', this.has.long.log.lo)]} -->
+
+  <template>
+    <span>{{foo}}</span> <span>{{foo.bar}}</span> <span>{{foo.bar.zot}}</span>
+    Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod
+    tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam,
+    quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo
+    consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse
+    cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non
+    proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
+    <span>{{compute(tricky, 'literal\,\'zot\'')}}</span>
+    Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod
+    tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam,
+    quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo
+    consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse
+    cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non
+    proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
+    <span>{{compute(tricky, 'literal\,\'zot\'', this.has.a.bogus.ending.bracket)]}</span>
+    Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod
+    tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam,
+    quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo
+    consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse
+    cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non
+    proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
+    <div class$="{{compute(a, b, c,d,e,f,g,h,i)}}">
+      Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod
+      tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam,
+      quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo
+      consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse
+      cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non
+      proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
+      <span>{{bindings.and.stuff}}</span>
+      <div id="zot"><span>[[computeFn(a, 'b', c, "d", 999)]]</span> literal <span>{{a.b}}</span> literally</div>
+      <div id="zot"><span>[[computeFn(a, 'b', c, "d", 999)]]</span> literal <span>{{a.b}}</span> literally</div>
+      <div id="zot"><span>[[computeFn(a, 'b', c, "d", 999)]]</span> literal <span>{{a.b}}</span> literally</div>
+      <div id="zot"><span>[[computeFn(a, 'b', c, "d", 999)]]</span> literal <span>{{a.b}}</span> literally</div>
+      <div id="zot"><span>[[computeFn(a, 'b', c, "d", 999)]]</span> literal <span>{{a.b}}</span> literally</div>
+      <div id="zot"><span>[[computeFn(a, 'b', c, "d", 999)]]</span> literal <span>{{a.b}}</span> literally</div>
+      <div id="zot"><span>[[computeFn(a, 'b', c, "d", 999)]]</span> literal <span>{{a.b}}</span> literally</div>
+    </div>
+  </template>
+
+  <script>
+  var COUNT = 1000;
+  var templates = [];
+  var template = document.querySelector('template');
+  for (var i=0; i<COUNT; i++) {
+    templates[i] = template.cloneNode(true);
+  }
+  console.perf();
+  for (var i=0; i<COUNT; i++) {
+    const klass = Polymer({
+      is: 'test-el-' + i,
+      _template: templates[i]
+    });
+    new klass();
+  }
+  console.perfEnd();
+  </script>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/test/perf/perf-tests.html b/test/perf/perf-tests.html
new file mode 100644
index 0000000000..f8da4dbe1a
--- /dev/null
+++ b/test/perf/perf-tests.html
@@ -0,0 +1,27 @@
+<!doctype html>
+<html lang="en">
+<head>
+
+  <meta charset="utf-8">
+  <script src="../../bower_components/webcomponentsjs/webcomponents-lite.js"></script>
+  <script src="../../bower_components/perf-tester/perf-tester.js"></script>
+  <link rel="import" href="../../polymer.html">
+  <style>
+    summary {
+      font-family: sans-serif;
+      font-size: 1.5em;
+    }
+  </style>
+
+</head>
+<body>
+  <summary>Perf is go.</summary>
+  <perf-tester runs="25"></perf-tester>
+
+  <script>
+    document.querySelector('perf-tester').tests = [
+      'binding-expressions.html'
+    ];
+  </script>
+
+</body>
\ No newline at end of file

From df0ee35460bbc547f21a7c543e956b7f8a0e707f Mon Sep 17 00:00:00 2001
From: Tim van der Lippe <tvanderlippe@google.com>
Date: Tue, 8 Aug 2017 15:46:49 -0700
Subject: [PATCH 08/20] Add documentation

---
 lib/utils/binding-parser.html | 28 ++++++++++++++++++++--------
 1 file changed, 20 insertions(+), 8 deletions(-)

diff --git a/lib/utils/binding-parser.html b/lib/utils/binding-parser.html
index 57babfe7b5..66545003d3 100644
--- a/lib/utils/binding-parser.html
+++ b/lib/utils/binding-parser.html
@@ -13,11 +13,19 @@
 (function() {
     'use strict';
 
+    /**
+     * The open and corresponding closing brackets for surrounding bindings.
+     * @enum {string}
+     */
     const BINDINGS = {
         '{': '}',
         '[': ']'
     };
 
+    /**
+     * All states that the parser can be in. The states represent the state-machine as a whole.
+     * @enum {number}
+     */
     const STATE = {
         INITIAL: 1,
         FIRSTOPENINGBINDING: 2,
@@ -98,26 +106,30 @@
     }
 
   /**
-   * Module with utilities for converting between "dash-case" and "camelCase"
-   * identifiers.
+   * Module that parses binding expressions and generates corresponding metadata.
    *
    * @namespace
    * @memberof Polymer
-   * @summary Module that provides utilities for converting between "dash-case"
-   *   and "camelCase".
+   * @summary Module that parses binding expressions and generates corresponding metadata.
    */
   const BindingParser = {
 
+    /**
+     * @param {string} text Text to parse from attribute or textContent
+     * @param {Object} templateInfo Current template metadata
+     * @return {Array<!BindingPart>} Array of binding part metadata
+     */
     parse(text, templateInfo) {
         const parts = [];
         let bindingData = {};
         let escaped = false;
+        /** @type {string} */
         let quote;
 
+        /** @type {number} */
         let state = STATE.INITIAL;
-        let i,l;
 
-        for (i=0,l=text.length; i<l; i++) {
+        for (let i=0,l=text.length; i<l; i++) {
             const char = text.charAt(i);
             switch (state) {
                 case STATE.INITIAL: {
@@ -326,7 +338,7 @@
                     if (char === BINDINGS[bindingData.mode]) {
                         state = STATE.METHODCLOSEDBINDING;
                     } else if (char !== ' ' && char !== '\t' && char !== '\n') {
-                        // console.warn(`Invalid binding: "${text}"`);
+                        console.warn(`Expected two closing "${BINDINGS[bindingData.mode]}" for binding "${text}"`);
                     }
                     break;
                 }
@@ -336,7 +348,7 @@
                         parts.push(bindingData);
                         state = STATE.INITIAL;
                     } else if (char !== ' ' && char !== '\t' && char !== '\n') {
-                        // console.warn(`Invalid binding: "${text}"`);
+                        console.warn(`Expected one closing "${BINDINGS[bindingData.mode]}" for binding "${text}"`);
                     }
                     break;
                 }

From 14fac01902ec436d1b8cb8ba429cae025cbbebe4 Mon Sep 17 00:00:00 2001
From: Tim van der Lippe <tvanderlippe@google.com>
Date: Tue, 8 Aug 2017 15:59:04 -0700
Subject: [PATCH 09/20] Fix linter warning

---
 lib/utils/binding-parser.html | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/lib/utils/binding-parser.html b/lib/utils/binding-parser.html
index 66545003d3..357d17a357 100644
--- a/lib/utils/binding-parser.html
+++ b/lib/utils/binding-parser.html
@@ -125,11 +125,11 @@
         let escaped = false;
         /** @type {string} */
         let quote;
-
         /** @type {number} */
         let state = STATE.INITIAL;
+        let i,l;
 
-        for (let i=0,l=text.length; i<l; i++) {
+        for (i=0,l=text.length; i<l; i++) {
             const char = text.charAt(i);
             switch (state) {
                 case STATE.INITIAL: {

From 333a466409c6306a4e40792e12e227dc184e356b Mon Sep 17 00:00:00 2001
From: Tim van der Lippe <tvanderlippe@google.com>
Date: Wed, 16 Aug 2017 19:02:55 -0700
Subject: [PATCH 10/20] Add missing dependency to bower.json

---
 bower.json | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/bower.json b/bower.json
index b2f988911a..b8d6992707 100644
--- a/bower.json
+++ b/bower.json
@@ -25,7 +25,8 @@
   },
   "devDependencies": {
     "web-component-tester": "^6.0.0",
-    "test-fixture": "PolymerElements/test-fixture#3.0.0-rc.1"
+    "test-fixture": "PolymerElements/test-fixture#3.0.0-rc.1",
+    "perf-tester": "polymerlabs/perf-tester"
   },
   "private": true,
   "resolutions": {

From 57a142367be91173c4e77096133f5632f1ffeca8 Mon Sep 17 00:00:00 2001
From: Tim van der Lippe <tvanderlippe@google.com>
Date: Mon, 18 Sep 2017 19:41:15 -0700
Subject: [PATCH 11/20] Extract to a mixin

---
 lib/mixins/property-effects.html         |  85 ++-
 lib/utils/binding-parser.html            | 640 ++++++++++++-----------
 test/unit/property-effects-elements.html |   8 +
 test/unit/property-effects.html          |  66 ++-
 4 files changed, 468 insertions(+), 331 deletions(-)

diff --git a/lib/mixins/property-effects.html b/lib/mixins/property-effects.html
index 15f9e5cdc7..b33b386b0b 100644
--- a/lib/mixins/property-effects.html
+++ b/lib/mixins/property-effects.html
@@ -13,7 +13,6 @@
 <link rel="import" href="../utils/path.html">
 <!-- for notify, reflect -->
 <link rel="import" href="../utils/case-map.html">
-<link rel="import" href="../utils/binding-parser.html">
 <link rel="import" href="property-accessors.html">
 <!-- for annotated effects -->
 <link rel="import" href="template-stamp.html">
@@ -821,6 +820,24 @@
 
   const emptyArray = [];
 
+  // Regular expressions used for binding
+  const IDENT  = '(?:' + '[a-zA-Z_$][\\w.:$\\-*]*' + ')';
+  const NUMBER = '(?:' + '[-+]?[0-9]*\\.?[0-9]+(?:[eE][-+]?[0-9]+)?' + ')';
+  const SQUOTE_STRING = '(?:' + '\'(?:[^\'\\\\]|\\\\.)*\'' + ')';
+  const DQUOTE_STRING = '(?:' + '"(?:[^"\\\\]|\\\\.)*"' + ')';
+  const STRING = '(?:' + SQUOTE_STRING + '|' + DQUOTE_STRING + ')';
+  const ARGUMENT = '(?:(' + IDENT + '|' + NUMBER + '|' +  STRING + ')\\s*' + ')';
+  const ARGUMENTS = '(?:' + ARGUMENT + '(?:,\\s*' + ARGUMENT + ')*' + ')';
+  const ARGUMENT_LIST = '(?:' + '\\(\\s*' +
+                                '(?:' + ARGUMENTS + '?' + ')' +
+                              '\\)\\s*' + ')';
+  const BINDING = '(' + IDENT + '\\s*' + ARGUMENT_LIST + '?' + ')'; // Group 3
+  const OPEN_BRACKET = '(\\[\\[|{{)' + '\\s*';
+  const CLOSE_BRACKET = '(?:]]|}})';
+  const NEGATE = '(?:(!)\\s*)?'; // Group 2
+  const EXPRESSION = OPEN_BRACKET + NEGATE + BINDING + CLOSE_BRACKET;
+  const bindingRegex = new RegExp(EXPRESSION, "g");
+
   /**
    * Create a string from binding parts of all the literal parts
    *
@@ -2610,9 +2627,67 @@
        * @protected
        */
       static _parseBindings(text, templateInfo) {
-        const parserParts = Polymer.BindingParser.parse(text, templateInfo);
-        if (parserParts.length) {
-          return parserParts;
+        let parts = [];
+        let lastIndex = 0;
+        let m;
+        // Example: "literal1{{prop}}literal2[[!compute(foo,bar)]]final"
+        // Regex matches:
+        //        Iteration 1:  Iteration 2:
+        // m[1]: '{{'          '[['
+        // m[2]: ''            '!'
+        // m[3]: 'prop'        'compute(foo,bar)'
+        while ((m = bindingRegex.exec(text)) !== null) {
+          // Add literal part
+          if (m.index > lastIndex) {
+            parts.push({literal: text.slice(lastIndex, m.index)});
+          }
+          // Add binding part
+          let mode = m[1][0];
+          let negate = Boolean(m[2]);
+          let source = m[3].trim();
+          let customEvent = false, notifyEvent = '', colon = -1;
+          if (mode == '{' && (colon = source.indexOf('::')) > 0) {
+            notifyEvent = source.substring(colon + 2);
+            source = source.substring(0, colon);
+            customEvent = true;
+          }
+          let signature = parseMethod(source);
+          let dependencies = [];
+          if (signature) {
+            // Inline computed function
+            let {args, methodName} = signature;
+            for (let i=0; i<args.length; i++) {
+              let arg = args[i];
+              if (!arg.literal) {
+                dependencies.push(arg);
+              }
+            }
+            let dynamicFns = templateInfo.dynamicFns;
+            if (dynamicFns && dynamicFns[methodName] || signature.static) {
+              dependencies.push(methodName);
+              signature.dynamicFn = true;
+            }
+          } else {
+            // Property or path
+            dependencies.push(source);
+          }
+          parts.push({
+            source, mode, negate, customEvent, signature, dependencies,
+            event: notifyEvent
+          });
+          lastIndex = bindingRegex.lastIndex;
+        }
+        // Add a final literal part
+        if (lastIndex && lastIndex < text.length) {
+          let literal = text.substring(lastIndex);
+          if (literal) {
+            parts.push({
+              literal: literal
+            });
+          }
+        }
+        if (parts.length) {
+          return parts;
         } else {
           return null;
         }
@@ -2722,4 +2797,4 @@
   };
 
 })();
-</script>
+</script>
\ No newline at end of file
diff --git a/lib/utils/binding-parser.html b/lib/utils/binding-parser.html
index 357d17a357..0e614d6a2b 100644
--- a/lib/utils/binding-parser.html
+++ b/lib/utils/binding-parser.html
@@ -9,117 +9,151 @@
 -->
 <link rel="import" href="boot.html">
 <link rel="import" href="path.html">
+<link rel="import" href="mixin.html">
+
 <script>
 (function() {
-    'use strict';
-
-    /**
-     * The open and corresponding closing brackets for surrounding bindings.
-     * @enum {string}
-     */
-    const BINDINGS = {
-        '{': '}',
-        '[': ']'
-    };
+  'use strict';
 
-    /**
-     * All states that the parser can be in. The states represent the state-machine as a whole.
-     * @enum {number}
-     */
-    const STATE = {
-        INITIAL: 1,
-        FIRSTOPENINGBINDING: 2,
-        FIRSTCHARACTERBINDING: 3,
-        BINDING: 4,
-        FIRSTCOLON: 5,
-        COLONNOTIFYEVENT: 6,
-        COLONNOTIFYEVENTFIRSTCLOSINGBINDING: 7,
-        FIRSTCLOSINGBINDING: 8,
-        STRING: 9,
-        METHOD: 10,
-        STRINGARG: 11,
-        NUMBERARG: 12,
-        VARIABLEARG: 13,
-        METHODCLOSED: 14,
-        METHODCLOSEDBINDING: 15
-    }
+  /**
+   * The open and corresponding closing brackets for surrounding bindings.
+   * @enum {string}
+   */
+  const BINDINGS = {
+    '{': '}',
+    '[': ']'
+  };
 
-    function pushLiteral(text, i, parts, startChar) {
-        const literal = text.substring(startChar || 0, i);
-        if (literal) {
-            parts.push({
-                literal
-            });
-        }
-    }
+  /**
+   * All states that the parser can be in. The states represent the state-machine as a whole.
+   * @enum {number}
+   */
+  const STATE = {
+    INITIAL: 1,
+    FIRSTOPENINGBINDING: 2,
+    FIRSTCHARACTERBINDING: 3,
+    BINDING: 4,
+    FIRSTCOLON: 5,
+    COLONNOTIFYEVENT: 6,
+    COLONNOTIFYEVENTFIRSTCLOSINGBINDING: 7,
+    FIRSTCLOSINGBINDING: 8,
+    STRING: 9,
+    METHOD: 10,
+    STRINGARG: 11,
+    NUMBERARG: 12,
+    VARIABLEARG: 13,
+    METHODCLOSED: 14,
+    METHODCLOSEDBINDING: 15
+  }
 
-    function storeMethod(bindingData, templateInfo) {
-        const methodName = bindingData.signature.methodName;
-        const dynamicFns = templateInfo.dynamicFns;
-        if (dynamicFns && dynamicFns[methodName] || bindingData.signature.static) {
-            bindingData.dependencies.push(methodName);
-            bindingData.signature.dynamicFn = true;
-        }
+  function pushLiteral(text, i, parts, startChar) {
+    const literal = text.substring(startChar || 0, i);
+    if (literal) {
+      parts.push({
+        literal
+      });
     }
+  }
 
-    function storeVariableBinding(parts, bindingData, prop, i) {
-        bindingData.source = prop;
-        bindingData.dependencies.push(prop);
-        bindingData.startChar = i + 1;
-        parts.push(bindingData);
+  function storeMethod(bindingData, templateInfo) {
+    const methodName = bindingData.signature.methodName;
+    const dynamicFns = templateInfo.dynamicFns;
+    if (dynamicFns && dynamicFns[methodName] || bindingData.signature.static) {
+      bindingData.dependencies.push(methodName);
+      bindingData.signature.dynamicFn = true;
     }
+  }
 
-    function storeMethodVariable(bindingData, text, i) {
-        const name = text.substring(bindingData.startChar, i).trim();
-        if (name) {
-            if (name === 'true' || name === 'false') {
-                bindingData.signature.args.push({
-                    name,
-                    value: name == 'true',
-                    literal: true
-                });
-            } else {
-                const arg = {
-                    name
-                }
-                arg.structured = Polymer.Path.isPath(name);
-                if (arg.structured) {
-                    arg.wildcard = (name.slice(-2) == '.*');
-                    if (arg.wildcard) {
-                        arg.name = name.slice(0, -2);
-                    }
-                }
-                bindingData.signature.args.push(arg);
-                bindingData.dependencies.push(name)
-                bindingData.signature.static = false;
-            }
-        }
-    }
+  function storeVariableBinding(parts, bindingData, prop, i) {
+    bindingData.source = prop;
+    bindingData.dependencies.push(prop);
+    bindingData.startChar = i + 1;
+    parts.push(bindingData);
+  }
 
-    function storeMethodNumber(bindingData, text, i) {
-        const value = text.substring(bindingData.startChar, i).trim();
+  function storeMethodVariable(bindingData, text, i) {
+    const name = text.substring(bindingData.startChar, i).trim();
+    if (name) {
+      if (name === 'true' || name === 'false') {
         bindingData.signature.args.push({
-            name: value,
-            value: Number(value),
-            literal: true
+          name,
+          value: name == 'true',
+          literal: true
         });
+      } else {
+        const arg = {
+          name
+        }
+        arg.structured = Polymer.Path.isPath(name);
+        if (arg.structured) {
+          arg.wildcard = (name.slice(-2) == '.*');
+          if (arg.wildcard) {
+            arg.name = name.slice(0, -2);
+          }
+        }
+        bindingData.signature.args.push(arg);
+        bindingData.dependencies.push(name)
+        bindingData.signature.static = false;
+      }
     }
+  }
+
+  function storeMethodNumber(bindingData, text, i) {
+    const value = text.substring(bindingData.startChar, i).trim();
+    bindingData.signature.args.push({
+      name: value,
+      value: Number(value),
+      literal: true
+    });
+  }
 
   /**
-   * Module that parses binding expressions and generates corresponding metadata.
+   * Mixin that parses binding expressions and generates corresponding metadata.
+   * The implementation is different than in `property-effects`, as it uses a
+   * state machine instead of a regex.
    *
    * @namespace
    * @memberof Polymer
-   * @summary Module that parses binding expressions and generates corresponding metadata.
+   * @summary Mixin that parses binding expressions and generates corresponding metadata.
    */
-  const BindingParser = {
+  const BindingParser = Polymer.dedupingMixin((base) => {
 
-    /**
-     * @param {string} text Text to parse from attribute or textContent
-     * @param {Object} templateInfo Current template metadata
-     * @return {Array<!BindingPart>} Array of binding part metadata
-     */
-    parse(text, templateInfo) {
+    return class extends base {
+
+      /**
+       * Called to parse text in a template (either attribute values or
+       * textContent) into binding metadata.
+       *
+       * Any overrides of this method should return an array of binding part
+       * metadata  representing one or more bindings found in the provided text
+       * and any "literal" text in between.  Any non-literal parts will be passed
+       * to `_evaluateBinding` when any dependencies change.  The only required
+       * fields of each "part" in the returned array are as follows:
+       *
+       * - `dependencies` - Array containing trigger metadata for each property
+       *   that should trigger the binding to update
+       * - `literal` - String containing text if the part represents a literal;
+       *   in this case no `dependencies` are needed
+       *
+       * Additional metadata for use by `_evaluateBinding` may be provided in
+       * each part object as needed.
+       *
+       * The default implementation handles the following types of bindings
+       * (one or more may be intermixed with literal strings):
+       * - Property binding: `[[prop]]`
+       * - Path binding: `[[object.prop]]`
+       * - Negated property or path bindings: `[[!prop]]` or `[[!object.prop]]`
+       * - Two-way property or path bindings (supports negation):
+       *   `{{prop}}`, `{{object.prop}}`, `{{!prop}}` or `{{!object.prop}}`
+       * - Inline computed method (supports negation):
+       *   `[[compute(a, 'literal', b)]]`, `[[!compute(a, 'literal', b)]]`
+       *
+       * @param {string} text Text to parse from attribute or textContent
+       * @param {Object} templateInfo Current template metadata
+       * @return {Array<!BindingPart>} Array of binding part metadata
+       * @protected
+       */
+      static _parseBindings(text, templateInfo) {
         const parts = [];
         let bindingData = {};
         let escaped = false;
@@ -130,238 +164,240 @@
         let i,l;
 
         for (i=0,l=text.length; i<l; i++) {
-            const char = text.charAt(i);
-            switch (state) {
-                case STATE.INITIAL: {
-                    if ((char === '{' || char === '[')) {
-                        bindingData = {
-                            mode: char,
-                            dependencies: [],
-                            startChar: bindingData.startChar
-                        };
-                        state = STATE.FIRSTOPENINGBINDING;
-                    }
-                    break;
-                }
-                case STATE.FIRSTOPENINGBINDING: {
-                    if (char === bindingData.mode) {
-                        pushLiteral(text, i - 1, parts, bindingData.startChar);
-                        bindingData.startChar = i + 1;
-                        state = STATE.FIRSTCHARACTERBINDING;
-                    } else {
-                        bindingData = {};
-                        state = STATE.INITIAL;
-                    }
-                    break;
+          const char = text.charAt(i);
+          switch (state) {
+            case STATE.INITIAL: {
+              if ((char === '{' || char === '[')) {
+                bindingData = {
+                  mode: char,
+                  dependencies: [],
+                  startChar: bindingData.startChar
+                };
+                state = STATE.FIRSTOPENINGBINDING;
+              }
+              break;
+            }
+            case STATE.FIRSTOPENINGBINDING: {
+              if (char === bindingData.mode) {
+                pushLiteral(text, i - 1, parts, bindingData.startChar);
+                bindingData.startChar = i + 1;
+                state = STATE.FIRSTCHARACTERBINDING;
+              } else {
+                bindingData = {};
+                state = STATE.INITIAL;
+              }
+              break;
+            }
+            case STATE.FIRSTCHARACTERBINDING: {
+              if (char !== ' ' && char !== '\t' && char !== '\n') {
+                if (char === '!') {
+                  bindingData.negate = true;
+                  bindingData.startChar = i + 1;
                 }
-                case STATE.FIRSTCHARACTERBINDING: {
-                    if (char !== ' ' && char !== '\t' && char !== '\n') {
-                        if (char === '!') {
-                            bindingData.negate = true;
-                            bindingData.startChar = i + 1;
-                        }
-                        state = STATE.BINDING;
-                    }
-                    break;
+                state = STATE.BINDING;
+              }
+              break;
+            }
+            case STATE.BINDING: {
+              switch (char) {
+                case BINDINGS[bindingData.mode]: {
+                  state = STATE.FIRSTCLOSINGBINDING;
+                  break;
                 }
-                case STATE.BINDING: {
-                    switch (char) {
-                        case BINDINGS[bindingData.mode]: {
-                            state = STATE.FIRSTCLOSINGBINDING;
-                            break;
-                        }
-                        case '\'':
-                        case '"': {
-                            quote = char;
-                            state = STATE.STRING;
-                            break;
-                        }
-                        case '(': {
-                            bindingData.signature = {
-                                methodName: text.substring(bindingData.startChar, i).trim(),
-                                args: [],
-                                static: true
-                            };
-                            bindingData.startChar = i + 1;
-                            state = STATE.METHOD;
-                            break;
-                        }
-                        case ':': {
-                            state = STATE.FIRSTCOLON;
-                        }
-                    }
-                    break;
+                case '\'':
+                case '"': {
+                  quote = char;
+                  state = STATE.STRING;
+                  break;
                 }
-                case STATE.FIRSTCOLON: {
-                    if (char === ':') {
-                        bindingData.customEvent = true;
-                        bindingData.startCharAfterColon = i + 1;
-                        state = STATE.COLONNOTIFYEVENT;
-                    } else {
-                        state = STATE.BINDING;
-                    }
-                    break;
+                case '(': {
+                  bindingData.signature = {
+                    methodName: text.substring(bindingData.startChar, i).trim(),
+                    args: [],
+                    static: true
+                  };
+                  bindingData.startChar = i + 1;
+                  state = STATE.METHOD;
+                  break;
                 }
-                case STATE.COLONNOTIFYEVENT: {
-                    if (char === BINDINGS[bindingData.mode]) {
-                        state = STATE.COLONNOTIFYEVENTFIRSTCLOSINGBINDING;
-                    }
-                    break;
+                case ':': {
+                  state = STATE.FIRSTCOLON;
                 }
-                case STATE.COLONNOTIFYEVENTFIRSTCLOSINGBINDING: {
-                    if (char === BINDINGS[bindingData.mode]) {
-                        bindingData.event = text.substring(bindingData.startCharAfterColon, i - 1).trim();
-                        const prop = text.substring(bindingData.startChar, bindingData.startCharAfterColon - 2).trim();
-                        storeVariableBinding(parts, bindingData, prop, i);
-                        state = STATE.INITIAL;
-                    } else {
-                        state = STATE.BINDING;
-                    }
-                    break;
+              }
+              break;
+            }
+            case STATE.FIRSTCOLON: {
+              if (char === ':') {
+                bindingData.customEvent = true;
+                bindingData.startCharAfterColon = i + 1;
+                state = STATE.COLONNOTIFYEVENT;
+              } else {
+                state = STATE.BINDING;
+              }
+              break;
+            }
+            case STATE.COLONNOTIFYEVENT: {
+              if (char === BINDINGS[bindingData.mode]) {
+                state = STATE.COLONNOTIFYEVENTFIRSTCLOSINGBINDING;
+              }
+              break;
+            }
+            case STATE.COLONNOTIFYEVENTFIRSTCLOSINGBINDING: {
+              if (char === BINDINGS[bindingData.mode]) {
+                bindingData.event = text.substring(bindingData.startCharAfterColon, i - 1).trim();
+                const prop = text.substring(bindingData.startChar, bindingData.startCharAfterColon - 2).trim();
+                storeVariableBinding(parts, bindingData, prop, i);
+                state = STATE.INITIAL;
+              } else {
+                state = STATE.BINDING;
+              }
+              break;
+            }
+            case STATE.FIRSTCLOSINGBINDING: {
+              if (char === BINDINGS[bindingData.mode]) {
+                const prop = text.substring(bindingData.startChar, i - 1).trim();
+                storeVariableBinding(parts, bindingData, prop, i);
+                state = STATE.INITIAL;
+              } else {
+                state = STATE.BINDING;
+              }
+              break;
+            }
+            case STATE.STRING: {
+              if (char === '\\') {
+                escaped = true;
+              } else if (char === quote && !escaped) {
+                state = STATE.BINDING;
+              } else {
+                escaped = false;
+              }
+              break;
+            }
+            case STATE.METHOD: {
+              switch (char) {
+                case ')': {
+                  storeMethodVariable(bindingData, text, i);
+                  storeMethod(bindingData, templateInfo);
+                  bindingData.startChar = i + 1;
+                  storeMethod(bindingData, templateInfo);
+                  state = STATE.METHODCLOSED;
+                  break;
                 }
-                case STATE.FIRSTCLOSINGBINDING: {
-                    if (char === BINDINGS[bindingData.mode]) {
-                        const prop = text.substring(bindingData.startChar, i - 1).trim();
-                        storeVariableBinding(parts, bindingData, prop, i);
-                        state = STATE.INITIAL;
-                    } else {
-                        state = STATE.BINDING;
-                    }
-                    break;
+                case ',': {
+                  storeMethodVariable(bindingData, text, i)
+                  bindingData.startChar = i + 1;
+                  break;
                 }
-                case STATE.STRING: {
-                    if (char === '\\') {
-                        escaped = true;
-                    } else if (char === quote && !escaped) {
-                        state = STATE.BINDING;
-                    } else {
-                        escaped = false;
-                    }
-                    break;
+                case '\'':
+                case '"': {
+                  quote = char;
+                  state = STATE.STRINGARG;
+                  break;
                 }
-                case STATE.METHOD: {
-                    switch (char) {
-                        case ')': {
-                            storeMethodVariable(bindingData, text, i);
-                            storeMethod(bindingData, templateInfo);
-                            bindingData.startChar = i + 1;
-                            storeMethod(bindingData, templateInfo);
-                            state = STATE.METHODCLOSED;
-                            break;
-                        }
-                        case ',': {
-                            storeMethodVariable(bindingData, text, i)
-                            bindingData.startChar = i + 1;
-                            break;
-                        }
-                        case '\'':
-                        case '"': {
-                            quote = char;
-                            state = STATE.STRINGARG;
-                            break;
-                        }
-                        default: {
-                            if (char >= '0' && char <= '9' || char === '-') {
-                                state = STATE.NUMBERARG;
-                            } else if (char != ' ' && char != '\n') {
-                                state = STATE.VARIABLEARG;
-                            }
-                        }
-                    }
-                    break;
+                default: {
+                  if (char >= '0' && char <= '9' || char === '-') {
+                    state = STATE.NUMBERARG;
+                  } else if (char != ' ' && char != '\n') {
+                    state = STATE.VARIABLEARG;
+                  }
                 }
-                case STATE.STRINGARG: {
-                    if (char === '\\') {
-                        escaped = true;
-                    } else if (char === quote && !escaped) {
-                        const value = text.substring(bindingData.startChar, i)
-                                .replace(/^\s+/, '')
-                                .substring(1)
-                                // replace comma entity with comma
-                                .replace(/&comma;/g, ',')
-                                // repair extra escape sequences; note only commas strictly need
-                                // escaping, but we allow any other char to be escaped since its
-                                // likely users will do this
-                                .replace(/\\(.)/g, '\$1');
-                        bindingData.signature.args.push({
-                            value,
-                            name: value,
-                            literal: true
-                        });
-                        bindingData.startChar = i + 1;
-                        state = STATE.METHOD;
-                    } else {
-                        escaped = false;
-                    }
-                    break;
+              }
+              break;
+            }
+            case STATE.STRINGARG: {
+              if (char === '\\') {
+                escaped = true;
+              } else if (char === quote && !escaped) {
+                const value = text.substring(bindingData.startChar, i)
+                    .replace(/^\s+/, '')
+                    .substring(1)
+                    // replace comma entity with comma
+                    .replace(/&comma;/g, ',')
+                    // repair extra escape sequences; note only commas strictly need
+                    // escaping, but we allow any other char to be escaped since its
+                    // likely users will do this
+                    .replace(/\\(.)/g, '\$1');
+                bindingData.signature.args.push({
+                  value,
+                  name: value,
+                  literal: true
+                });
+                bindingData.startChar = i + 1;
+                state = STATE.METHOD;
+              } else {
+                escaped = false;
+              }
+              break;
+            }
+            case STATE.NUMBERARG: {
+              switch (char) {
+                case ',': {
+                  storeMethodNumber(bindingData, text, i);
+                  bindingData.startChar = i + 1;
+                  state = STATE.METHOD;
+                  break;
                 }
-                case STATE.NUMBERARG: {
-                    switch (char) {
-                        case ',': {
-                            storeMethodNumber(bindingData, text, i);
-                            bindingData.startChar = i + 1;
-                            state = STATE.METHOD;
-                            break;
-                        }
-                        case ')': {
-                            storeMethodNumber(bindingData, text, i);
-                            storeMethod(bindingData, templateInfo);
-                            state = STATE.METHODCLOSED;
-                            break;
-                        }
-                        default: {
-                            if (char < '0' || char > '9') {
-                                state = STATE.VARIABLEARG;
-                            }
-                        }
-                    }
-                    break;
+                case ')': {
+                  storeMethodNumber(bindingData, text, i);
+                  storeMethod(bindingData, templateInfo);
+                  state = STATE.METHODCLOSED;
+                  break;
                 }
-                case STATE.VARIABLEARG: {
-                    switch (char) {
-                        case ',': {
-                            storeMethodVariable(bindingData, text, i);
-                            bindingData.startChar = i + 1;
-                            state = STATE.METHOD;
-                            break;
-                        }
-                        case ')': {
-                            storeMethodVariable(bindingData, text, i);
-                            storeMethod(bindingData, templateInfo);
-                            state = STATE.METHODCLOSED;
-                            break;
-                        }
-                    }
-                    break;
+                default: {
+                  if (char < '0' || char > '9') {
+                    state = STATE.VARIABLEARG;
+                  }
                 }
-                case STATE.METHODCLOSED: {
-                    if (char === BINDINGS[bindingData.mode]) {
-                        state = STATE.METHODCLOSEDBINDING;
-                    } else if (char !== ' ' && char !== '\t' && char !== '\n') {
-                        console.warn(`Expected two closing "${BINDINGS[bindingData.mode]}" for binding "${text}"`);
-                    }
-                    break;
+              }
+              break;
+            }
+            case STATE.VARIABLEARG: {
+              switch (char) {
+                case ',': {
+                  storeMethodVariable(bindingData, text, i);
+                  bindingData.startChar = i + 1;
+                  state = STATE.METHOD;
+                  break;
                 }
-                case STATE.METHODCLOSEDBINDING: {
-                    if (char === BINDINGS[bindingData.mode]) {
-                        bindingData.startChar = i + 1;
-                        parts.push(bindingData);
-                        state = STATE.INITIAL;
-                    } else if (char !== ' ' && char !== '\t' && char !== '\n') {
-                        console.warn(`Expected one closing "${BINDINGS[bindingData.mode]}" for binding "${text}"`);
-                    }
-                    break;
+                case ')': {
+                  storeMethodVariable(bindingData, text, i);
+                  storeMethod(bindingData, templateInfo);
+                  state = STATE.METHODCLOSED;
+                  break;
                 }
+              }
+              break;
+            }
+            case STATE.METHODCLOSED: {
+              if (char === BINDINGS[bindingData.mode]) {
+                state = STATE.METHODCLOSEDBINDING;
+              } else if (char !== ' ' && char !== '\t' && char !== '\n') {
+                console.warn(`Expected two closing "${BINDINGS[bindingData.mode]}" for binding "${text}"`);
+              }
+              break;
             }
+            case STATE.METHODCLOSEDBINDING: {
+              if (char === BINDINGS[bindingData.mode]) {
+                bindingData.startChar = i + 1;
+                parts.push(bindingData);
+                state = STATE.INITIAL;
+              } else if (char !== ' ' && char !== '\t' && char !== '\n') {
+                console.warn(`Expected one closing "${BINDINGS[bindingData.mode]}" for binding "${text}"`);
+              }
+              break;
+            }
+          }
         }
 
         if (parts.length) {
-            pushLiteral(text, i, parts, parts[parts.length - 1].startChar);
+          pushLiteral(text, i, parts, parts[parts.length - 1].startChar);
+          return parts;
         }
 
-        return parts;
+        return null;
+      }
     }
-  }
+  });
 
   Polymer.BindingParser = BindingParser;
 })();
diff --git a/test/unit/property-effects-elements.html b/test/unit/property-effects-elements.html
index e06574cebe..8defcc9519 100644
--- a/test/unit/property-effects-elements.html
+++ b/test/unit/property-effects-elements.html
@@ -7,6 +7,7 @@
 Code distributed by Google as part of the polymer project is also
 subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
 -->
+<link rel="import" href="../../lib/utils/binding-parser.html">
 <dom-module id="x-basic">
   <template>
     <div id="boundChild"
@@ -329,6 +330,13 @@
           {value: this.customNotifyingValue});
       }
     });
+
+    HTMLImports.whenReady(() => {
+      class XBasicWithBindingParser extends Polymer.BindingParser(customElements.get('x-basic')) {
+        static get is() { return 'x-basic-binding-parser'; }
+      }
+      customElements.define(XBasicWithBindingParser.is, XBasicWithBindingParser);
+    });
   </script>
 </dom-module>
 
diff --git a/test/unit/property-effects.html b/test/unit/property-effects.html
index bef3730a68..40f93aa5c0 100644
--- a/test/unit/property-effects.html
+++ b/test/unit/property-effects.html
@@ -358,30 +358,6 @@
     assert.equal(el.$.boundWithDash.textContent, 'yes');
   });
 
-  test('binding with slash', function() {
-    el.objectWithSlash = {
-      'binding/with/slash': 'yes'
-    };
-    assert.equal(el.$.boundWithSlash.textContent, 'yes');
-  });
-
-  test('json should not be a binding', function() {
-    assert.equal(el.$.jsonContent.textContent, '[["Jan", 31],["Feb", 28],["Mar", 31]]');
-  });
-
-  test('binding with non-English unicode', function() {
-    el.objectWithNonEnglishUnicode = {
-      商品名: 'yes'
-    };
-    assert.equal(el.$.nonEnglishUnicode.textContent, 'yes');
-  });
-
-  test('binding with booleans', function() {
-    el.otherValue = 10;
-    assert.equal(el.$.booleanTrue.textContent, 'foo(field, true): 10');
-    assert.equal(el.$.booleanFalse.textContent, 'foo(field, false): 20');
-  });
-
   test('class attribute without template scope not erased', function() {
     var el = document.querySelector('.class1');
     assert.notEqual(el, null, 'class without template scope is undefined');
@@ -443,6 +419,48 @@
       assert.equal(el.__observerCalled, 1);
     });
   });
+
+  suite('can work with binding parser', function() {
+    setup(function() {
+      document.body.removeChild(el);
+      el = document.createElement('x-basic-binding-parser');
+      document.body.appendChild(el);
+    });
+
+    test('binding with slash', function() {
+      el.objectWithSlash = {
+        'binding/with/slash': 'yes'
+      };
+      assert.equal(el.$.boundWithSlash.textContent, 'yes');
+    });
+
+    test('json should not be a binding', function() {
+      assert.equal(el.$.jsonContent.textContent, '[["Jan", 31],["Feb", 28],["Mar", 31]]');
+    });
+
+    test('binding with non-English unicode', function() {
+      el.objectWithNonEnglishUnicode = {
+        商品名: 'yes'
+      };
+      assert.equal(el.$.nonEnglishUnicode.textContent, 'yes');
+    });
+
+    test('binding with booleans', function() {
+      el.otherValue = 10;
+      assert.equal(el.$.booleanTrue.textContent, 'foo(field, true): 10');
+      assert.equal(el.$.booleanFalse.textContent, 'foo(field, false): 20');
+    });
+
+    suite('equivalent behavior as regex', function() {
+      // Loop over the suite "single-element binding effects" (parent of the parent of this suite)
+      // And make sure that the tests there also pass on the binding-parser
+      //
+      // t.title is the name of the test and t.fn contains the test body
+      this.parent.parent.tests.forEach(t => {
+        test(t.title, t.fn);
+      });;
+    });
+  });
 });
 
 suite('computed bindings with dynamic functions', function() {

From d8cf449ee52d11fcb04d970611a42c52c20715dc Mon Sep 17 00:00:00 2001
From: Tim van der Lippe <tvanderlippe@google.com>
Date: Mon, 18 Sep 2017 19:49:29 -0700
Subject: [PATCH 12/20] Fix linter errors

---
 lib/utils/binding-parser.html   | 10 +++++-----
 test/unit/property-effects.html |  2 +-
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/lib/utils/binding-parser.html b/lib/utils/binding-parser.html
index 0e614d6a2b..6bff5f35dd 100644
--- a/lib/utils/binding-parser.html
+++ b/lib/utils/binding-parser.html
@@ -44,7 +44,7 @@
     VARIABLEARG: 13,
     METHODCLOSED: 14,
     METHODCLOSEDBINDING: 15
-  }
+  };
 
   function pushLiteral(text, i, parts, startChar) {
     const literal = text.substring(startChar || 0, i);
@@ -83,7 +83,7 @@
       } else {
         const arg = {
           name
-        }
+        };
         arg.structured = Polymer.Path.isPath(name);
         if (arg.structured) {
           arg.wildcard = (name.slice(-2) == '.*');
@@ -92,7 +92,7 @@
           }
         }
         bindingData.signature.args.push(arg);
-        bindingData.dependencies.push(name)
+        bindingData.dependencies.push(name);
         bindingData.signature.static = false;
       }
     }
@@ -284,7 +284,7 @@
                   break;
                 }
                 case ',': {
-                  storeMethodVariable(bindingData, text, i)
+                  storeMethodVariable(bindingData, text, i);
                   bindingData.startChar = i + 1;
                   break;
                 }
@@ -396,7 +396,7 @@
 
         return null;
       }
-    }
+    };
   });
 
   Polymer.BindingParser = BindingParser;
diff --git a/test/unit/property-effects.html b/test/unit/property-effects.html
index 40f93aa5c0..2a567e335c 100644
--- a/test/unit/property-effects.html
+++ b/test/unit/property-effects.html
@@ -458,7 +458,7 @@
       // t.title is the name of the test and t.fn contains the test body
       this.parent.parent.tests.forEach(t => {
         test(t.title, t.fn);
-      });;
+      });
     });
   });
 });

From 19d4b8cb9c169567c9b67c05ddc4bf3918aa5e3c Mon Sep 17 00:00:00 2001
From: Tim van der Lippe <tvanderlippe@google.com>
Date: Fri, 22 Sep 2017 16:03:41 -0700
Subject: [PATCH 13/20] Rename to StrictBindingParser

---
 .../{binding-parser.html => strict-binding-parser.html}   | 7 ++++---
 test/unit/property-effects-elements.html                  | 8 ++++----
 test/unit/property-effects.html                           | 4 ++--
 3 files changed, 10 insertions(+), 9 deletions(-)
 rename lib/utils/{binding-parser.html => strict-binding-parser.html} (98%)

diff --git a/lib/utils/binding-parser.html b/lib/utils/strict-binding-parser.html
similarity index 98%
rename from lib/utils/binding-parser.html
rename to lib/utils/strict-binding-parser.html
index 6bff5f35dd..5b94efe5b9 100644
--- a/lib/utils/binding-parser.html
+++ b/lib/utils/strict-binding-parser.html
@@ -110,13 +110,14 @@
   /**
    * Mixin that parses binding expressions and generates corresponding metadata.
    * The implementation is different than in `property-effects`, as it uses a
-   * state machine instead of a regex.
+   * state machine instead of a regex. As such, this implementation is able to
+   * handle more cases, with the potential performance hit.
    *
    * @namespace
    * @memberof Polymer
    * @summary Mixin that parses binding expressions and generates corresponding metadata.
    */
-  const BindingParser = Polymer.dedupingMixin((base) => {
+  const StrictBindingParser = Polymer.dedupingMixin((base) => {
 
     return class extends base {
 
@@ -399,6 +400,6 @@
     };
   });
 
-  Polymer.BindingParser = BindingParser;
+  Polymer.StrictBindingParser = StrictBindingParser;
 })();
 </script>
diff --git a/test/unit/property-effects-elements.html b/test/unit/property-effects-elements.html
index 8defcc9519..622d128f55 100644
--- a/test/unit/property-effects-elements.html
+++ b/test/unit/property-effects-elements.html
@@ -7,7 +7,7 @@
 Code distributed by Google as part of the polymer project is also
 subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
 -->
-<link rel="import" href="../../lib/utils/binding-parser.html">
+<link rel="import" href="../../lib/utils/strict-binding-parser.html">
 <dom-module id="x-basic">
   <template>
     <div id="boundChild"
@@ -332,10 +332,10 @@
     });
 
     HTMLImports.whenReady(() => {
-      class XBasicWithBindingParser extends Polymer.BindingParser(customElements.get('x-basic')) {
-        static get is() { return 'x-basic-binding-parser'; }
+      class XBasicWithStrictBindingParser extends Polymer.StrictBindingParser(customElements.get('x-basic')) {
+        static get is() { return 'x-basic-strict-binding-parser'; }
       }
-      customElements.define(XBasicWithBindingParser.is, XBasicWithBindingParser);
+      customElements.define(XBasicWithStrictBindingParser.is, XBasicWithStrictBindingParser);
     });
   </script>
 </dom-module>
diff --git a/test/unit/property-effects.html b/test/unit/property-effects.html
index 2a567e335c..f0c78ac772 100644
--- a/test/unit/property-effects.html
+++ b/test/unit/property-effects.html
@@ -420,10 +420,10 @@
     });
   });
 
-  suite('can work with binding parser', function() {
+  suite('can work with strict binding parser', function() {
     setup(function() {
       document.body.removeChild(el);
-      el = document.createElement('x-basic-binding-parser');
+      el = document.createElement('x-basic-strict-binding-parser');
       document.body.appendChild(el);
     });
 

From a4d4eb9a8fe504265ace8efdca4b4dc130b83a75 Mon Sep 17 00:00:00 2001
From: Tim van der Lippe <tvanderlippe@google.com>
Date: Tue, 26 Sep 2017 21:00:07 -0700
Subject: [PATCH 14/20] Move strict-binding-parser to lib/mixins

---
 lib/{utils => mixins}/strict-binding-parser.html | 0
 test/unit/property-effects-elements.html         | 2 +-
 2 files changed, 1 insertion(+), 1 deletion(-)
 rename lib/{utils => mixins}/strict-binding-parser.html (100%)

diff --git a/lib/utils/strict-binding-parser.html b/lib/mixins/strict-binding-parser.html
similarity index 100%
rename from lib/utils/strict-binding-parser.html
rename to lib/mixins/strict-binding-parser.html
diff --git a/test/unit/property-effects-elements.html b/test/unit/property-effects-elements.html
index 622d128f55..969fe19ce9 100644
--- a/test/unit/property-effects-elements.html
+++ b/test/unit/property-effects-elements.html
@@ -7,7 +7,7 @@
 Code distributed by Google as part of the polymer project is also
 subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
 -->
-<link rel="import" href="../../lib/utils/strict-binding-parser.html">
+<link rel="import" href="../../lib/mixins/strict-binding-parser.html">
 <dom-module id="x-basic">
   <template>
     <div id="boundChild"

From 0f0ccdade8922b254ce0a73d07bc793a5a0d591b Mon Sep 17 00:00:00 2001
From: Tim van der Lippe <tvanderlippe@gmail.com>
Date: Thu, 5 Oct 2017 04:25:14 -0700
Subject: [PATCH 15/20] Only store method once for dynamic functions

---
 lib/mixins/property-effects.html         |  2 +-
 lib/mixins/strict-binding-parser.html    |  1 -
 test/unit/property-effects-elements.html | 10 ++++++++--
 test/unit/property-effects.html          |  7 +++++++
 4 files changed, 16 insertions(+), 4 deletions(-)

diff --git a/lib/mixins/property-effects.html b/lib/mixins/property-effects.html
index b33b386b0b..827c6de1a9 100644
--- a/lib/mixins/property-effects.html
+++ b/lib/mixins/property-effects.html
@@ -2797,4 +2797,4 @@
   };
 
 })();
-</script>
\ No newline at end of file
+</script>
diff --git a/lib/mixins/strict-binding-parser.html b/lib/mixins/strict-binding-parser.html
index 5b94efe5b9..4e0c24486f 100644
--- a/lib/mixins/strict-binding-parser.html
+++ b/lib/mixins/strict-binding-parser.html
@@ -280,7 +280,6 @@
                   storeMethodVariable(bindingData, text, i);
                   storeMethod(bindingData, templateInfo);
                   bindingData.startChar = i + 1;
-                  storeMethod(bindingData, templateInfo);
                   state = STATE.METHODCLOSED;
                   break;
                 }
diff --git a/test/unit/property-effects-elements.html b/test/unit/property-effects-elements.html
index 969fe19ce9..2e3efbc0b7 100644
--- a/test/unit/property-effects-elements.html
+++ b/test/unit/property-effects-elements.html
@@ -46,6 +46,7 @@
       compoundAttr2$="literal1 {{cpnd1}} literal2 {{cpnd2}}{{cpnd3.prop}} literal3 {{computeCompound(cpnd4, cpnd5, 'literalComputed')}} literal4"
       compoundAttr3$="[yes/no]: {{cpnd1}}, {{computeCompound('world', 'username ', 'Hello {0} ')}}"
       computed-from-behavior="{{computeFromBehavior(value)}}"
+      computed-dynamic-fn="{{dynamicFn('hello', 'username')}}"
       >
       Test
       <!-- Malformed bindings to be ignored -->
@@ -82,7 +83,7 @@
           content: '[[binding]]'
         }
       </style>
-      <span id="boundWithSlash">[[objectWithSlash.binding/with/slash]]</span> 
+      <span id="boundWithSlash">[[objectWithSlash.binding/with/slash]]</span>
       <span id="jsonContent">[["Jan", 31],["Feb", 28],["Mar", 31]]</span>
       <span id="nonEnglishUnicode">{{objectWithNonEnglishUnicode.商品名}}</span>
       <span id="booleanTrue">foo(field, true): {{computeWithBoolean(otherValue, true)}}</span>
@@ -181,6 +182,9 @@
         },
         title: {
           observer: 'titleChanged'
+        },
+        dynamicFn: {
+          type: Function
         }
       },
       observers: [
@@ -202,6 +206,7 @@
           notifierWithoutComputingChanged: 0
         };
         this.titleChanged = sinon.spy();
+        this._dynamicFnCalled = false;
       },
       ready: function() {
         this.isReady = true;
@@ -328,7 +333,8 @@
         this.customNotifyingValue = 'changed!';
         this.dispatchEvent(new CustomEvent('custom-notifying-value-changed'),
           {value: this.customNotifyingValue});
-      }
+      },
+      dynamicFn: function() {}
     });
 
     HTMLImports.whenReady(() => {
diff --git a/test/unit/property-effects.html b/test/unit/property-effects.html
index f0c78ac772..fbb8ac7fbe 100644
--- a/test/unit/property-effects.html
+++ b/test/unit/property-effects.html
@@ -409,6 +409,13 @@
     }
   });
 
+  test('only calls dynamic functions once', function() {
+    el.dynamicFn = function() {
+      assert.isFalse(this._dynamicFnCalled);
+      this._dynamicFnCalled = true;
+    };
+  });
+
   suite('observer inheritance', function() {
     setup(function() {
       el = document.createElement('sub-observer-element');

From ab93ab089226f34a3dbce7ed5742f1e08e3fe117 Mon Sep 17 00:00:00 2001
From: Tim van der Lippe <tvanderlippe@gmail.com>
Date: Sat, 2 Dec 2017 15:14:21 +0100
Subject: [PATCH 16/20] Correct import paths

---
 lib/mixins/strict-binding-parser.html | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/lib/mixins/strict-binding-parser.html b/lib/mixins/strict-binding-parser.html
index 4e0c24486f..2706b473b7 100644
--- a/lib/mixins/strict-binding-parser.html
+++ b/lib/mixins/strict-binding-parser.html
@@ -7,9 +7,9 @@
 Code distributed by Google as part of the polymer project is also
 subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
 -->
-<link rel="import" href="boot.html">
-<link rel="import" href="path.html">
-<link rel="import" href="mixin.html">
+<link rel="import" href="../utils/boot.html">
+<link rel="import" href="../utils/path.html">
+<link rel="import" href="../utils/mixin.html">
 
 <script>
 (function() {

From f53e9e8a7316d0b8acf18ec132658f618f929b85 Mon Sep 17 00:00:00 2001
From: Tim van der Lippe <tvanderlippe@gmail.com>
Date: Sat, 2 Dec 2017 17:10:14 +0100
Subject: [PATCH 17/20] Update perf test to use strict-binding-parser

---
 test/perf/binding-expressions.html | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/test/perf/binding-expressions.html b/test/perf/binding-expressions.html
index 9b70f0b1ab..177a41f249 100644
--- a/test/perf/binding-expressions.html
+++ b/test/perf/binding-expressions.html
@@ -6,6 +6,7 @@
   <script src="../../bower_components/perf-tester/perf.js"></script>
   <script src="../../bower_components/webcomponentsjs/webcomponents-lite.js"></script>
   <link rel="import" href="../../polymer.html">
+  <link rel="import" href="../../lib/mixins/strict-binding-parser.html">
 </head>
 
 <body>
@@ -64,14 +65,14 @@
   }
   console.perf();
   for (var i=0; i<COUNT; i++) {
-    const klass = Polymer({
-      is: 'test-el-' + i,
-      _template: templates[i]
-    });
+    const klass = class Foo extends Polymer.StrictBindingParser(Polymer.Element) {
+      static get _template() { return templates[i]; }
+    };
+    customElements.define('foo-' + i, klass);
     new klass();
   }
   console.perfEnd();
   </script>
 
 </body>
-</html>
\ No newline at end of file
+</html>

From 211c223fb9ba2993f9a5751f28fae1dfea44e8a8 Mon Sep 17 00:00:00 2001
From: Tim van der Lippe <tvanderlippe@gmail.com>
Date: Sun, 25 Feb 2018 16:13:16 +0100
Subject: [PATCH 18/20] Update docs and types

---
 externs/closure-types.js                    | 11 ++++
 lib/mixins/strict-binding-parser.html       | 19 +++++-
 types/lib/mixins/strict-binding-parser.d.ts | 67 +++++++++++++++++++++
 3 files changed, 95 insertions(+), 2 deletions(-)
 create mode 100644 types/lib/mixins/strict-binding-parser.d.ts

diff --git a/externs/closure-types.js b/externs/closure-types.js
index c8b38c77e3..53a27aed29 100644
--- a/externs/closure-types.js
+++ b/externs/closure-types.js
@@ -1377,6 +1377,17 @@ Polymer_ArraySelectorMixin.prototype.select = function(item){};
 Polymer_ArraySelectorMixin.prototype.selectIndex = function(idx){};
 /**
 * @interface
+* @extends {Polymer_PropertyEffects}
+*/
+function Polymer_StrictBindingParser(){}
+/**
+* @param {string} text Text to parse from attribute or textContent
+* @param {Object} templateInfo Current template metadata
+* @return {Array.<!BindingPart>}
+*/
+Polymer_StrictBindingParser._parseBindings = function(text, templateInfo){};
+/**
+* @interface
 * @extends {Polymer_ElementMixin}
 */
 function Polymer_DisableUpgradeMixin(){}
diff --git a/lib/mixins/strict-binding-parser.html b/lib/mixins/strict-binding-parser.html
index 2706b473b7..03a3b3d278 100644
--- a/lib/mixins/strict-binding-parser.html
+++ b/lib/mixins/strict-binding-parser.html
@@ -10,6 +10,7 @@
 <link rel="import" href="../utils/boot.html">
 <link rel="import" href="../utils/path.html">
 <link rel="import" href="../utils/mixin.html">
+<link rel="import" href="../mixins/property-effects.html">
 
 <script>
 (function() {
@@ -113,13 +114,27 @@
    * state machine instead of a regex. As such, this implementation is able to
    * handle more cases, with the potential performance hit.
    *
-   * @namespace
+   * @mixinFunction
+   * @appliesMixin Polymer.PropertyEffects
+   * @polymer
    * @memberof Polymer
    * @summary Mixin that parses binding expressions and generates corresponding metadata.
    */
   const StrictBindingParser = Polymer.dedupingMixin((base) => {
 
-    return class extends base {
+    /**
+     * @constructor
+     * @extends {base}
+     * @implements {Polymer_PropertyEffects}
+     */
+    const elementBase = Polymer.PropertyEffects(base);
+
+    /**
+     * @polymer
+     * @mixinClass
+     * @implements {Polymer_PropertyEffects}
+     */
+    return class extends elementBase {
 
       /**
        * Called to parse text in a template (either attribute values or
diff --git a/types/lib/mixins/strict-binding-parser.d.ts b/types/lib/mixins/strict-binding-parser.d.ts
new file mode 100644
index 0000000000..b4d9406b95
--- /dev/null
+++ b/types/lib/mixins/strict-binding-parser.d.ts
@@ -0,0 +1,67 @@
+/**
+ * DO NOT EDIT
+ *
+ * This file was automatically generated by
+ *   https://github.com/Polymer/gen-typescript-declarations
+ *
+ * To modify these typings, edit the source file(s):
+ *   lib/mixins/strict-binding-parser.html
+ */
+
+/// <reference path="../utils/boot.d.ts" />
+/// <reference path="../utils/path.d.ts" />
+/// <reference path="../utils/mixin.d.ts" />
+/// <reference path="property-effects.d.ts" />
+
+declare namespace Polymer {
+
+
+  /**
+   * Mixin that parses binding expressions and generates corresponding metadata.
+   * The implementation is different than in `property-effects`, as it uses a
+   * state machine instead of a regex. As such, this implementation is able to
+   * handle more cases, with the potential performance hit.
+   */
+  function StrictBindingParser<T extends new (...args: any[]) => {}>(base: T): T & StrictBindingParserConstructor & Polymer.PropertyEffectsConstructor & Polymer.TemplateStampConstructor & Polymer.PropertyAccessorsConstructor & Polymer.PropertiesChangedConstructor;
+
+  interface StrictBindingParserConstructor {
+    new(...args: any[]): StrictBindingParser;
+
+    /**
+     * Called to parse text in a template (either attribute values or
+     * textContent) into binding metadata.
+     *
+     * Any overrides of this method should return an array of binding part
+     * metadata  representing one or more bindings found in the provided text
+     * and any "literal" text in between.  Any non-literal parts will be passed
+     * to `_evaluateBinding` when any dependencies change.  The only required
+     * fields of each "part" in the returned array are as follows:
+     *
+     * - `dependencies` - Array containing trigger metadata for each property
+     *   that should trigger the binding to update
+     * - `literal` - String containing text if the part represents a literal;
+     *   in this case no `dependencies` are needed
+     *
+     * Additional metadata for use by `_evaluateBinding` may be provided in
+     * each part object as needed.
+     *
+     * The default implementation handles the following types of bindings
+     * (one or more may be intermixed with literal strings):
+     * - Property binding: `[[prop]]`
+     * - Path binding: `[[object.prop]]`
+     * - Negated property or path bindings: `[[!prop]]` or `[[!object.prop]]`
+     * - Two-way property or path bindings (supports negation):
+     *   `{{prop}}`, `{{object.prop}}`, `{{!prop}}` or `{{!object.prop}}`
+     * - Inline computed method (supports negation):
+     *   `[[compute(a, 'literal', b)]]`, `[[!compute(a, 'literal', b)]]`
+     *
+     * @param text Text to parse from attribute or textContent
+     * @param templateInfo Current template metadata
+     * @returns Array of binding part metadata
+     */
+    _parseBindings(text: string, templateInfo: object|null): BindingPart[]|null;
+  }
+
+  interface StrictBindingParser {
+  }
+}

From 89ab7385d24dc44cd920979023e00c99e4268657 Mon Sep 17 00:00:00 2001
From: Tim van der Lippe <tvanderlippe@gmail.com>
Date: Sat, 31 Mar 2018 15:57:16 +0200
Subject: [PATCH 19/20] Add note about performance vs correctness

---
 lib/mixins/property-effects.html | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/lib/mixins/property-effects.html b/lib/mixins/property-effects.html
index 0feb7c9e41..d5c60613e2 100644
--- a/lib/mixins/property-effects.html
+++ b/lib/mixins/property-effects.html
@@ -2629,6 +2629,17 @@
        * - Inline computed method (supports negation):
        *   `[[compute(a, 'literal', b)]]`, `[[!compute(a, 'literal', b)]]`
        *
+       * The default implementation uses a regular expression for best
+       * performance. However, the regular expression uses a white-list of
+       * allowed characters in a data-binding, which causes problems for
+       * data-bindings that do use characters not in this white-list.
+       *
+       * Instead of updating the white-list with all allowed characters,
+       * there is a StrictBindingParser (see lib/mixins/strict-binding-parser)
+       * that uses a state machine instead. This state machine is able to handle
+       * all characters. However, it is slightly less performant, therefore we
+       * extracted it into a separate optional mixin.
+       *
        * @param {string} text Text to parse from attribute or textContent
        * @param {Object} templateInfo Current template metadata
        * @return {Array<!BindingPart>} Array of binding part metadata

From 23ba7dee27ca4e7acdfc758b7c249b8542e618a7 Mon Sep 17 00:00:00 2001
From: Tim van der Lippe <tvanderlippe@gmail.com>
Date: Sat, 31 Mar 2018 16:02:01 +0200
Subject: [PATCH 20/20] Update types

---
 types/lib/mixins/property-effects.d.ts | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/types/lib/mixins/property-effects.d.ts b/types/lib/mixins/property-effects.d.ts
index 572674abe3..52aec3a068 100644
--- a/types/lib/mixins/property-effects.d.ts
+++ b/types/lib/mixins/property-effects.d.ts
@@ -257,6 +257,17 @@ declare namespace Polymer {
      * - Inline computed method (supports negation):
      *   `[[compute(a, 'literal', b)]]`, `[[!compute(a, 'literal', b)]]`
      *
+     * The default implementation uses a regular expression for best
+     * performance. However, the regular expression uses a white-list of
+     * allowed characters in a data-binding, which causes problems for
+     * data-bindings that do use characters not in this white-list.
+     *
+     * Instead of updating the white-list with all allowed characters,
+     * there is a StrictBindingParser (see lib/mixins/strict-binding-parser)
+     * that uses a state machine instead. This state machine is able to handle
+     * all characters. However, it is slightly less performant, therefore we
+     * extracted it into a separate optional mixin.
+     *
      * @param text Text to parse from attribute or textContent
      * @param templateInfo Current template metadata
      * @returns Array of binding part metadata