From 3f1bc4e33a63ef3517f61003f77212faac5f74d7 Mon Sep 17 00:00:00 2001
From: herr kaste <herr.kaste@googlemail.com>
Date: Mon, 1 Feb 2016 23:31:03 +0100
Subject: [PATCH 1/5] Support dynamic functions for computed annotations.

Alternate take for #3299
---
 src/standard/annotations.html | 13 +++++++++++--
 test/unit/bind-elements.html  | 32 ++++++++++++++++++++++++++++++++
 test/unit/bind.html           | 30 ++++++++++++++++++++++++++++++
 3 files changed, 73 insertions(+), 2 deletions(-)

diff --git a/src/standard/annotations.html b/src/standard/annotations.html
index 7c845c67..7ec8548f 100644
--- a/src/standard/annotations.html
+++ b/src/standard/annotations.html
@@ -145,8 +145,17 @@ TODO(sjmiles): this module should produce either syntactic metadata
           for (var k=0; k<b.parts.length; k++) {
             var p = b.parts[k];
             if (!p.literal) {
-              p.signature = this._parseMethod(p.value);
-              if (!p.signature) {
+              var signature = this._parseMethod(p.value);
+              if (signature) {
+                var method = signature.method;
+                if (this.properties[method]) {
+                  var args = signature.args || [];
+                  args.push(this._parseArg(method));
+                  signature.args = args;
+                  signature.static = false;
+                }
+                p.signature = signature;
+              } else {
                 p.model = this._modelForPath(p.value);
               }
             }
diff --git a/test/unit/bind-elements.html b/test/unit/bind-elements.html
index 851c6d4a..a39e9858 100644
--- a/test/unit/bind-elements.html
+++ b/test/unit/bind-elements.html
@@ -582,3 +582,35 @@
   })();
   </script>
 </dom-module>
