Merge branch '2.x' into perf-opt

lib/elements/dom-bind.html

@@ -57,6 +57,9 @@ subject to an additional IP rights grant found at http://polymer.github.io/PATEN
 
       constructor() {
         super();
+        if (Polymer.strictTemplatePolicy) {
+          throw new Error(`strictTemplatePolicy: dom-bind not allowed`);
+        }
         this.root = null;
         this.$ = null;
         this.__children = null;

lib/elements/dom-if.html

@@ -255,8 +255,12 @@ subject to an additional IP rights grant found at http://polymer.github.io/PATEN
         if (c$ && c$.length) {
           // use first child parent, for case when dom-if may have been detached
           let parent = c$[0].parentNode;
-          for (let i=0, n; (i<c$.length) && (n=c$[i]); i++) {
-            parent.removeChild(n);
+          // Instance children may be disconnected from parents when dom-if
+          // detaches if a tree was innerHTML'ed
+          if (parent) {
+            for (let i=0, n; (i<c$.length) && (n=c$[i]); i++) {
+              parent.removeChild(n);
+            }
           }
         }
         this.__instance = null;

lib/elements/dom-module.html

@@ -15,6 +15,12 @@ subject to an additional IP rights grant found at http://polymer.github.io/PATEN
 
   let modules = {};
   let lcModules = {};
+  function setModule(id, module) {
+    // store id separate from lowercased id so that
+    // in all cases mixedCase id will stored distinctly
+    // and lowercase version is a fallback
+    modules[id] = lcModules[id.toLowerCase()] = module;
+  }
   function findModule(id) {
     return modules[id] || lcModules[id.toLowerCase()];
   }
@@ -124,12 +130,14 @@ subject to an additional IP rights grant found at http://polymer.github.io/PATEN
     register(id) {
       id = id || this.id;
       if (id) {
+        // Under strictTemplatePolicy, reject and null out any re-registered
+        // dom-module since it is ambiguous whether first-in or last-in is trusted 
+        if (Polymer.strictTemplatePolicy && findModule(id) !== undefined) {
+          setModule(id, null);
+          throw new Error(`strictTemplatePolicy: dom-module ${id} re-registered`);
+        }
         this.id = id;
-        // store id separate from lowercased id so that
-        // in all cases mixedCase id will stored distinctly
-        // and lowercase version is a fallback
-        modules[id] = this;
-        lcModules[id.toLowerCase()] = this;
+        setModule(id, this);
         styleOutsideTemplateCheck(this);
       }
     }

lib/legacy/class.html

@@ -230,22 +230,6 @@ subject to an additional IP rights grant found at http://polymer.github.io/PATEN
           return observers;
         }
 
-        /**
-         * @return {HTMLTemplateElement} template for this class
-         */
-        static get template() {
-          // get template first from any imperative set in `info._template`
-          return info._template ||
-            // next look in dom-module associated with this element's is.
-            Polymer.DomModule && Polymer.DomModule.import(this.is, 'template') ||
-            // next look for superclass template (note: use superclass symbol
-            // to ensure correct `this.is`)
-            Base.template ||
-            // finally fall back to `_template` in element's prototype.
-            this.prototype._template ||
-            null;
-        }
-
         /**
          * @return {void}
          */
@@ -499,6 +483,7 @@ subject to an additional IP rights grant found at http://polymer.github.io/PATEN
      *
      * @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
      *   before extending with Polymer metaprogramming.
      * @return {function(new:HTMLElement)} Generated class
@@ -513,6 +498,15 @@ subject to an additional IP rights grant found at http://polymer.github.io/PATEN
       klass = GenerateClassFromInfo(info, klass, info.behaviors);
       // decorate klass with registration info
       klass.is = info.is;
+      // To match 1.x behavior, `_template` supplied on a behavior should take
+      // precedence over dom-module lookup for `is`; this also prevents
+      // dom-module injection under strictTemplatePolicy for an element that
+      // would normally get its template from a behavior.
+      // TODO(sorvell): Remove once "flattened behaviors" lands, since both
+      // `_template` and `is` will be on the same class after that change
+      if (klass.prototype._template !== undefined) {
+        klass.prototype._template = klass.prototype._template;
+      }
       return klass;
     };
 

lib/legacy/legacy-data-mixin.html

