Get Polymer compiling clean under closure recommended flags

externs/polymer-externs.js

@@ -48,6 +48,7 @@ PolymerInit.prototype.hostAttributes;
 /** @type {(!Object<string, string> | undefined)} */
 PolymerInit.prototype.listeners;
 
+/** @record */
 let PolymerElementConstructor = function () {};
 /** @type {(string | undefined)} */
 PolymerElementConstructor.is;
@@ -78,6 +79,26 @@ function Polymer(init){}
  */
 Polymer.sanitizeDOMValue;
 
+/**
+ * @type {boolean}
+ */
+Polymer.passiveTouchGestures;
+
+/**
+ * @type {boolean}
+ */
+Polymer.strictTemplatePolicy;
+
+/**
+ * @type {boolean}
+ */
+Polymer.allowTemplateFromDomModule;
+
+/**
+ * @type {string}
+ */
+Polymer.rootPath;
+
 /**
  * @param {string} string
  * @param {Object} obj
@@ -174,7 +195,7 @@ var PolymerDeepPropertyChange;
  * @constructor
  * @template T
  */
-let DomRepeatEvent = function() {};
+var DomRepeatEvent = function() {};
 
 /**
  * @type {{

externs/webcomponents-externs.js

@@ -12,23 +12,37 @@
  */
 /* eslint-disable */
 
-let ShadyDOM = {
+var HTMLImports = {
+  /**
+   * @param {function()} callback
+   */
+  whenReady(callback) {},
+  /**
+   * @param {Element} element
+   * @returns {Document} document
+   */
+  importForElement(element) {}
+};
+
+window.HTMLImports = HTMLImports;
+
+var ShadyDOM = {
   inUse: false,
-  flush(){},
+  flush() {},
   /**
    * @param {!Node} target
    * @param {function(Array<MutationRecord>, MutationObserver)} callback
    * @return {MutationObserver}
    */
-  observeChildren(target, callback){},
+  observeChildren(target, callback) {},
   /**
    * @param {MutationObserver} observer
    */
-  unobserveChildren(observer){},
+  unobserveChildren(observer) {},
   /**
    * @param {Node} node
    */
-  patch(node){}
+  patch(node) {}
 };
 
 window.ShadyDOM = ShadyDOM;

gen-tsd.json

@@ -7,6 +7,9 @@
     "util/**",
     "index.html"
   ],
