From a6642d68c92ce7ddd16e8da71a1f2eb909fde74d Mon Sep 17 00:00:00 2001
From: Nathan Shively-Sanders <nathansa@microsoft.com>
Date: Wed, 27 Jul 2016 13:21:42 -0700
Subject: [PATCH] JSDoc understands string literal types

Unfortunately, I didn't find a way to reuse the normal string literal
type, so I had to extend the existing JSDoc type hierarchy. Otherwise,
this feature is very simple.
---
 src/compiler/checker.ts                          |  2 ++
 src/compiler/parser.ts                           |  9 ++++++++-
 src/compiler/types.ts                            |  5 +++++
 tests/baselines/reference/jsdocStringLiteral.js  | 16 ++++++++++++++++
 .../reference/jsdocStringLiteral.symbols         | 12 ++++++++++++
 .../baselines/reference/jsdocStringLiteral.types | 14 ++++++++++++++
 .../conformance/jsdoc/jsdocStringLiteral.ts      | 12 ++++++++++++
 7 files changed, 69 insertions(+), 1 deletion(-)
 create mode 100644 tests/baselines/reference/jsdocStringLiteral.js
 create mode 100644 tests/baselines/reference/jsdocStringLiteral.symbols
 create mode 100644 tests/baselines/reference/jsdocStringLiteral.types
 create mode 100644 tests/cases/conformance/jsdoc/jsdocStringLiteral.ts

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 6da456afcbc..321bfcc74a3 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -5326,6 +5326,8 @@ namespace ts {
                     return getTypeFromThisTypeNode(node);
                 case SyntaxKind.StringLiteralType:
                     return getTypeFromStringLiteralTypeNode(<StringLiteralTypeNode>node);
+                case SyntaxKind.JSDocStringLiteralType:
+                    return getTypeFromStringLiteralTypeNode((<JSDocStringLiteralType>node).stringLiteral);
                 case SyntaxKind.TypeReference:
                 case SyntaxKind.JSDocTypeReference:
                     return getTypeFromTypeReference(<TypeReferenceNode>node);
diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts
index 774cea60e09..2e76093cde2 100644
--- a/src/compiler/parser.ts
+++ b/src/compiler/parser.ts
@@ -5860,9 +5860,10 @@ namespace ts {
                     case SyntaxKind.SymbolKeyword:
                     case SyntaxKind.VoidKeyword:
                         return parseTokenNode<JSDocType>();
+                    case SyntaxKind.StringLiteral:
+                        return parseJSDocStringLiteralType();
                 }
 
-                // TODO (drosen): Parse string literal types in JSDoc as well.
                 return parseJSDocTypeReference();
             }
 
@@ -6041,6 +6042,12 @@ namespace ts {
                 return finishNode(result);
             }
 
+            function parseJSDocStringLiteralType(): JSDocStringLiteralType {
+                const result = <JSDocStringLiteralType>createNode(SyntaxKind.JSDocStringLiteralType);
+                result.stringLiteral = parseStringLiteralTypeNode();
+                return finishNode(result);
+            }
+
             function parseJSDocUnknownOrNullableType(): JSDocUnknownType | JSDocNullableType {
                 const pos = scanner.getStartPos();
                 // skip the ?
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index dc332b24567..17e8a25038d 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -346,6 +346,7 @@ namespace ts {
         JSDocTypedefTag,
         JSDocPropertyTag,
         JSDocTypeLiteral,
+        JSDocStringLiteralType,
 
         // Synthesized list
         SyntaxList,
@@ -1491,6 +1492,10 @@ namespace ts {
         type: JSDocType;
     }
 
+    export interface JSDocStringLiteralType extends JSDocType {
+        stringLiteral: StringLiteralTypeNode;
+    }
+
     export type JSDocTypeReferencingNode = JSDocThisType | JSDocConstructorType | JSDocVariadicType | JSDocOptionalType | JSDocNullableType | JSDocNonNullableType;
 
     // @kind(SyntaxKind.JSDocRecordMember)
diff --git a/tests/baselines/reference/jsdocStringLiteral.js b/tests/baselines/reference/jsdocStringLiteral.js
new file mode 100644
index 00000000000..f74faf3519e
--- /dev/null
+++ b/tests/baselines/reference/jsdocStringLiteral.js
@@ -0,0 +1,16 @@
+//// [in.js]
+/**
+ * @param {'literal'} input
+ */
+function f(input) {
+    return input + '.';
+}
+
+
+//// [out.js]
+/**
+ * @param {'literal'} input
+ */
+function f(input) {
+    return input + '.';
+}
diff --git a/tests/baselines/reference/jsdocStringLiteral.symbols b/tests/baselines/reference/jsdocStringLiteral.symbols
new file mode 100644
index 00000000000..0414efc24d9
--- /dev/null
+++ b/tests/baselines/reference/jsdocStringLiteral.symbols
@@ -0,0 +1,12 @@
+=== tests/cases/compiler/in.js ===
+/**
+ * @param {'literal'} input
+ */
+function f(input) {
+>f : Symbol(f, Decl(in.js, 0, 0))
+>input : Symbol(input, Decl(in.js, 3, 11))
+
+    return input + '.';
+>input : Symbol(input, Decl(in.js, 3, 11))
+}
+
diff --git a/tests/baselines/reference/jsdocStringLiteral.types b/tests/baselines/reference/jsdocStringLiteral.types
new file mode 100644
index 00000000000..c7b87857d18
--- /dev/null
+++ b/tests/baselines/reference/jsdocStringLiteral.types
@@ -0,0 +1,14 @@
+=== tests/cases/compiler/in.js ===
+/**
+ * @param {'literal'} input
+ */
+function f(input) {
+>f : (input: "literal") => string
+>input : "literal"
+
+    return input + '.';
+>input + '.' : string
+>input : "literal"
+>'.' : string
+}
+
diff --git a/tests/cases/conformance/jsdoc/jsdocStringLiteral.ts b/tests/cases/conformance/jsdoc/jsdocStringLiteral.ts
new file mode 100644
index 00000000000..d2a0d6c644d
--- /dev/null
+++ b/tests/cases/conformance/jsdoc/jsdocStringLiteral.ts
@@ -0,0 +1,12 @@
+// @allowJs: true
+// @filename: in.js
+// @out: out.js
+/**
+ * @param {'literal'} p1
+ * @param {"literal"} p2
+ * @param {'literal' | 'other'} p3
+ * @param {'literal' | number} p4
+ */
+function f(p1, p2, p3, p4) {
+    return p1 + p2 + p3 + p4 + '.';
+}