@@ -0,0 +1,171 @@
+<!--
+@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="class.html">
+<link rel="import" href="../../polymer.html">
+<link rel="import" href="../utils/mixin.html">
+<link rel="import" href="../utils/templatize.html">
+
+<script>
+(function() {
+  'use strict';
+
+  const UndefinedArgumentError = class extends Error {
+    constructor(message, arg) {
+      super(message);
+      this.arg = arg;
+      this.name = this.constructor.name;
+      // Affordances for ensuring instanceof works after babel ES5 compilation
+      // TODO(kschaaf): Remove after polymer CLI updates to newer Babel that
+      // sets the constructor/prototype correctly for subclassed builtins
+      this.constructor = UndefinedArgumentError;
+      this.__proto__ = UndefinedArgumentError.prototype;
+    }
+  };
+
+  /**
+   * Wraps effect functions to catch `UndefinedArgumentError`s and warn.
+   * 
+   * @param {Object=} effect Effect metadata object
+   * @param {Object=} fnName Name of user function, if known
+   * @return {?Object} Effect metadata object
+   */
+  function wrapEffect(effect, fnName) {
+    if (effect && effect.fn) {
+      const fn = effect.fn;
+      effect.fn = function() {
+        try {
+          fn.apply(this, arguments);
+        } catch (e) {
+          if (e instanceof UndefinedArgumentError) {
+            console.warn(`Argument '${e.arg}'${fnName ?` for method '${fnName}'` : ''} was undefined. Ensure it has an undefined check.`);
+          } else {
+            throw e;
+          }
+        }
+      };
+    }
+    return effect;
+  }
+  
+  /**
+   * 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.
+   *
+   * @mixinFunction
+   * @polymer
+   * @summary Mixin to selectively add back Polymer 1.x's `undefined` rules
+   * governing when observers & computing functions run.
+   */
+  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);
+        // Per legacy data rules, single-property observers (whether in `properties`
+        // and in `observers`) are called regardless of whether their argument is
+        // undefined or not. Multi-property observers must have all arguments defined
+        if (this._legacyUndefinedCheck && vals.length > 1) {
+          for (let i=0; i<vals.length; i++) {
+            if (vals[i] === undefined) {
+              // Break out of effect's control flow; will be caught in
+              // wrapped property effect function below
+              const name = args[i].name;
+              throw new UndefinedArgumentError(`Argument '${name}' is undefined. Ensure it has an undefined check.`, name);
+            }
+          }
+        }
+        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) {
+        return super._addPropertyEffect(property, type,
+          wrapEffect(effect, effect && effect.info && effect.info.methodName));
+      }
+
+      /**
+       * Overrides `Polyer.PropertyEffects` to wrap effect functions to
+       * catch `UndefinedArgumentError`s and warn.
+       *
+       * @param {Object} templateInfo Template metadata to add effect to
+       * @param {string} prop Property that should trigger the effect
+       * @param {Object=} effect Effect metadata object
+       * @return {void}
+       * @protected
+       */
+      static _addTemplatePropertyEffect(templateInfo, prop, effect) {
+        return super._addTemplatePropertyEffect(templateInfo, prop, wrapEffect(effect));
+      }
+
+    }
+
+    return LegacyDataMixin;
+
+  });
+
+  // LegacyDataMixin is applied to base class _before_ metaprogramming, to
+  // ensure override of _addPropertyEffect et.al. are used by metaprogramming
+  // performed in _finalizeClass
+  const Class = Polymer.Class;
+  Polymer.Class = (info, mixin) => Class(info, 
+    superClass => mixin ? 
+      mixin(Polymer.LegacyDataMixin(superClass)) : 
+      Polymer.LegacyDataMixin(superClass)
+  );
+
+  // Apply LegacyDataMixin to Templatizer instances as well, and defer
+  // runtime switch to the root's host (_methodHost)
+  Polymer.Templatize.mixin = 
+    Polymer.dedupingMixin(superClass => class extends Polymer.LegacyDataMixin(superClass) {
+      get _legacyUndefinedCheck() {
+        return this._methodHost && this._methodHost._legacyUndefinedCheck;
+      }
+    });
+
+  console.info('LegacyDataMixin will be applied to all legacy elements.\n' +
+               'Set `_legacyUndefinedCheck: true` to enable.');
+
+})();
+</script>

lib/mixins/element-mixin.html

