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);
   });