From c46a38de7c5cd2f0c81145352b189f4cab7e19d9 Mon Sep 17 00:00:00 2001
From: Kevin Schaaf <kschaaf@google.com>
Date: Wed, 20 Jun 2018 17:45:48 -0700
Subject: [PATCH] Add legacy-data-mixin as 1.x->2.x migration aide. Fixes
 #5262.

---
 lib/legacy/class.html             |  10 +-
 lib/legacy/legacy-data-mixin.html | 104 +++++++++++
 lib/mixins/property-effects.html  | 102 +++++------
 test/unit/legacy-data.html        | 278 ++++++++++++++++++++++++++++++
 4 files changed, 440 insertions(+), 54 deletions(-)
 create mode 100644 lib/legacy/legacy-data-mixin.html
 create mode 100644 test/unit/legacy-data.html

diff --git a/lib/legacy/class.html b/lib/legacy/class.html
index afe838cc57..82349b620b 100644
--- a/lib/legacy/class.html
+++ b/lib/legacy/class.html
@@ -353,17 +353,21 @@
      *
      * @param {!PolymerInit} info Object containing Polymer metadata and functions
      *   to become class methods.
+     * @template T
+     * @param {function(T):T} mixin Optional mixin to apply to legacy base class
      * @return {function(new:HTMLElement)} Generated class
      * @memberof Polymer
      */
