WIP: type-level assertion operator (!)

src/compiler/checker.ts

@@ -7986,11 +7986,12 @@ namespace ts {
                     return getTypeFromIntersectionTypeNode(<IntersectionTypeNode>node);
                 case SyntaxKind.JSDocNullableType:
                     return getTypeFromJSDocNullableTypeNode(<JSDocNullableType>node);
-                case SyntaxKind.ParenthesizedType:
                 case SyntaxKind.JSDocNonNullableType:
+                    return getTypeFromNonNullableType((<JSDocNullableType>node).type);
+                case SyntaxKind.ParenthesizedType:
                 case SyntaxKind.JSDocOptionalType:
                 case SyntaxKind.JSDocTypeExpression:
-                    return getTypeFromTypeNode((<ParenthesizedTypeNode | JSDocTypeReferencingNode | JSDocTypeExpression>node).type);
+                    return getTypeFromTypeNode((<ParenthesizedTypeNode | JSDocTypeReferencingNode>node).type);
                 case SyntaxKind.FunctionType:
                 case SyntaxKind.ConstructorType:
                 case SyntaxKind.TypeLiteral:
@@ -8016,6 +8017,10 @@ namespace ts {
             }
         }
 
+        function getTypeFromNonNullableType(node: TypeNode) {
+            return getNonNullableType(getTypeFromTypeNode(node));
+        }
+
         function instantiateList<T>(items: T[], mapper: TypeMapper, instantiator: (item: T, mapper: TypeMapper) => T): T[] {
             if (items && items.length) {
                 const result: T[] = [];
@@ -22374,7 +22379,8 @@ namespace ts {
                     return checkUnionOrIntersectionType(<UnionOrIntersectionTypeNode>node);
                 case SyntaxKind.ParenthesizedType:
                 case SyntaxKind.TypeOperator:
-                    return checkSourceElement((<ParenthesizedTypeNode | TypeOperatorNode>node).type);
+                case SyntaxKind.JSDocNonNullableType:
+                    return checkSourceElement((<ParenthesizedTypeNode | TypeOperatorNode | JSDocNonNullableType>node).type);
                 case SyntaxKind.JSDocComment:
                     return checkJSDocComment(node as JSDoc);
                 case SyntaxKind.JSDocParameterTag:
@@ -22383,7 +22389,6 @@ namespace ts {
                     checkSignatureDeclaration(node as JSDocFunctionType);
                     // falls through
                 case SyntaxKind.JSDocVariadicType:
-                case SyntaxKind.JSDocNonNullableType:
                 case SyntaxKind.JSDocNullableType:
                 case SyntaxKind.JSDocAllType:
                 case SyntaxKind.JSDocUnknownType:

src/compiler/emitter.ts

@@ -703,6 +703,9 @@ namespace ts {
                     return emitEnumMember(<EnumMember>node);
 
                 // JSDoc nodes (ignored)
+                case SyntaxKind.JSDocNonNullableType:
+                    return emitNonNullType(<JSDocNonNullableType>node);
+
                 // Transformation nodes (ignored)
             }
 
@@ -1413,6 +1416,11 @@ namespace ts {
             write("!");
         }
 
+        function emitNonNullType(node: JSDocNonNullableType) {
+            emit(node.type);
+            write("!");
+        }
+
         function emitMetaProperty(node: MetaProperty) {
             writeToken(node.keywordToken, node.pos);
             write(".");

tests/baselines/reference/jsdocDisallowedInTypescript.errors.txt

@@ -8,13 +8,11 @@ tests/cases/conformance/jsdoc/jsdocDisallowedInTypescript.ts(13,14): error TS802
 tests/cases/conformance/jsdoc/jsdocDisallowedInTypescript.ts(14,11): error TS8020: JSDoc types can only be used inside documentation comments.
 tests/cases/conformance/jsdoc/jsdocDisallowedInTypescript.ts(15,8): error TS8020: JSDoc types can only be used inside documentation comments.
 tests/cases/conformance/jsdoc/jsdocDisallowedInTypescript.ts(16,15): error TS8020: JSDoc types can only be used inside documentation comments.
-tests/cases/conformance/jsdoc/jsdocDisallowedInTypescript.ts(17,11): error TS8020: JSDoc types can only be used inside documentation comments.
-tests/cases/conformance/jsdoc/jsdocDisallowedInTypescript.ts(18,17): error TS8020: JSDoc types can only be used inside documentation comments.
 tests/cases/conformance/jsdoc/jsdocDisallowedInTypescript.ts(19,5): error TS2322: Type 'undefined' is not assignable to type 'number | null'.
 tests/cases/conformance/jsdoc/jsdocDisallowedInTypescript.ts(19,17): error TS8020: JSDoc types can only be used inside documentation comments.
 
 
-==== tests/cases/conformance/jsdoc/jsdocDisallowedInTypescript.ts (14 errors) ====
+==== tests/cases/conformance/jsdoc/jsdocDisallowedInTypescript.ts (12 errors) ====
     // grammar error from checker
     var ara: Array.<number> = [1,2,3];
                   ~
@@ -52,11 +50,7 @@ tests/cases/conformance/jsdoc/jsdocDisallowedInTypescript.ts(19,17): error TS802
                   ~~~~~~~~~~
 !!! error TS8020: JSDoc types can only be used inside documentation comments.
     var most: !string = 'definite';
-              ~~~~~~~
-!!! error TS8020: JSDoc types can only be used inside documentation comments.
     var postfixdef: number! = 101;
-                    ~~~~~~~
-!!! error TS8020: JSDoc types can only be used inside documentation comments.
     var postfixopt: number? = undefined;
         ~~~~~~~~~~
 !!! error TS2322: Type 'undefined' is not assignable to type 'number | null'.

tests/baselines/reference/nonNullType.js

@@ -0,0 +1,11 @@
+//// [nonNullType.ts]
+let a: string | undefined | null | never;
+let b: typeof a!;
+type Assert<T> = T!;
+let c: Assert<typeof a>;
+
+
+//// [nonNullType.js]
+var a;
+var b;
+var c;

tests/baselines/reference/nonNullType.symbols

@@ -0,0 +1,18 @@
+=== tests/cases/compiler/nonNullType.ts ===
+let a: string | undefined | null | never;
+>a : Symbol(a, Decl(nonNullType.ts, 0, 3))
+
+let b: typeof a!;
+>b : Symbol(b, Decl(nonNullType.ts, 1, 3))
+>a : Symbol(a, Decl(nonNullType.ts, 0, 3))
+
+type Assert<T> = T!;
+>Assert : Symbol(Assert, Decl(nonNullType.ts, 1, 17))
+>T : Symbol(T, Decl(nonNullType.ts, 2, 12))
+>T : Symbol(T, Decl(nonNullType.ts, 2, 12))
+
+let c: Assert<typeof a>;
+>c : Symbol(c, Decl(nonNullType.ts, 3, 3))
+>Assert : Symbol(Assert, Decl(nonNullType.ts, 1, 17))
+>a : Symbol(a, Decl(nonNullType.ts, 0, 3))
+

tests/baselines/reference/nonNullType.types

@@ -0,0 +1,19 @@
+=== tests/cases/compiler/nonNullType.ts ===
+let a: string | undefined | null | never;
+>a : string | null | undefined
+>null : null
+
+let b: typeof a!;
+>b : string
+>a : string | null | undefined
+
+type Assert<T> = T!;
+>Assert : T
+>T : T
+>T : T
+
+let c: Assert<typeof a>;
+>c : string | null | undefined
+>Assert : T
+>a : string | null | undefined
+

tests/cases/compiler/nonNullType.ts

@@ -0,0 +1,5 @@
+// @strictNullChecks: true
+let a: string | undefined | null | never;
+let b: typeof a!;
+type Assert<T> = T!;
+let c: Assert<typeof a>;