Generics (templates) are lost in type annotations within methods

Running this command - java -jar ../build/binaries/closure-compiler-v20180716.jar --js trial.js --language_in ECMASCRIPT_NEXT -O ADVANCED_OPTIMIZATIONS --jscomp_warning '*' --warning_level VERBOSE --js_output_file trial.min.js

With this trial.js -

/** @template T*/
class Helpers
{
  /** @param {T} value
      @return {!Promise<!Array<T>>} */
  getValueAsArray(value)
  {
   return new Promise(
           (resolve, reject) =>
           {
            /** @type {!Array<T>} */
            const objects = [value];
            resolve(objects);
           });
  }
}

/** @type {!Helpers<string>} */
const helpers = new Helpers();
helpers.getValueAsArray("hey").then(array => console.log(array));

Outputs -

trial.js:11: WARNING - Bad type annotation. Unknown type T
            /** @type {!Array<T>} */
                              ^

0 error(s), 1 warning(s), 92.0% typed

I realize the example looks weird. The actual scenario is that the value is not supplied in a parameter, but brought from IndexedDB -

/** @template T*/
class Store
{
  /** @return {!Promise<!Array<T>>} */
  getObjects()
  {
   return new Promise(
           (resolve, reject) =>
           {
            /** @type {!Array<T>} */
            const objects = [];
            // Asynchronously get the stuff from IndexedDB
            resolve(objects);
           });
  }
}

/** @type {!Store<string>} */
const store = new Store();
store.getObjects().then(array => console.log(array));

trial.js:10: WARNING - Bad type annotation. Unknown type T
            /** @type {!Array<T>} */
                              ^

0 error(s), 1 warning(s), 92.1% typed

[blickly]

I’m pretty sure that @concavelenz is working on an improvement to the typechecking that allows referring to template parameters inside the body of templated functions.

[ChadKillingsworth]

If you are looking for mixin support, I strongly recommend you use ES6 class mixin functions: http://justinfagnani.com/2015/12/21/real-mixins-with-javascript-classes/

Supporting them in the compiler is a little bit interesting. You have to define an interface and mark the mixed constructor as implementing it:

function MixedInterface() {}
/** @type {function(boolean):boolean} */ MixedInterface.prototype.foo;

/** @param {function(new:HTMLElement)} Superclass */
function mixFoo(Superclass) {
  /** @implements {MixedInterface} */
  class Foo extends Superclass {
    foo(test) { return test; }
  }
  return Foo;
}

/**
 * @constructor
 * @extends {HTMLElement}
 * @implements {MixedInterface}
 */
const FooElement = mixFoo(HTMLElement);

This is supported by the compiler and type safe. One note - in ADVANCED mode the MixedInterface must be complete. It must contain all properties added to the prototype (even private ones).