-    Polymer.Class = function(info) {
+    Polymer.Class = function(info, mixin) {
       if (!info) {
         console.warn('Polymer.Class requires `info` argument');
       }
-      let klass = GenerateClassFromInfo(info, info.behaviors ?
+      const baseWithBehaviors = info.behaviors ?
         // note: mixinBehaviors ensures `LegacyElementMixin`.
         mixinBehaviors(info.behaviors, HTMLElement) :
-        Polymer.LegacyElementMixin(HTMLElement));
+        Polymer.LegacyElementMixin(HTMLElement);
+      const baseWithMixin = mixin ? mixin(baseWithBehaviors) : baseWithBehaviors;
+      const klass = GenerateClassFromInfo(info, baseWithMixin);
       // decorate klass with registration info
       klass.is = info.is;
       return klass;
diff --git a/lib/legacy/legacy-data-mixin.html b/lib/legacy/legacy-data-mixin.html
new file mode 100644
index 0000000000..32ad88c941
--- /dev/null
+++ b/lib/legacy/legacy-data-mixin.html
@@ -0,0 +1,104 @@
+<!--
+@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="../utils/mixin.html">
+
+<script>
+(function() {
+  'use strict';
+
+  const UndefinedArgumentError = class extends Error {};
+
+  /**
+   * Mixin to selectively add back Polymer 1.x's `undefined` rules
+   * governing when observers & computing functions run based
+   * on all arguments being defined (reference https://www.polymer-project.org/1.0/docs/devguide/observers#multi-property-observers).
+   * 
+   * When loaded, all legacy elements (defined with `Polymer({...})`)
+   * will have the mixin applied. The mixin only restores legacy data handling
+   * if `_legacyUndefinedCheck: true` is set on the element's prototype.
+   * 
+   * This mixin is intended for use to help migration from Polymer 1.x to
+   * 2.x+ by allowing legacy code to work while identifying observers and
+   * computing functions that need undefined checks to work without
+   * the mixin in Polymer 2.
+   */
+  Polymer.LegacyDataMixin = Polymer.dedupingMixin(superClass => {
+
+    /**
+     * @polymer
+     * @mixinClass
+     * @implements {Polymer_LegacyDataMixin}
+     */
+    class LegacyDataMixin extends superClass {
+      /**
+       * Overrides `Polyer.PropertyEffects` to add `undefined` argument
+       * checking to match Polymer 1.x style rules
+       * 
+       * @param {!Array<!MethodArg>} args Array of argument metadata
+       * @param {string} path Property/path name that triggered the method effect
+       * @param {Object} props Bag of current property changes
+       * @return {Array<*>} Array of argument values
+       * @private
+       */
+      _marshalArgs(args, path, props) {
+        const vals = super._marshalArgs(args, path, props);
+        if (this._legacyUndefinedCheck && args.length > 1) {
+          for (let i=0; i<args.length; i++) {
+            if (vals[i] === undefined) {
+              throw new UndefinedArgumentError(`argument '${args[i].name}' is undefined; ensure it has an undefined check`);
+            }
+          }
+        }
+        return vals;
+      }
+
+      /**
+       * Overrides `Polyer.PropertyEffects` to wrap effect functions to
+       * catch `UndefinedArgumentError`s and warn.
+       * 
+       * @param {string} property Property that should trigger the effect
+       * @param {string} type Effect type, from this.PROPERTY_EFFECT_TYPES
+       * @param {Object=} effect Effect metadata object
+       * @return {void}
+       * @protected
+       */
+       _addPropertyEffect(property, type, effect) {
+        if (effect && effect.fn) {
+          const fn = effect.fn;
+          effect.fn = function() {
+            try {
+              fn.apply(this, arguments);
+            } catch (e) {
+              if (e instanceof UndefinedArgumentError) {
+                console.warn(e.message);
+              } else {
+                throw e;
+              }
+            }
+          };
+        }
+        return super._addPropertyEffect(property, type, effect);
+      }
+
+    }
+
+    return LegacyDataMixin;
+
+  });
+
+  const Class = Polymer.Class;
+  Polymer.Class = info => Class(info, Polymer.LegacyDataMixin);
+
+  console.info('LegacyDataMixin will be applied to all legacy elements.\n' +
+               'Set `_legacyUndefinedCheck: true` to enable.');
+
+})();
+</script>
diff --git a/lib/mixins/property-effects.html b/lib/mixins/property-effects.html
index de92b17c4a..8cb808d6fa 100644
--- a/lib/mixins/property-effects.html
+++ b/lib/mixins/property-effects.html
@@ -814,7 +814,7 @@
     let context = inst._methodHost || inst;
     let fn = context[info.methodName];
     if (fn) {
-      let args = marshalArgs(inst.__data, info.args, property, props);
+      let args = inst._marshalArgs(info.args, property, props);
       return fn.apply(context, args);
     } else if (!info.dynamicFn) {
       console.warn('method `' + info.methodName + '` not defined');
@@ -970,56 +970,6 @@
     return a;
   }
 
-  /**
-   * Gather the argument values for a method specified in the provided array
-   * of argument metadata.
-   *
-   * The `path` and `value` arguments are used to fill in wildcard descriptor
-   * when the method is being called as a result of a path notification.
-   *
-   * @param {Object} data Instance data storage object to read properties from
-   * @param {!Array<!MethodArg>} args Array of argument metadata
-   * @param {string} path Property/path name that triggered the method effect
-   * @param {Object} props Bag of current property changes
-   * @return {Array<*>} Array of argument values
-   * @private
-   */
-  function marshalArgs(data, args, path, props) {
-    let values = [];
-    for (let i=0, l=args.length; i<l; i++) {
-      let arg = args[i];
-      let name = arg.name;
-      let v;
-      if (arg.literal) {
-        v = arg.value;
-      } else {
-        if (arg.structured) {
-          v = Polymer.Path.get(data, name);
-          // when data is not stored e.g. `splices`
-          if (v === undefined) {
-            v = props[name];
-          }
-        } else {
-          v = data[name];
-        }
-      }
-      if (arg.wildcard) {
-        // Only send the actual path changed info if the change that
-        // caused the observer to run matched the wildcard
-        let baseChanged = (name.indexOf(path + '.') === 0);
-        let matches = (path.indexOf(name) === 0 && !baseChanged);
-        values[i] = {
-          path: matches ? path : name,
-          value: matches ? props[path] : v,
-          base: v
-        };
-      } else {
-        values[i] = v;
-      }
-    }
-    return values;
-  }
-
   // data api
 
   /**
@@ -2180,6 +2130,56 @@
         createMethodEffect(this, sig, TYPES.COMPUTE, runComputedEffect, property, dynamicFn);
       }
 
+      /**
+       * Gather the argument values for a method specified in the provided array
+       * of argument metadata.
+       *
+       * The `path` and `value` arguments are used to fill in wildcard descriptor
+       * when the method is being called as a result of a path notification.
+       *
+       * @param {!Array<!MethodArg>} args Array of argument metadata
+       * @param {string} path Property/path name that triggered the method effect
+       * @param {Object} props Bag of current property changes
+       * @return {Array<*>} Array of argument values
+       * @private
+       */
+      _marshalArgs(args, path, props) {
+        const data = this.__data;
+        let values = [];
+        for (let i=0, l=args.length; i<l; i++) {
+          let arg = args[i];
+          let name = arg.name;
+          let v;
+          if (arg.literal) {
+            v = arg.value;
+          } else {
+            if (arg.structured) {
+              v = Polymer.Path.get(data, name);
+              // when data is not stored e.g. `splices`
+              if (v === undefined) {
+                v = props[name];
+              }
+            } else {
+              v = data[name];
+            }
+          }
+          if (arg.wildcard) {
+            // Only send the actual path changed info if the change that
+            // caused the observer to run matched the wildcard
+            let baseChanged = (name.indexOf(path + '.') === 0);
+            let matches = (path.indexOf(name) === 0 && !baseChanged);
+            values[i] = {
+              path: matches ? path : name,
+              value: matches ? props[path] : v,
+              base: v
+            };
+          } else {
+            values[i] = v;
+          }
+        }
+        return values;
+      }
+
       // -- static class methods ------------
 
       /**
diff --git a/test/unit/legacy-data.html b/test/unit/legacy-data.html
new file mode 100644
index 0000000000..bda4d989b8
--- /dev/null
+++ b/test/unit/legacy-data.html
@@ -0,0 +1,278 @@
+<!doctype html>
+<!--
+@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
+-->
+<html>
+<head>
+  <meta charset="utf-8">
+  <script src="../../../webcomponentsjs/webcomponents-lite.js"></script>
+  <script src="../../../web-component-tester/browser.js"></script>
+  <link rel="import" href="../../polymer.html">
+  <link rel="import" href="../../lib/legacy/legacy-data-mixin.html">
+</head>
+<body>
+
+  <script>
+  </script>
+  
+  <dom-module id="x-data">
+    <script>
+      HTMLImports.whenReady(() => {
+        Polymer({
+          is: 'x-data',
+          observers: [
+            'static("static")',
+            'one(a)',
+            'two(b, c)',
+            'throws(d)'
+          ],
+          created() {
+            this.one = sinon.spy();
+            this.two = sinon.spy();
+            this.static = sinon.spy();
+          },
+          throws() {
+            throw new Error('real error');
+          }
+        });
+      });
+    </script>
+  </dom-module>
+
+  <test-fixture id="declarative-one">
+    <x-data a="a"></x-data>
+  </test-fixture>
+
+  <test-fixture id="declarative-two">
+    <x-data a="a" b="b"></x-data>
+  </test-fixture>
+
+  <test-fixture id="declarative-all">
+    <x-data a="a" b="b"></x-data>
+  </test-fixture>
+
+  <script>
+  suite('imperative', () => {
+    setup(() => sinon.spy(console, 'warn'));
+    teardown(() => console.warn.restore());
+    suite('check disabled', () => {
+      test('no arguments defined', () => {
+        const el = document.createElement('x-data');
+        document.body.appendChild(el);
+        assert.equal(el.static.callCount, 1);
+        assert.equal(el.one.callCount, 0);
+        assert.equal(el.two.callCount, 0);
+        assert.equal(console.warn.callCount, 0);
+        document.body.removeChild(el);
+      });
+      test('one argument defined', () => {
+        const el = document.createElement('x-data');
+        el.a = 'a';
+        document.body.appendChild(el);
+        assert.equal(el.static.callCount, 1);
+        assert.equal(el.one.callCount, 1);
+        assert.equal(el.two.callCount, 0);
+        assert.equal(console.warn.callCount, 0);
+        document.body.removeChild(el);
+      });
+      test('two arguments defined', () => {
+        const el = document.createElement('x-data');
+        el.a = 'a';
+        el.b = 'b';
+        document.body.appendChild(el);
+        assert.equal(el.static.callCount, 1);
+        assert.equal(el.one.callCount, 1);
+        assert.equal(el.two.callCount, 1);
+        document.body.removeChild(el);
+      });
+      test('all arguments defined', () => {
+        const el = document.createElement('x-data');
+        el.a = 'a';
+        el.b = 'b';
+        el.c = 'c';
+        document.body.appendChild(el);
+        assert.equal(el.static.callCount, 1);
+        assert.equal(el.one.callCount, 1);
+        assert.equal(el.two.callCount, 1);
+        assert.equal(console.warn.callCount, 0);
+        document.body.removeChild(el);
+      });
+      test('one argument undefined', () => {
+        const el = document.createElement('x-data');
+        el.a = 'a';
+        el.b = 'b';
+        el.c = 'c';
+        document.body.appendChild(el);
+        assert.equal(el.static.callCount, 1);
+        assert.equal(el.one.callCount, 1);
+        assert.equal(el.two.callCount, 1);
+        el.a = undefined;
+        assert.equal(el.static.callCount, 1);
+        assert.equal(el.one.callCount, 2);
+        assert.equal(el.two.callCount, 1);
+        assert.equal(console.warn.callCount, 0);
+        document.body.removeChild(el);
+      });
+      test('two arguments undefined', () => {
+        const el = document.createElement('x-data');
+        el.a = 'a';
+        el.b = 'b';
+        el.c = 'c';
+        document.body.appendChild(el);
+        assert.equal(el.static.callCount, 1);
+        assert.equal(el.one.callCount, 1);
+        assert.equal(el.two.callCount, 1);
+        el.a = undefined;
+        el.b = undefined;
+        assert.equal(el.static.callCount, 1);
+        assert.equal(el.one.callCount, 2);
+        assert.equal(el.two.callCount, 2);
+        assert.equal(console.warn.callCount, 0);
+        document.body.removeChild(el);
+      });
+      test('all arguments undefined', () => {
+        const el = document.createElement('x-data');
+        el.a = 'a';
+        el.b = 'b';
+        el.c = 'c';
+        document.body.appendChild(el);
+        assert.equal(el.static.callCount, 1);
+        assert.equal(el.one.callCount, 1);
+        assert.equal(el.two.callCount, 1);
+        el.a = undefined;
+        el.b = undefined;
+        el.c = undefined;
+        assert.equal(el.static.callCount, 1);
+        assert.equal(el.one.callCount, 2);
+        assert.equal(el.two.callCount, 3);
+        assert.equal(console.warn.callCount, 0);
+        document.body.removeChild(el);
+      });
+    });
+    // ------------------------------------------------
+    suite('warn', () => {
+      test('no arguments defined', () => {
+        const el = document.createElement('x-data');
+        el._legacyUndefinedCheck = true;
+        document.body.appendChild(el);
+        assert.equal(el.static.callCount, 1);
+        assert.equal(el.one.callCount, 0);
+        assert.equal(el.two.callCount, 0);
+        assert.equal(console.warn.callCount, 0);
+        document.body.removeChild(el);
+      });
+      test('one argument defined', () => {
+        const el = document.createElement('x-data');
+        el._legacyUndefinedCheck = true;
+        el.a = 'a';
+        document.body.appendChild(el);
+        assert.equal(el.static.callCount, 1);
+        assert.equal(el.one.callCount, 1);
+        assert.equal(el.two.callCount, 0);
+        assert.equal(console.warn.callCount, 0);
+        document.body.removeChild(el);
+      });
+      test('two arguments defined', () => {
+        const el = document.createElement('x-data');
+        el._legacyUndefinedCheck = true;
+        el.a = 'a';
+        el.b = 'b';
+        document.body.appendChild(el);
+        assert.equal(el.static.callCount, 1);
+        assert.equal(el.one.callCount, 1);
+        assert.equal(el.two.callCount, 0);
+        assert.isTrue(console.warn.calledOnce);
+        assert.match(console.warn.firstCall.args[0], /'c' is undefined/);
+        document.body.removeChild(el);
+      });
+      test('all arguments defined', () => {
+        const el = document.createElement('x-data');
+        el._legacyUndefinedCheck = true;
+        el.a = 'a';
+        el.b = 'b';
+        el.c = 'c';
+        document.body.appendChild(el);
+        assert.equal(el.static.callCount, 1);
+        assert.equal(el.one.callCount, 1);
+        assert.equal(el.two.callCount, 1);
+        assert.equal(console.warn.callCount, 0);
+        document.body.removeChild(el);
+      });
+      test('one argument undefined', () => {
+        const el = document.createElement('x-data');
+        el._legacyUndefinedCheck = true;
+        el.a = 'a';
+        el.b = 'b';
+        el.c = 'c';
+        document.body.appendChild(el);
+        assert.equal(el.static.callCount, 1);
+        assert.equal(el.one.callCount, 1);
+        assert.equal(el.two.callCount, 1);
+        el.a = undefined;
+        assert.equal(el.static.callCount, 1);
+        assert.equal(el.one.callCount, 2);
+        assert.equal(el.two.callCount, 1);
+        assert.equal(console.warn.callCount, 0);
+        document.body.removeChild(el);
+      });
+      test('two arguments undefined', () => {
+        const el = document.createElement('x-data');
+        el._legacyUndefinedCheck = true;
+        el.a = 'a';
+        el.b = 'b';
+        el.c = 'c';
+        document.body.appendChild(el);
+        assert.equal(el.static.callCount, 1);
+        assert.equal(el.one.callCount, 1);
+        assert.equal(el.two.callCount, 1);
+        el.a = undefined;
+        el.b = undefined;
+        assert.equal(el.static.callCount, 1);
+        assert.equal(el.one.callCount, 2);
+        assert.equal(el.two.callCount, 1);
+        assert.equal(console.warn.callCount, 1);
+        assert.match(console.warn.firstCall.args[0], /'b' is undefined/);
+        document.body.removeChild(el);
+      });
+      test('all arguments undefined', () => {
+        const el = document.createElement('x-data');
+        el._legacyUndefinedCheck = true;
+        el.a = 'a';
+        el.b = 'b';
+        el.c = 'c';
+        document.body.appendChild(el);
+        assert.equal(el.static.callCount, 1);
+        assert.equal(el.one.callCount, 1);
+        assert.equal(el.two.callCount, 1);
+        el.a = undefined;
+        el.b = undefined;
+        el.c = undefined;
+        assert.equal(el.static.callCount, 1);
+        assert.equal(el.one.callCount, 2);
+        assert.equal(el.two.callCount, 1);
+        assert.equal(console.warn.callCount, 2);
+        assert.match(console.warn.firstCall.args[0], /'b' is undefined/);
+        assert.match(console.warn.secondCall.args[0], /'b' is undefined/);
+        document.body.removeChild(el);
+      });
+    });
+    suite('other', () => {
+      test('real errors still throw', () => {
+        const el = document.createElement('x-data');
+        document.body.appendChild(el);
+        assert.throws(() => {
+          el.d = true;
+        }, /real error/);
+        document.body.removeChild(el);
+      });
+    });
+  });
+  </script>
+</body>
+</html>