Closure warnings

externs/polymer-externs.js

@@ -3,15 +3,111 @@
  * @externs
  */
 
+/* eslint-disable */
+
+/**
+ * @typedef Object<string, {
+ *   value: *,
+ *   type: (Function | undefined),
+ *   readOnly: (boolean | undefined),
+ *   computed: (string | undefined),
+ *   reflectToAttribute: (boolean | undefined),
+ *   notify: (boolean | undefined),
+ *   observer: (string | undefined)
+ * }>)
+ */
+let PolymerElementProperties;
+
 /**
- * @param {!{is: string}} init
+ * @typedef {{
+ *   is: string,
+ *   extends: (string | undefined),
+ *   properties: (!PolymerElementProperties | undefined),
+ *   observers: (!Array<string> | undefined),
+ *   template: (!HTMLTemplateElement | string | undefined),
+ *   hostAttributes: (!Object<string, *> | undefined),
+ *   listeners: (!Object<string, string> | undefined)
+ * }}
+ */
+let PolymerInit;
+
+let PolymerElementConstructor = function () { };
+/** @type {(string | undefined)} */
+PolymerElementConstructor.is;
+/** @type {(string | undefined)} */
+PolymerElementConstructor.extends;
+/** @type {(!PolymerElementProperties | undefined)} */
+PolymerElementConstructor.properties;
+/** @type {(!Array<string> | undefined)} */
+PolymerElementConstructor.observers;
+/** @type {(!HTMLTemplateElement | string | undefined)} */
+PolymerElementConstructor.template;
+
+/**
+ * @param {!PolymerInit} init
  * @return {!HTMLElement}
  */
 function Polymer(init){}
 
+/**
+ * @type {(function(*,string,string,Node):*)|undefined}
+ */
+Polymer.sanitizeDOMValue;
+
 /**
  * @param {string} string
  * @param {Object} obj
  * @return {string}
  */
-function JSCompiler_renameProperty(string, obj) {}
+function JSCompiler_renameProperty(string, obj) {}
+
+/** @record */
+function PolymerTelemetry(){}
+/** @type {number} */
+PolymerTelemetry.prototype.instanceCount;
+/** @type {Array<HTMLElement>} */
+PolymerTelemetry.prototype.registrations;
+/** @type {function(HTMLElement)} */
+PolymerTelemetry.prototype._regLog;
+/** @type {function(HTMLElement)} */
+PolymerTelemetry.prototype.register;
+/** @type {function(HTMLElement)} */
+PolymerTelemetry.prototype.dumpRegistrations;
+
+/**
+ * @typedef {{
+ * name: (string | undefined),
+ * structured: (boolean | undefined),
+ * wildcard: (boolean | undefined)
+ * }}
+ */
+var DataTrigger;
+
+/**
+ * @typedef {{
+ * info: ?,
+ * trigger: (!DataTrigger | undefined),
+ * fn: (!Function | undefined)
+ * }}
+ */
+var DataEffect;
+
+/**
+ * @record
+ * @extends {Polymer_PropertyEffects}
+ */
+function PropertyEffectsInstance(){}
+/** @type {Object<string, !Array<!DataEffect>>} */
+PropertyEffectsInstance.prototype.__computeEffects;
+/** @type {Object<string, !Array<!DataEffect>>} */
+PropertyEffectsInstance.prototype.__reflectEffects;
+/** @type {Object<string, !Array<!DataEffect>>} */
+PropertyEffectsInstance.prototype.__notifyEffects;
+/** @type {Object<string, !Array<!DataEffect>>} */
+PropertyEffectsInstance.prototype.__propagateEffects;
+/** @type {Object<string, !Array<!DataEffect>>} */
+PropertyEffectsInstance.prototype.__observeEffects;
+/** @type {Object<string, !Array<!DataEffect>>} */
+PropertyEffectsInstance.prototype.__readOnly;
+/** @type {Object} */
+PropertyEffectsInstance.prototype.__data;

externs/webcomponents-externs.js

@@ -7,7 +7,12 @@ let HTMLImports = {
   /**
    * @param {function()} callback
    */
-  whenReady(callback){}
+  whenReady(callback){},
+  /**
+   * @param {Element} element
+   * @returns {Document} document
+   */
+  importForElement(element){}
 };
 
 window.HTMLImports = HTMLImports;
