Adds transforms for NonNullExpression

src/compiler/binder.ts

@@ -1883,6 +1883,7 @@ namespace ts {
             case SyntaxKind.EnumMember:
             case SyntaxKind.TypeAssertionExpression:
             case SyntaxKind.AsExpression:
+            case SyntaxKind.NonNullExpression:
             case SyntaxKind.ReadonlyKeyword:
                 // These nodes are TypeScript syntax.
                 transformFlags = TransformFlags.AssertTypeScript;

src/compiler/printer.ts

@@ -751,6 +751,8 @@ const _super = (function (geti, seti) {
                         return;
                     case SyntaxKind.AsExpression:
                         return emitAsExpression(<AsExpression>node);
+                    case SyntaxKind.NonNullExpression:
+                        return emitNonNullExpression(<NonNullExpression>node);
 
                     // JSX
                     case SyntaxKind.JsxElement:
@@ -1286,6 +1288,11 @@ const _super = (function (geti, seti) {
                 }
             }
 
+            function emitNonNullExpression(node: NonNullExpression) {
+                emitExpression(node.expression);
+                write("!");
+            }
+
             //
             // Misc
             //

src/compiler/transformers/ts.ts

@@ -371,6 +371,10 @@ namespace ts {
                     // TypeScript type assertions are removed, but their subtrees are preserved.
                     return visitAssertionExpression(<AssertionExpression>node);
 
+                case SyntaxKind.NonNullExpression:
+                    // TypeScript non-null expressions are removed, but their subtrees are preserved.
+                    return visitNonNullExpression(<NonNullExpression>node);
+
                 case SyntaxKind.EnumDeclaration:
                     // TypeScript enum declarations do not exist in ES6 and must be rewritten.
                     return visitEnumDeclaration(<EnumDeclaration>node);
@@ -2228,7 +2232,12 @@ namespace ts {
         }
 
         function visitAssertionExpression(node: AssertionExpression): Expression {
-            const expression = visitNode((<TypeAssertion | AsExpression>node).expression, visitor, isExpression);
+            const expression = visitNode(node.expression, visitor, isExpression);
+            return createPartiallyEmittedExpression(expression, node);
+        }
+
+        function visitNonNullExpression(node: NonNullExpression): Expression {
+            const expression = visitNode(node.expression, visitor, isLeftHandSideExpression);
             return createPartiallyEmittedExpression(expression, node);
         }
 

src/compiler/visitor.ts

@@ -219,6 +219,9 @@ namespace ts {
             { name: "expression", test: isExpression },
             { name: "type", test: isTypeNode }
         ],
+        [SyntaxKind.NonNullExpression]: [
+            { name: "expression", test: isLeftHandSideExpression }
+        ],
         [SyntaxKind.TemplateSpan]: [
             { name: "expression", test: isExpression },
             { name: "literal", test: isTemplateLiteralFragment }