+  "excludeIdentifiers": [
+    "templatizedBase"
+  ],
   "removeReferences": [
     "../shadycss/apply-shim.d.ts",
     "../shadycss/custom-style-interface.d.ts"
@@ -32,7 +35,8 @@
       "Binding",
       "AsyncInterface",
       "GestureRecognizer",
-      "IdleDeadline"
+      "IdleDeadline",
+      "PolymerElementConstructor"
     ],
     "./lib/utils/debounce.js": [
       "Debouncer"

interfaces.d.ts

@@ -191,3 +191,12 @@ export interface IdleDeadline {
   didTimeout: boolean;
   timeRemaining(): number;
 }
+
+export interface PolymerElementConstructor {
+  new (): HTMLElement;
+  is?: string;
+  extends?: string;
+  properties?: PolymerElementProperties;
+  observers?: string[];
+  template?: string|HTMLTemplateElement|null;
+}

lib/elements/array-selector.js

@@ -37,7 +37,6 @@ let ArraySelectorMixin = dedupingMixin(superClass => {
 
   /**
    * @constructor
-   * @extends {superClass}
    * @implements {Polymer_ElementMixin}
    * @private
    */
@@ -52,7 +51,6 @@ let ArraySelectorMixin = dedupingMixin(superClass => {
   class ArraySelectorMixin extends elementBase {
 
     static get properties() {
-
       return {
 
         /**
@@ -76,31 +74,22 @@ let ArraySelectorMixin = dedupingMixin(superClass => {
          * When `multi` is true, this is an array that contains any selected.
          * When `multi` is false, this is the currently selected item, or `null`
          * if no item is selected.
-         * @type {?(Object|Array<!Object>)}
+         * @type {?Object|?Array<!Object>}
          */
-        selected: {
-          type: Object,
-          notify: true
-        },
+        selected: {type: Object, notify: true},
 
         /**
          * When `multi` is false, this is the currently selected item, or `null`
          * if no item is selected.
          * @type {?Object}
          */
-        selectedItem: {
-          type: Object,
-          notify: true
-        },
+        selectedItem: {type: Object, notify: true},
 
         /**
          * When `true`, calling `select` on an item that is already selected
          * will deselect the item.
          */
-        toggle: {
-          type: Boolean,
-          value: false
-        }
+        toggle: {type: Boolean, value: false}
 
       };
     }
@@ -208,6 +197,7 @@ let ArraySelectorMixin = dedupingMixin(superClass => {
 
     /**
      * Clears the selection state.
+     * @override
      * @return {void}
      */
     clearSelection() {
@@ -226,6 +216,7 @@ let ArraySelectorMixin = dedupingMixin(superClass => {
     /**
      * Returns whether the item is currently selected.
      *
+     * @override
      * @param {*} item Item from `items` array to test
      * @return {boolean} Whether the item is selected
      */
@@ -236,6 +227,7 @@ let ArraySelectorMixin = dedupingMixin(superClass => {
     /**
      * Returns whether the item is currently selected.
      *
+     * @override
      * @param {number} idx Index from `items` array to test
      * @return {boolean} Whether the item is selected
      */
@@ -265,6 +257,7 @@ let ArraySelectorMixin = dedupingMixin(superClass => {
     /**
      * Deselects the given item if it is already selected.
      *
+     * @override
      * @param {*} item Item from `items` array to deselect
      * @return {void}
      */
@@ -288,6 +281,7 @@ let ArraySelectorMixin = dedupingMixin(superClass => {
     /**
      * Deselects the given index if it is already selected.
      *
+     * @override
      * @param {number} idx Index from `items` array to deselect
      * @return {void}
      */
@@ -299,6 +293,7 @@ let ArraySelectorMixin = dedupingMixin(superClass => {
      * Selects the given item.  When `toggle` is true, this will automatically
      * deselect the item if already selected.
      *
+     * @override
      * @param {*} item Item from `items` array to select
      * @return {void}
      */
@@ -310,6 +305,7 @@ let ArraySelectorMixin = dedupingMixin(superClass => {
      * Selects the given index.  When `toggle` is true, this will automatically
      * deselect the item if already selected.
      *
+     * @override
      * @param {number} idx Index from `items` array to select
      * @return {void}
      */

lib/legacy/legacy-data-mixin.js

@@ -28,10 +28,10 @@ const UndefinedArgumentError = class extends Error {
 
 /**
  * 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
+ * @return {?Object|undefined} Effect metadata object
  */
 function wrapEffect(effect, fnName) {
   if (effect && effect.fn) {
@@ -41,7 +41,7 @@ function wrapEffect(effect, fnName) {
         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.`);
+          console.warn(`Argument '${e.arg}'${fnName ?` for method '${fnName}'` : ''} was undefined. Ensure it has a default value, or else ensure the method handles the argument being undefined.`);
         } else {
           throw e;
         }
@@ -55,11 +55,11 @@ function wrapEffect(effect, fnName) {
  * 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
@@ -73,15 +73,14 @@ function wrapEffect(effect, fnName) {
 export const LegacyDataMixin = dedupingMixin(superClass => {
 
   /**
-   * @constructor
-   * @extends {superClass}
    * @unrestricted
-   * @private   */
+   * @private
+   */
   class LegacyDataMixin extends superClass {
     /**
      * Overrides `Polymer.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
@@ -99,7 +98,7 @@ export const LegacyDataMixin = dedupingMixin(superClass => {
             // 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);
+            throw new UndefinedArgumentError(`Argument '${name}' is undefined.`, name);
           }
         }
       }
@@ -109,7 +108,7 @@ export const LegacyDataMixin = dedupingMixin(superClass => {
     /**
      * 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
@@ -144,9 +143,9 @@ export const LegacyDataMixin = dedupingMixin(superClass => {
 // LegacyDataMixin is applied to base class _before_ metaprogramming, to
 // ensure override of _addPropertyEffect et.al. are used by metaprogramming
 // performed in _finalizeClass
-Polymer.Class = (info, mixin) => Class(info, 
-  superClass => mixin ? 
-    mixin(LegacyDataMixin(superClass)) : 
+Polymer.Class = (info, mixin) => Class(info,
+  superClass => mixin ?
+    mixin(LegacyDataMixin(superClass)) :
     LegacyDataMixin(superClass)
 );