@@ -42,4 +47,9 @@ HTMLElement.prototype._activeElement;
 /**
  * @param {HTMLTemplateElement} template
  */
-HTMLTemplateElement.prototype.decorate = function(template){};
+HTMLTemplateElement.decorate = function(template){};
+
+/**
+ * @param {function(function())} cb callback
+ */
+CustomElementRegistry.prototype.polyfillWrapFlushCallback = function(cb){};

gulpfile.js

@@ -100,20 +100,13 @@ gulp.task('closure', ['clean'], () => {
 
   let entry, splitRx, joinRx;
 
-  function full() {
-    entry = 'polymer.html';
-    splitRx = /polymer\.html_script_\d+\.js$/;
-    joinRx = /polymer\.html/;
+  function config(path) {
+    entry = path;
+    joinRx = new RegExp(path.split('/').join('\\/'));
+    splitRx = new RegExp(joinRx.source + '_script_\\d+\\.js$');
   }
 
-  function element() {
-    entry = 'polymer-element.html';
-    splitRx = /polymer-element\.html_script_\d+\.js$/;
-    joinRx = /polymer-element\.html/;
-  }
-
-  // element();
-  full();
+  config('polymer.html');
 
   const project = new PolymerProject({
     shell: `./${entry}`,
@@ -148,16 +141,16 @@ gulp.task('closure', ['clean'], () => {
     language_in: 'ES6_STRICT',
     language_out: 'ES5_STRICT',
     warning_level: 'VERBOSE',
-    output_wrapper: '(function(){\n%output%\n}).call(self);',
+    isolation_mode: 'IIFE',
     assume_function_wrapper: true,
     rewrite_polyfills: false,
     new_type_inf: true,
     checks_only: CLOSURE_LINT_ONLY,
     externs: [
       'bower_components/shadycss/externs/shadycss-externs.js',
       'externs/webcomponents-externs.js',
-      'externs/polymer-externs.js',
       'externs/closure-types.js',
+      'externs/polymer-externs.js',
     ],
     extra_annotation_name: [
       'polymerMixin',
@@ -199,7 +192,7 @@ gulp.task('lint-closure', (done) => {
 gulp.task('estimate-size', ['clean'], () => {
 
   const babelPresets = {
-    presets: [['babili', {regexpConstructors: false}]]
+    presets: [['babili', {regexpConstructors: false, simplifyComparisons: false}]]
   };
 
   const project = new PolymerProject({
@@ -242,3 +235,10 @@ gulp.task('lint', function() {
     .pipe(eslint.format())
     .pipe(eslint.failAfterError());
 });
+
+gulp.task('generate-closure-externs', ['clean'], () => {
+  let genClosure = require('@polymer/gen-closure-declarations').generateDeclarations;
+  return genClosure().then((declarations) => {
+    fs.writeFileSync('externs/closure-types.js', declarations);
+  });
+});

lib/elements/array-selector.html

@@ -8,7 +8,7 @@
 subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
 -->
 
-<link rel="import" href="../../polymer-element.html">
+<link rel="import" href="../mixins/property-effects.html">
 <link rel="import" href="../utils/mixin.html">
 <link rel="import" href="../utils/array-splice.html">
 
@@ -17,7 +17,7 @@
   'use strict';
 
   /**
-   * Element mixin for recording  dynamic associations between item paths in a
+   * Element mixin for recording dynamic associations between item paths in a
    * master `items` array and a `selected` array such that path changes to the
    * master array (at the host) element or elsewhere via data-binding) are
    * correctly propagated to items in the selected array and vice-versa.
@@ -31,15 +31,26 @@
    * is an array of multiply selected items.
    *
    * @polymerMixin
+   * @mixes Polymer.PropertyEffects
    * @memberof Polymer
+   * @summary Element mixin for recording dynamic associations between item paths in a
+   * master `items` array and a `selected` array
    */
   let ArraySelectorMixin = Polymer.dedupingMixin(superClass => {
 
+    /**
+     * @constructor
+     * @extends {superClass}
+     * @implements {Polymer_PropertyEffects}
+     */
+    let propertyEffectsBase = Polymer.PropertyEffects(superClass);
+
     /**
      * @polymerMixinClass
      * @implements {Polymer_ArraySelectorMixin}
+     * @unrestricted
      */
-    class ArraySelectorMixin extends superClass {
+    class ArraySelectorMixin extends propertyEffectsBase {
 
       static get properties() {
 
@@ -391,7 +402,6 @@
    * ```
    *
    * @polymerElement
-   * @extends Polymer.Element
    * @mixes Polymer.ArraySelectorMixin
    * @memberof Polymer
    * @summary Custom element that links paths between an input `items` array and

lib/elements/custom-style.html

@@ -53,9 +53,9 @@
       if (this._style) {
         return this._style;
       }
-      const style = this.querySelector('style');
+      const style = /** @type {HTMLStyleElement} */(this.querySelector('style'));
       if (!style) {
-        return;
+        return null;
       }
       this._style = style;
       const include = style.getAttribute(attr);

lib/elements/dom-bind.html

@@ -20,10 +20,10 @@
 
     /**
      * @constructor
+     * @extends {HTMLElement}
      * @implements {Polymer_PropertyEffects}
      * @implements {Polymer_OptionalMutableData}
-     * @implements {Polymer_GestureEventListener}
-     * @extends {HTMLElement}
+     * @implements {Polymer_GestureEventListeners}
      */
     const domBindBase =
       Polymer.GestureEventListeners(
@@ -40,8 +40,9 @@
      * document and bind elements to the `dom-bind` element itself as the
      * binding scope.
      *
-     * @extends HTMLElement
      * @mixes Polymer.PropertyEffects
+     * @mixes Polymer.OptionalMutableData
+     * @mixes Polymer.GestureEventListeners
      * @memberof Polymer
      * @summary Custom element to allow using Polymer's template features (data
      *   binding, declarative event listeners, etc.) in the main document.
@@ -50,6 +51,13 @@
 
       static get observedAttributes() { return ['mutable-data'] }
 
+      constructor() {
+        super();
+        this.root = null;
+        this.$ = null;
+        this.__children = null;
+      }
+
       // assumes only one observed attribute
       attributeChangedCallback() {
         this.mutableData = true;
@@ -78,18 +86,19 @@
       /**
        * Forces the element to render its content. This is typically only
        * necessary to call if HTMLImports with the async attribute are used.
+       * @suppress {missingProperties}
        */
       render() {
         let template;
         if (!this.__children) {
-          template = template || this.querySelector('template');
+          template = /** @type {HTMLTemplateElement} */(template || this.querySelector('template'));
           if (!template) {
             // Wait until childList changes and template should be there by then
             let observer = new MutationObserver(() => {
-              template = this.querySelector('template');
+              template = /** @type {HTMLTemplateElement} */(this.querySelector('template'));
               if (template) {
                 observer.disconnect();
-                this.render(template);
+                this.render();
               } else {
                 throw new Error('dom-bind requires a <template> child');
               }

lib/elements/dom-if.html

@@ -88,6 +88,8 @@
       this.__renderDebouncer = null;
       this.__invalidProps = null;
       this.__instance = null;
+      this._lastIf = false;
+      this.__ctor = null;
     }
 
     __debounceRender() {
@@ -186,6 +188,11 @@
             // dom-if templatizer instances require `mutable: true`, as
             // `__syncHostProperties` relies on that behavior to sync objects
             mutableData: true,
+            /**
+             * @param {string} prop Property to forward
+             * @param {*} value Value of property
+             * @this {this}
+             */
             forwardHostProp: function(prop, value) {
               if (this.__instance) {
                 if (this.if) {
@@ -222,6 +229,7 @@
       return true;
     }
 
+    /** @suppress {missingProperties} */
     __syncHostProperties() {
       let props = this.__invalidProps;
       if (props) {

lib/elements/dom-module.html

@@ -48,6 +48,7 @@
    * @memberof Polymer
    * @summary Custom element that provides a registry of relocatable DOM content
    *   by `id` that is agnostic to bundling.
+   * @unrestricted
    */
   class DomModule extends HTMLElement {