+
+<dom-module id="x-bind-computed-property">
+  <template>
+    <div id="check">[[translate('Hello World.')]]</div>
+  </template>
+  <script>
+    Polymer({
+      is: 'x-bind-computed-property',
+      properties: {
+        translate: {
+          type: Function,
+          computed: '_computeTranslateFn(translator)'
+        },
+        translator: {
+          type: Function,
+          value: function() {
+            return function(message) {
+              return 'translated: ' + message;
+            }
+          }
+        },
+      },
+
+      _computeTranslateFn: function(translator) {
+        return function(message) {
+          return translator(message);
+        }
+      },
+
+    });
+  </script>
+</dom-module>
diff --git a/test/unit/bind.html b/test/unit/bind.html
index 1bd95331..752b5cfe 100644
--- a/test/unit/bind.html
+++ b/test/unit/bind.html
@@ -285,6 +285,36 @@ suite('single-element binding effects', function() {
 
 <script>
 
+suite('computed properties', function() {
+
+  var el;
+
+  setup(function() {
+
+  });
+
+  teardown(function() {
+    document.body.removeChild(el);
+  });
+
+  test('x', function() {
+    el = document.createElement('x-bind-computed-property');
+    document.body.appendChild(el);
+
+    assert.equal(el.$.check.textContent, 'translated: Hello World.');
+
+    el.translator = function(message) {
+      return 'changed: ' + message;
+    }
+
+    assert.equal(el.$.check.textContent, 'changed: Hello World.');
+  });
+
+});
+
+</script>
+
+<script>
 suite('2-way binding effects between elements', function() {
 
   var el;

From 3c12178f79f829798292f8eb7910c2c3402ed8f1 Mon Sep 17 00:00:00 2001
From: herr kaste <herr.kaste@googlemail.com>
Date: Tue, 2 Feb 2016 23:45:28 +0100
Subject: [PATCH 2/5] Proper implementation

Replace ad hoc hack with a proper implementation.
---
 src/standard/annotations.html   | 7 ++-----
 src/standard/effectBuilder.html | 8 ++++++++
 test/unit/bind.html             | 4 ++--
 3 files changed, 12 insertions(+), 7 deletions(-)

diff --git a/src/standard/annotations.html b/src/standard/annotations.html
index 7ec8548f..8c14137f 100644
--- a/src/standard/annotations.html
+++ b/src/standard/annotations.html
@@ -147,11 +147,8 @@ TODO(sjmiles): this module should produce either syntactic metadata
             if (!p.literal) {
               var signature = this._parseMethod(p.value);
               if (signature) {
-                var method = signature.method;
-                if (this.properties[method]) {
-                  var args = signature.args || [];
-                  args.push(this._parseArg(method));
-                  signature.args = args;
+                if (this.properties[signature.method]) {
+                  signature.dynamicFn = true;
                   signature.static = false;
                 }
                 p.signature = signature;
diff --git a/src/standard/effectBuilder.html b/src/standard/effectBuilder.html
index 493a7c12..03635275 100644
--- a/src/standard/effectBuilder.html
+++ b/src/standard/effectBuilder.html
@@ -171,6 +171,14 @@ subject to an additional IP rights grant found at http://polymer.github.io/PATEN
               arg);
           }
         }
+        if (sig.dynamicFn) {
+          // trigger=null is sufficient as long as we don't allow paths to be
+          // used. If we change our mind, we must first implement this in the
+          // effects anyway where we basically do a `fn = this[methodName]` at
+          // the moment.
+          this.__addAnnotatedComputationEffect(
+              sig.method, index, note, part, null);
+        }
       }
     },
 
diff --git a/test/unit/bind.html b/test/unit/bind.html
index 752b5cfe..c13ed6fc 100644
--- a/test/unit/bind.html
+++ b/test/unit/bind.html
@@ -285,7 +285,7 @@ suite('single-element binding effects', function() {
 
 <script>
 
-suite('computed properties', function() {
+suite('computed bindings with dynamic functions', function() {
 
   var el;
 
@@ -297,7 +297,7 @@ suite('computed properties', function() {
     document.body.removeChild(el);
   });
 
-  test('x', function() {
+  test('annotated computation with dynamic function', function() {
     el = document.createElement('x-bind-computed-property');
     document.body.appendChild(el);
 

From f4486a263c9b64b562939ff111aa125e2d3f18cb Mon Sep 17 00:00:00 2001
From: herr kaste <herr.kaste@googlemail.com>
Date: Wed, 3 Feb 2016 23:02:25 +0100
Subject: [PATCH 3/5] Generalized approach supporting compute and observers

---
 src/lib/bind/effects.html       | 34 ++++++++++++++-----
 src/standard/annotations.html   |  4 ---
 src/standard/effectBuilder.html | 35 ++++++++++++++++++--
 test/unit/bind.html             | 58 +++++++++++++++++++++++++++++++++
 4 files changed, 115 insertions(+), 16 deletions(-)

diff --git a/src/lib/bind/effects.html b/src/lib/bind/effects.html
index 06be1433..be9b3893 100644
--- a/src/lib/bind/effects.html
+++ b/src/lib/bind/effects.html
@@ -67,6 +67,10 @@ subject to an additional IP rights grant found at http://polymer.github.io/PATEN
         if (args) {
           fn.apply(this, args);
         }
+      } else if (effect.dynamicFn) {
+        // dynamic functions can be just like every other property `undefined`
+        // so we MUST ignore an undefined value here. (That's totally the
+        // same guard we use within `_marshalArgs` and part of the spec.)
       } else {
         this._warn(this._logf('_complexObserverEffect', 'observer method `' +
           effect.method + '` not defined'));
@@ -74,15 +78,20 @@ subject to an additional IP rights grant found at http://polymer.github.io/PATEN
     },
 
     _computeEffect: function(source, value, effect) {
-      var args = Polymer.Bind._marshalArgs(this.__data__, effect, source, value);
-      if (args) {
-        var fn = this[effect.method];
-        if (fn) {
-          this.__setProperty(effect.name, fn.apply(this, args));
-        } else {
-          this._warn(this._logf('_computeEffect', 'compute method `' +
-            effect.method + '` not defined'));
+      var fn = this[effect.method];
+      if (fn) {
+        var args = Polymer.Bind._marshalArgs(this.__data__, effect, source, value);
+        if (args) {
+          var computedvalue = fn.apply(this, args);
+          this.__setProperty(effect.name, computedvalue);
         }
+      } else if (effect.dynamicFn) {
+        // dynamic functions can be just like every other property `undefined`
+        // so we MUST ignore an undefined value here. (That's totally the
+        // same guard we use within `_marshalArgs` and part of the spec.)
+      } else {
+        this._warn(this._logf('_computeEffect', 'compute method `' +
+          effect.method + '` not defined'));
       }
     },
 
@@ -98,6 +107,10 @@ subject to an additional IP rights grant found at http://polymer.github.io/PATEN
           }
           this._applyEffectValue(effect, computedvalue);
         }
+      } else if (effect.dynamicFn) {
+        // dynamic functions can be just like every other property `undefined`
+        // so we MUST ignore an undefined value here. (That's totally the
+        // same guard we use within `_marshalArgs` and part of the spec.)
       } else {
         computedHost._warn(computedHost._logf('_annotatedComputationEffect',
           'compute method `' + effect.method + '` not defined'));
@@ -109,6 +122,9 @@ subject to an additional IP rights grant found at http://polymer.github.io/PATEN
     _marshalArgs: function(model, effect, path, value) {
       var values = [];
       var args = effect.args;
+      // Actually we should return early as soon as we see an `undefined`,
+      // but dom-repeat relies on this behavior.
+      var bailoutEarly = (args.length > 1 || effect.dynamicFn);
       for (var i=0, l=args.length; i<l; i++) {
         var arg = args[i];
         var name = arg.name;
@@ -120,7 +136,7 @@ subject to an additional IP rights grant found at http://polymer.github.io/PATEN
         } else {
           v = model[name];
         }
-        if (args.length > 1 && v === undefined) {
+        if (bailoutEarly && v === undefined) {
           return;
         }
         if (arg.wildcard) {
diff --git a/src/standard/annotations.html b/src/standard/annotations.html
index 8c14137f..3743c48a 100644
--- a/src/standard/annotations.html
+++ b/src/standard/annotations.html
@@ -147,10 +147,6 @@ TODO(sjmiles): this module should produce either syntactic metadata
             if (!p.literal) {
               var signature = this._parseMethod(p.value);
               if (signature) {
-                if (this.properties[signature.method]) {
-                  signature.dynamicFn = true;
-                  signature.static = false;
-                }
                 p.signature = signature;
               } else {
                 p.model = this._modelForPath(p.value);
diff --git a/src/standard/effectBuilder.html b/src/standard/effectBuilder.html
index 03635275..749addc0 100644
--- a/src/standard/effectBuilder.html
+++ b/src/standard/effectBuilder.html
@@ -79,14 +79,27 @@ subject to an additional IP rights grant found at http://polymer.github.io/PATEN
 
     _addComputedEffect: function(name, expression) {
       var sig = this._parseMethod(expression);
+
+      var dynamicFn = sig.dynamicFn;
+
       for (var i=0, arg; (i<sig.args.length) && (arg=sig.args[i]); i++) {
         this._addPropertyEffect(arg.model, 'compute', {
           method: sig.method,
           args: sig.args,
           trigger: arg,
-          name: name
+          name: name,
+          dynamicFn: dynamicFn
         });
       }
+      if (dynamicFn) {
+        this._addPropertyEffect(sig.method, 'compute', {
+          method: sig.method,
+          args: sig.args,
+          trigger: null,
+          name: name,
+          dynamicFn: dynamicFn
+        })
+      }
     },
 
     _addObserverEffect: function(property, observer) {
@@ -111,11 +124,22 @@ subject to an additional IP rights grant found at http://polymer.github.io/PATEN
         throw new Error("Malformed observer expression '" + observer + "'");
       }
 
+      var dynamicFn = sig.dynamicFn;
+
       for (var i=0, arg; (i<sig.args.length) && (arg=sig.args[i]); i++) {
         this._addPropertyEffect(arg.model, 'complexObserver', {
           method: sig.method,
           args: sig.args,
-          trigger: arg
+          trigger: arg,
+          dynamicFn: dynamicFn
+        });
+      }
+      if (dynamicFn) {
+        this._addPropertyEffect(sig.method, 'complexObserver', {
+          method: sig.method,
+          args: sig.args,
+          trigger: null,
+          dynamicFn: dynamicFn
         });
       }
     },
@@ -192,7 +216,8 @@ subject to an additional IP rights grant found at http://polymer.github.io/PATEN
         negate: part.negate,
         method: part.signature.method,
         args: part.signature.args,
-        trigger: trigger
+        trigger: trigger,
+        dynamicFn: part.signature.dynamicFn
       });
     },
 
@@ -202,6 +227,10 @@ subject to an additional IP rights grant found at http://polymer.github.io/PATEN
       var m = expression.match(/([^\s]+?)\(([\s\S]*)\)/);
       if (m) {
         var sig = { method: m[1], static: true };
+        if (this.properties[sig.method]) {
+          sig.static = false;
+          sig.dynamicFn = true;
+        }
         if (m[2].trim()) {
           // replace escaped commas with comma entity, split on un-escaped commas
           var args = m[2].replace(/\\,/g, '&comma;').split(',');
diff --git a/test/unit/bind.html b/test/unit/bind.html
index c13ed6fc..a7f853f8 100644
--- a/test/unit/bind.html
+++ b/test/unit/bind.html
@@ -310,6 +310,64 @@ suite('computed bindings with dynamic functions', function() {
     assert.equal(el.$.check.textContent, 'changed: Hello World.');
   });
 
+  test('observer with dynamic function', function() {
+    Polymer({
+      is: 'x-observer-with-dynamic-function',
+      properties: {
+        translate: {
+          type: Function,
+        },
+        message: {
+          type: String,
+          value: 'Hello'
+        },
+      },
+
+      observers: ['translate(message)'],
+
+    })
+
+    el = document.createElement('x-observer-with-dynamic-function');
+    document.body.appendChild(el);
+
+    var called = 0;
+    el.translate = function() {
+      called += 1;
+    };
+
+    assert.equal(called, 1);
+
+  });
+
+  test('computed property with dynamic function', function() {
+    Polymer({
+      is: 'x-computed-property-with-dynamic-function',
+      properties: {
+        computedValue: {
+          computed: "translate('Hello')"
+        },
+        translate: {
+          type: Function
+        }
+      }
+    });
+
+    el = document.createElement('x-computed-property-with-dynamic-function');
+    document.body.appendChild(el);
+
+    assert.equal(el.computedValue, undefined);
+
+    var called = 0;
+    el.translate = function(message) {
+      called += 1;
+      return 'translated: ' + message;
+    };
+
+    assert.equal(called, 1);
+    assert.equal(el.computedValue, 'translated: Hello');
+
+  });
+
 });
 
 </script>

From b6abf26fdaf669451d1cfdbc20b735d9cc8be41b Mon Sep 17 00:00:00 2001
From: herr kaste <herr.kaste@googlemail.com>
Date: Fri, 12 Feb 2016 13:30:08 +0100
Subject: [PATCH 4/5] Add support for properties defined in a behavior.

For correctness this is implemented using `getPropertyInfo()` though
this is not optimized at all. Note that `_propertyInfo` is not ready
when we parse the annotations (which is the earliest call to
`_parseMethod` right now). There are several options to make this right,
but these are not part of this feature PR.
---
 src/standard/effectBuilder.html |  3 +-
 test/unit/bind-elements.html    | 49 +++++++++++++++++++--------------
 2 files changed, 30 insertions(+), 22 deletions(-)

diff --git a/src/standard/effectBuilder.html b/src/standard/effectBuilder.html
index 749addc0..a932974c 100644
--- a/src/standard/effectBuilder.html
+++ b/src/standard/effectBuilder.html
@@ -227,7 +227,8 @@ subject to an additional IP rights grant found at http://polymer.github.io/PATEN
       var m = expression.match(/([^\s]+?)\(([\s\S]*)\)/);
       if (m) {
         var sig = { method: m[1], static: true };
-        if (this.properties[sig.method]) {
+        // TODO(kaste): Optimize/memoize `getPropertyInfo`.
+        if (this.getPropertyInfo(sig.method) !== Polymer.nob) {
           sig.static = false;
           sig.dynamicFn = true;
         }
diff --git a/test/unit/bind-elements.html b/test/unit/bind-elements.html
index a39e9858..b7f61ca6 100644
--- a/test/unit/bind-elements.html
+++ b/test/unit/bind-elements.html
@@ -588,29 +588,36 @@
     <div id="check">[[translate('Hello World.')]]</div>
   </template>
   <script>
-    Polymer({
-      is: 'x-bind-computed-property',
-      properties: {
-        translate: {
-          type: Function,
-          computed: '_computeTranslateFn(translator)'
-        },
-        translator: {
-          type: Function,
-          value: function() {
-            return function(message) {
-              return 'translated: ' + message;
+    (function(){
+      var TranslateBehavior = {
+        properties: {
+          translate: {
+            type: Function,
+            computed: '_computeTranslateFn(translator)'
+          }
+        }
+      };
+      Polymer({
+        is: 'x-bind-computed-property',
+        behaviors: [TranslateBehavior],
+        properties: {
+          translator: {
+            type: Function,
+            value: function() {
+              return function(message) {
+                return 'translated: ' + message;
+              }
             }
+          },
+        },
+
+        _computeTranslateFn: function(translator) {
+          return function(message) {
+            return translator(message);
           }
         },
-      },
 
-      _computeTranslateFn: function(translator) {
-        return function(message) {
-          return translator(message);
-        }
-      },
-
-    });
+      });
+    })();
   </script>
-</dom-module>
+</dom-module>
\ No newline at end of file

From 0037c535c84d2f8f226625cb7a0288f2a3583e01 Mon Sep 17 00:00:00 2001
From: herr kaste <herr.kaste@googlemail.com>
Date: Fri, 12 Feb 2016 22:38:20 +0100
Subject: [PATCH 5/5] Add test that late resolved functions don't warn

---
 test/unit/bind-elements.html | 31 +++++++++++++++++++++++++++++++
 test/unit/bind.html          | 13 +++++++++++++
 2 files changed, 44 insertions(+)

diff --git a/test/unit/bind-elements.html b/test/unit/bind-elements.html
index b7f61ca6..f2ae5034 100644
--- a/test/unit/bind-elements.html
+++ b/test/unit/bind-elements.html
@@ -620,4 +620,35 @@
       });
     })();
   </script>
+</dom-module>
+
+<dom-module id="x-bind-computed-property-late-translator">
+  <template>
+    <div id="check">[[translate(message)]]</div>
+  </template>
+  <script>
+    Polymer({
+      is: 'x-bind-computed-property-late-translator',
+      properties: {
+        message: {
+          type: String,
+          value: 'Hello'
+        },
+        translate: {
+          type: Function,
+          computed: '_computeTranslateFn(translator)'
+        },
+        translator: {
+          type: Function,
+        },
+      },
+
+      _computeTranslateFn: function(translator) {
+        return function(message) {
+          return translator(message);
+        }
+      },
+
+    });
+  </script>
 </dom-module>
\ No newline at end of file
diff --git a/test/unit/bind.html b/test/unit/bind.html
index a7f853f8..2f3f1160 100644
--- a/test/unit/bind.html
+++ b/test/unit/bind.html
@@ -310,6 +310,19 @@ suite('computed bindings with dynamic functions', function() {
     assert.equal(el.$.check.textContent, 'changed: Hello World.');
   });
 
+  test('annotated computation / late resolved dynamic function', function() {
+    el = document.createElement('x-bind-computed-property-late-translator');
+    document.body.appendChild(el);
+
+    assert.equal(el.$.check.textContent.trim(), '');
+
+    el.translator = function(message) {
+      return 'translated: ' + message;
+    };
+
+    assert.equal(el.$.check.textContent, 'translated: Hello');
+  });
+
   test('observer with dynamic function', function() {
     Polymer({
       is: 'x-observer-with-dynamic-function',