Don’t emit closure type casts for Polymer behaviors

when using a call expression.

E.g.
```
Polymer({behaviors: [(Polymer as any).NeonAnimationRunnerBehavior])
```

This type cast was never emitted in non transformer mode due to
microsoft/TypeScript#9873.

This is a temporary workaround, the real fix is to change
the Polymer Closure plugin (see #529).

Author: tbosch

src/tsickle.ts

@@ -785,6 +785,17 @@ class Annotator extends ClosureRewriter {
       case ts.SyntaxKind.AsExpression:
         // Both of these cases are AssertionExpressions.
         const typeAssertion = node as ts.AssertionExpression;
+        if (this.polymerBehaviorStackCount > 0) {
+          // Don't emit type casts for Polymer behaviors that are declared
+          // by calling the Polymer function
+          // as the Polymer closure plugin does not work when emitting them.
+          // Note: This only matters in the transformer version of tsickle,
+          // as the non transformer version never emitted type casts due to
+          // https://github.com/Microsoft/TypeScript/issues/9873 (see below).
+          // TODO(tbosch): file an issue with Polymer, tracked in
+          // https://github.com/angular/tsickle/issues/529.
+          return false;
+        }
         // When using a type casts in template expressions,
         // closure requires another pair of parens, otherwise it will
         // complain with "Misplaced type annotation. Type annotations are not allowed here."
@@ -852,6 +863,15 @@ class Annotator extends ClosureRewriter {
           return true;
         }
         break;
+      case ts.SyntaxKind.PropertyAssignment:
+        const pa = node as ts.PropertyAssignment;
+        if (isPolymerBehaviorPropertyInCallExpression(pa)) {
+          this.polymerBehaviorStackCount++;
+          this.writeNodeFrom(node, node.getStart());
+          this.polymerBehaviorStackCount--;
+          return true;
+        }
+        return false;
       case ts.SyntaxKind.ElementAccessExpression:
         // Warn for quoted accesses to properties that have a symbol declared.
         // Mixing quoted and non-quoted access to a symbol (x['foo'] and x.foo) risks breaking
@@ -1870,6 +1890,18 @@ class ExternsWriter extends ClosureRewriter {
   }
 }
 
+function isPolymerBehaviorPropertyInCallExpression(pa: ts.PropertyAssignment): boolean {
+  const parentParent = pa.parent && pa.parent.parent;
+  if (pa.name.kind !== ts.SyntaxKind.Identifier ||
+      (pa.name as ts.Identifier).text !== 'behaviors' || !pa.parent || !pa.parent.parent ||
+      pa.parent.parent.kind !== ts.SyntaxKind.CallExpression) {
+    return false;
+  }
+
+  const expr = (parentParent as ts.CallExpression).expression;
+  return expr.kind === ts.SyntaxKind.Identifier && (expr as ts.Identifier).text === 'Polymer';
+}
+
 export function annotate(
     typeChecker: ts.TypeChecker, file: ts.SourceFile, host: AnnotatorHost,
     options: AnnotatorOptions = {}, tsHost?: ts.ModuleResolutionHost, tsOpts?: ts.CompilerOptions,

test_files/jsdoc/jsdoc.js

@@ -126,3 +126,9 @@ const /** @type {string} */ c = 'c';
  * @polymerBehavior
  */
 const somePolymerBehavior = {};
+/**
+ * Don't emit type comments for Polymer behaviors
+ * if they are declared via the Polymer function.
+ */
+let /** @type {?} */ Polymer;
+Polymer({ behaviors: ['test'] });

test_files/jsdoc/jsdoc.ts

@@ -109,3 +109,10 @@ const c = 'c';
  * @polymerBehavior
  */
 const somePolymerBehavior = {};
+
+/**
+ * Don't emit type comments for Polymer behaviors
+ * if they are declared via the Polymer function.
+ */
+let Polymer: any;
+Polymer({ behaviors: [ 'test' as any ] });

test_files/jsdoc/jsdoc.tsickle.ts

@@ -162,3 +162,9 @@ const /** @type {string} */ c = 'c';
  * @polymerBehavior
  */
 const somePolymerBehavior = {};
+/**
+ * Don't emit type comments for Polymer behaviors
+ * if they are declared via the Polymer function.
+ */
+let /** @type {?} */ Polymer: any;
+Polymer({behaviors: [ 'test' as any ] });