Tsickle emits bound `this` generics which trigger jscompiler whitelist conformance checks

m getting a conformance check error with a generic this value:

/**
 * d3 inverts the `this` ownership. buildD3Handler reverts that, so that the
 * passed method is called in the original context with the d3 value as the
 * input.
 */
export function
buildD3Handler<ContextT, SVGEltT extends SVGElement, BoundObjT extends
                   BoundD3T, HandlerRetT>(
    context: ContextT,
    targetMethod: (svgElt: SVGEltT, boundObj: BoundObjT) => HandlerRetT,
    ): d3.ValueFn<SVGEltT, BoundObjT, HandlerRetT> {
  return function(this: SVGEltT, node: BoundObjT) {
    // Here 'this' is a reference to the D3 DOM Node 
    return targetMethod.call(context, this, node);
  };
}

As far as I can tell, this is sensible:

/**                                                                              
 * d3 inverts the `this` ownership. buildD3Handler reverts that, so that the        
 * passed method is called in the original context with the d3 value as the         
 * input.                                                                        
 * @template ContextT, SVGEltT, BoundObjT, HandlerRetT                           
 * @param {ContextT} context                                                     
 * @param {function(SVGEltT, BoundObjT): HandlerRetT} targetMethod               
 * @return {?}                                                                   
 */                                                                              
function buildD3Handler(context, targetMethod) {                                 
    return (/**                                                                  
     * @this {SVGEltT}                                                                                                                                                                                                                                        
     * @param {BoundObjT} node                                                   
     * @return {?}                                                               
     */                                                                          
    function (node) {                                                            
        // Here 'this' is not a reference to TopologyGraphComponent object.         
        return targetMethod.call(context, this, node);                           
    });                                                                          
}

But I am getting:

ERROR - Violation: References to "this" that are typed as "unknown" are not allowed. See https://github.com/google/closure-compiler/wiki/Conformance:-Unknown-type-of-%E2%80%9Cthis%E2%80%9D

[rictic]

I ran into this recently. Adding an explicit cast (e.g. this as SVGEltT}) seems to fix it.

If tsickle automatically emitted the type assertion, both on static methods (because of https://github.com/google/closure-compiler/issues/3340) and when a function has an explicit this type it would do wonders for code legibility.

[evmar]

If I followed the bug, this isn’t even about generic bounds really. It’s that code like

/**
 * @template T
 */
function f() {
  /** @this {T} */
  function f2() {}
}

fails because you can’t use a templated type in a this clause. So the generic bounds thing doesn’t even help.