Emit additional parenthesis for casts in template expressions

This is required by closure ES6 to not produce an error.

Note: In the current version of tsickle, type comments
in interpolations are elided because of #411. In the upcoming
transformer version, this is fixed though.

Author: tbosch

src/tsickle.ts

@@ -525,6 +525,8 @@ class Annotator extends ClosureRewriter {
   private generatedExports = new Set<string>();
   /** DecoratorClassVisitor when lowering decorators while closure annotating */
   private currentDecoratorConverter: DecoratorClassVisitor|undefined;
+
+  private templateSpanStackCount = 0;
   private polymerBehaviorStackCount = 0;
 
   constructor(
@@ -719,10 +721,21 @@ class Annotator extends ClosureRewriter {
         return true;
       case ts.SyntaxKind.EnumDeclaration:
         return this.maybeProcessEnum(node as ts.EnumDeclaration);
+      case ts.SyntaxKind.TemplateSpan:
+        this.templateSpanStackCount++;
+        this.writeNode(node);
+        this.templateSpanStackCount--;
+        return true;
       case ts.SyntaxKind.TypeAssertionExpression:
       case ts.SyntaxKind.AsExpression:
         // Both of these cases are AssertionExpressions.
         const typeAssertion = node as ts.AssertionExpression;
+        // 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."
+        if (this.templateSpanStackCount > 0) {
+          this.emit('(');
+        }
         this.emitJSDocType(typeAssertion);
         // When TypeScript emits JS, it removes one layer of "redundant"
         // parens, but we need them for the Closure type assertion.  Work
@@ -732,6 +745,9 @@ class Annotator extends ClosureRewriter {
         this.emit('((');
         this.writeNode(node);
         this.emit('))');
+        if (this.templateSpanStackCount > 0) {
+          this.emit(')');
+        }
         return true;
       case ts.SyntaxKind.NonNullExpression:
         const nnexpr = node as ts.NonNullExpression;
@@ -745,11 +761,18 @@ class Annotator extends ClosureRewriter {
           typeCopy.types = nonNullUnion;
           type = typeCopy;
         }
+        // See comment above.
+        if (this.templateSpanStackCount > 0) {
+          this.emit('(');
+        }
         this.emitJSDocType(nnexpr, undefined, type);
         // See comment above.
         this.emit('((');
         this.writeNode(nnexpr.expression);
         this.emit('))');
+        if (this.templateSpanStackCount > 0) {
+          this.emit(')');
+        }
         return true;
       case ts.SyntaxKind.PropertyDeclaration:
       case ts.SyntaxKind.VariableStatement:

test_files/coerce/coerce.js

@@ -9,3 +9,4 @@ goog.module('test_files.coerce.coerce');var module = module || {id: 'test_files/
 function acceptString(arg) { return arg; }
 acceptString(/** @type {?} */ (3));
 acceptString(/** @type {?} */ (3));
+acceptString(`${((3))}`);

test_files/coerce/coerce.ts

@@ -1,3 +1,4 @@
 function acceptString(arg: string): string { return arg; }
 acceptString(<any>3);
-acceptString(3 as any);
+acceptString(3 as any);
+acceptString(`${3 as any}`);

test_files/coerce/coerce.tsickle.ts

@@ -10,4 +10,5 @@
  */
 function acceptString(arg: string): string { return arg; }
 acceptString( /** @type {?} */((<any>3)));
-acceptString( /** @type {?} */((3 as any)));
+acceptString( /** @type {?} */((3 as any)));
+acceptString(`${( /** @type {?} */((3 as any)))}`);

test_files/nullable/nullable.js

@@ -37,3 +37,6 @@ function NonPrimitives_tsickle_Closure_declarations() {
 function takesNonNullable(val) { }
 let /** @type {{field: (null|string|number)}} */ x = { field: null };
 takesNonNullable(/** @type {(string|number)} */ ((x.field)));
+takesNonNullable(`${(((x.field)))}`);
+let /** @type {?} */ ctx;
+takesNonNullable(`org/${(((ctx.getTargetOrganization()))).key}/admin/folders`);

test_files/nullable/nullable.ts

@@ -20,3 +20,6 @@ function takesNonNullable(val: string|number) {}
 
 let x: {field: string | null | number} = {field: null};
 takesNonNullable(x.field!);
+takesNonNullable(`${x.field!}`);
+let ctx: any;
+takesNonNullable(`org/${ctx.getTargetOrganization()!.key}/admin/folders`);

test_files/nullable/nullable.tsickle.ts

@@ -52,3 +52,6 @@ function takesNonNullable(val: string|number) {}
 
 let /** @type {{field: (null|string|number)}} */ x: {field: string | null | number} = {field: null};
 takesNonNullable( /** @type {(string|number)} */((x.field)));
+takesNonNullable(`${( /** @type {(string|number)} */((x.field)))}`);
+let /** @type {?} */ ctx: any;
+takesNonNullable(`org/${( /** @type {?} */((ctx.getTargetOrganization()))).key}/admin/folders`);