@@ -132,7 +132,7 @@ subject to an additional IP rights grant found at http://polymer.github.io/PATEN
     }
 
     /**
-     * Returns a memoized version of the the `observers` array.
+     * Returns a memoized version of the `observers` array.
      * @param {PolymerElementConstructor} constructor Element class
      * @return {Array} Array containing own observers for the given class
      * @protected
@@ -156,7 +156,7 @@ subject to an additional IP rights grant found at http://polymer.github.io/PATEN
      * alter these settings. However, additional `observers` may be added
      * by subclasses.
      *
-     * The info object should may contain property metadata as follows:
+     * The info object should contain property metadata as follows:
      *
      * * `type`: {function} type to which an attribute matching the property
      * is deserialized. Note the property is camel-cased from a dash-cased
@@ -168,7 +168,7 @@ subject to an additional IP rights grant found at http://polymer.github.io/PATEN
      * property 'foo',
      *
      * * `computed`: {string} creates a computed property. A computed property
-     * also automatically is set to `readOnly: true`. The value is calculated
+     * is also automatically set to `readOnly: true`. The value is calculated
      * by running a method and arguments parsed from the given string. For
      * example 'compute(foo)' will compute a given property when the
      * 'foo' property changes by executing the 'compute' method. This method
@@ -288,6 +288,27 @@ subject to an additional IP rights grant found at http://polymer.github.io/PATEN
     }
 
     /**
+     * Look up template from dom-module for element
+     *
+     * @param {!string} is Element name to look up
+     * @return {!HTMLTemplateElement} Template found in dom module, or
+     *   undefined if not found
+     * @protected
+     */
+    function getTemplateFromDomModule(is) {
+      let template = null;
+      if (is && Polymer.DomModule) {
+        template = Polymer.DomModule.import(is, 'template');
+        // Under strictTemplatePolicy, require any element with an `is`
+        // specified to have a dom-module
+        if (Polymer.strictTemplatePolicy && !template) {
+          throw new Error(`strictTemplatePolicy: expecting dom-module or null template for ${is}`);
+        }
+      }
+      return template;
+    }
+
+  /**
      * @polymer
      * @mixinClass
      * @unrestricted
@@ -381,7 +402,7 @@ subject to an additional IP rights grant found at http://polymer.github.io/PATEN
        *   class MySubClass extends MySuperClass {
        *     static get template() {
        *       if (!memoizedTemplate) {
-       *         memoizedTemplate = super.template.cloneNode(true);
+       *         memoizedTemplate = MySuperClass.template.cloneNode(true);
        *         let subContent = document.createElement('div');
        *         subContent.textContent = 'This came from MySubClass';
        *         memoizedTemplate.content.appendChild(subContent);
@@ -393,17 +414,43 @@ subject to an additional IP rights grant found at http://polymer.github.io/PATEN
        * @return {HTMLTemplateElement|string} Template to be stamped
        */
       static get template() {
+        // Explanation of template-related properties:
+        // - constructor.template (this getter): the template for the class.
+        //     This can come from the prototype (for legacy elements), from a
+        //     dom-module, or from the super class's template (or can be overridden
+        //     altogether by the user)
+        // - constructor._template: memoized version of constructor.template
+        // - prototype._template: working template for the element, which will be
+        //     parsed and modified in place. It is a cloned version of
+        //     constructor.template, saved in _finalizeClass(). Note that before
+        //     this getter is called, for legacy elements this could be from a
+        //     _template field on the info object passed to Polymer(), a behavior,
+        //     or set in registered(); once the static getter runs, a clone of it
+        //     will overwrite it on the prototype as the working template.
         if (!this.hasOwnProperty(JSCompiler_renameProperty('_template', this))) {
-          this._template = Polymer.DomModule && Polymer.DomModule.import(
-            /** @type {PolymerElementConstructor}*/ (this).is, 'template') ||
-            // note: implemented so a subclass can retrieve the super
-            // template; call the super impl this way so that `this` points
-            // to the superclass.
-            Object.getPrototypeOf(/** @type {PolymerElementConstructor}*/ (this).prototype).constructor.template;
+          this._template =
+            // If user has put template on prototype (e.g. in legacy via registered
+            // callback or info object), prefer that first
+            this.prototype.hasOwnProperty(JSCompiler_renameProperty('_template', this.prototype)) ?
+            this.prototype._template :
+            // Look in dom-module associated with this element's is
+            (getTemplateFromDomModule(/** @type {PolymerElementConstructor}*/ (this).is) ||
+            // Next look for superclass template (call the super impl this
+            // way so that `this` points to the superclass)
+            Object.getPrototypeOf(/** @type {PolymerElementConstructor}*/ (this).prototype).constructor.template);
         }
         return this._template;
       }
 
+      /**
+       * Set the template.
+       *
+       * @param {!HTMLTemplateElement|string} value Template to set.
+       */
+      static set template(value) {
+        this._template = value;
+      }
+
       /**
        * Path matching the url from which the element was imported.
        *

lib/mixins/property-effects.html

@@ -814,7 +814,7 @@ subject to an additional IP rights grant found at http://polymer.github.io/PATEN
     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 @@ subject to an additional IP rights grant found at http://polymer.github.io/PATEN
     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
 
   /**
@@ -2181,6 +2131,56 @@ subject to an additional IP rights grant found at http://polymer.github.io/PATEN
         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 ------------
 
       /**

lib/utils/templatize.html

@@ -297,6 +297,10 @@ subject to an additional IP rights grant found at http://polymer.github.io/PATEN
       // Anonymous class created by the templatize
       let base = options.mutableData ?
         MutableTemplateInstanceBase : TemplateInstanceBase;
+      // Affordance for global mixins onto TemplatizeInstance
+      if (Polymer.Templatize.mixin) {
+        base = Polymer.Templatize.mixin(base);
+      }
       /**
        * @constructor
        * @extends {base}
@@ -509,6 +513,12 @@ subject to an additional IP rights grant found at http://polymer.github.io/PATEN
        * @suppress {invalidCasts}
        */
       templatize(template, owner, options) {
+        // Under strictTemplatePolicy, the templatized element must be owned
+        // by a (trusted) Polymer element, indicated by existence of _methodHost;
+        // e.g. for dom-if & dom-repeat in main document, _methodHost is null
+        if (Polymer.strictTemplatePolicy && !findMethodHost(template)) {
+          throw new Error('strictTemplatePolicy: template owner not trusted');
+        }
         options = /** @type {!TemplatizeOptions} */(options || {});
         if (template.__templatizeOwner) {
           throw new Error('A <template> can only be templatized once');