Support translating foo! expressions into type asserts.

Author: mprobst

src/tsickle.ts

@@ -310,12 +310,12 @@ class ClosureRewriter extends Rewriter {
   }
 
   /** Emits a type annotation in JSDoc, or {?} if the type is unavailable. */
-  emitJSDocType(node: ts.Node, additionalDocTag?: string) {
+  emitJSDocType(node: ts.Node, additionalDocTag?: string, type?: ts.Type) {
     this.emit(' /**');
     if (additionalDocTag) {
       this.emit(' ' + additionalDocTag);
     }
-    this.emit(` @type {${this.typeToClosure(node)}} */`);
+    this.emit(` @type {${this.typeToClosure(node, type)}} */`);
   }
 
   /**
@@ -532,10 +532,30 @@ class Annotator extends ClosureRewriter {
         // When TypeScript emits JS, it removes one layer of "redundant"
         // parens, but we need them for the Closure type assertion.  Work
         // around this by using two parens.  See test_files/coerce.*.
+        // TODO: the comment is currently dropped from pure assignments due to
+        //   https://github.com/Microsoft/TypeScript/issues/9873
         this.emit('((');
         this.writeNode(node);
         this.emit('))');
         return true;
+      case ts.SyntaxKind.NonNullExpression:
+        const nnexpr = node as ts.NonNullExpression;
+        let type = this.program.getTypeChecker().getTypeAtLocation(nnexpr.expression);
+        if (type.flags & ts.TypeFlags.Union) {
+          const nonNullUnion =
+              (type as ts.UnionType)
+                  .types.filter(
+                      t => (t.flags & (ts.TypeFlags.Null | ts.TypeFlags.Undefined)) === 0);
+          const typeCopy = Object.assign({}, type as ts.UnionType);
+          typeCopy.types = nonNullUnion;
+          type = typeCopy;
+        }
+        this.emitJSDocType(nnexpr, undefined, type);
+        // See comment above.
+        this.emit('((');
+        this.writeNode(nnexpr.expression);
+        this.emit('))');
+        return true;
       default:
         break;
     }

src/type-translator.ts

@@ -272,7 +272,7 @@ export class TypeTranslator {
       return '?';
     } else if (type.flags & ts.TypeFlags.Union) {
       let unionType = type as ts.UnionType;
-      let parts = unionType.types.map(t => this.translate(t, notNull));
+      let parts = unionType.types.map(t => this.translate(t, true));
       // In union types that include boolean literal and other literals can
       // end up repeating the same closure type. For example: true | boolean
       // will be translated to boolean | boolean. Remove duplicates to produce

test_files/jsx/jsx.js

@@ -4,4 +4,4 @@ let /** @type {!JSX.Element} */ helloDiv = React.createElement("div", null,
     hello, 
     "hello, world", 
     React.createElement(Component, null));
-React.render(helloDiv, document.body);
+React.render(helloDiv, /** @type {!HTMLElement} */ ((document.body)));

test_files/jsx/jsx.tsickle.tsx

@@ -26,5 +26,5 @@ let /** @type {!JSX.Element} */ helloDiv = <div>
   <Component/>
 </div>;
 
-React.render(helloDiv, document.body!);
+React.render(helloDiv, /** @type {!HTMLElement} */(( document.body)));
 

test_files/nullable/nullable.js

@@ -26,3 +26,10 @@ function NonPrimitives_tsickle_Closure_declarations() {
     /** @type {(undefined|!NonPrimitive)} */
     NonPrimitives.prototype.optional;
 }
+/**
+ * @param {(string|number)} val
+ * @return {void}
+ */
+function takesNonNullable(val) { }
+let /** @type {{field: (null|string|number)}} */ x = { field: null };
+takesNonNullable(/** @type {(string|number)} */ ((x.field)));

test_files/nullable/nullable.ts

@@ -15,3 +15,8 @@ class NonPrimitives {
   nullableUndefinable: NonPrimitive|null|undefined;
   optional?: NonPrimitive;
 }
+
+function takesNonNullable(val: string|number) {}
+
+let x: {field: string | null | number} = {field: null};
+takesNonNullable(x.field!);

test_files/nullable/nullable.tsickle.ts

@@ -41,3 +41,11 @@ NonPrimitives.prototype.nullableUndefinable;
 NonPrimitives.prototype.optional;
 }
 
+/**
+ * @param {(string|number)} val
+ * @return {void}
+ */
+function takesNonNullable(val: string|number) {}
+
+let /** @type {{field: (null|string|number)}} */ x: {field: string | null | number} = {field: null};
+takesNonNullable( /** @type {(string|number)} */((x.field)));