From 7312b32c965b4fb17ace431404221c5dd12d86c0 Mon Sep 17 00:00:00 2001
From: Tycho Grouwstra <tychogrouwstra@gmail.com>
Date: Fri, 25 Aug 2017 22:41:46 +0800
Subject: [PATCH] simple test works, but too eager for generics

---
 src/compiler/checker.ts                       |  7 ++++++-
 src/compiler/emitter.ts                       |  8 ++++++++
 tests/baselines/reference/nonNullType.js      | 11 +++++++++++
 tests/baselines/reference/nonNullType.symbols | 18 ++++++++++++++++++
 tests/baselines/reference/nonNullType.types   | 19 +++++++++++++++++++
 tests/cases/compiler/nonNullType.ts           |  8 +++-----
 6 files changed, 65 insertions(+), 6 deletions(-)
 create mode 100644 tests/baselines/reference/nonNullType.js
 create mode 100644 tests/baselines/reference/nonNullType.symbols
 create mode 100644 tests/baselines/reference/nonNullType.types

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 311854ff46f3c..83e56a92940ed 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -7987,10 +7987,11 @@ namespace ts {
                 case SyntaxKind.JSDocNullableType:
                     return getTypeFromJSDocNullableTypeNode(<JSDocNullableType>node);
                 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[] = [];
diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts
index 5444c618353bd..4df9f9a8682bf 100644
--- a/src/compiler/emitter.ts
+++ b/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(".");
diff --git a/tests/baselines/reference/nonNullType.js b/tests/baselines/reference/nonNullType.js
new file mode 100644
index 0000000000000..2b87ad3e6bd51
--- /dev/null
+++ b/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;
diff --git a/tests/baselines/reference/nonNullType.symbols b/tests/baselines/reference/nonNullType.symbols
new file mode 100644
index 0000000000000..1b4aa2a4cb5ac
--- /dev/null
+++ b/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))
+
diff --git a/tests/baselines/reference/nonNullType.types b/tests/baselines/reference/nonNullType.types
new file mode 100644
index 0000000000000..4d18132b8e76a
--- /dev/null
+++ b/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
+
diff --git a/tests/cases/compiler/nonNullType.ts b/tests/cases/compiler/nonNullType.ts
index 8bc6ee9897f9e..f080dc7c1e234 100644
--- a/tests/cases/compiler/nonNullType.ts
+++ b/tests/cases/compiler/nonNullType.ts
@@ -1,7 +1,5 @@
 // @strictNullChecks: true
-type z = string | undefined | null | never;
-type a = string | undefined | null | never;
-type b = a!;
+let a: string | undefined | null | never;
+let b: typeof a!;
 type Assert<T> = T!;
-type c = Assert<a>;
-
+let c: Assert<typeof a>;