From 8e926035b7e17533b205d06d4c60a89c21238e00 Mon Sep 17 00:00:00 2001
From: Anders Hejlsberg <andersh@microsoft.com>
Date: Sun, 14 Feb 2016 18:59:58 -0800
Subject: [PATCH] Parsing of nullable types

---
 src/compiler/parser.ts | 23 +++++++++++++++++------
 src/compiler/types.ts  |  8 +++++++-
 2 files changed, 24 insertions(+), 7 deletions(-)

diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts
index 66d33f9d7d9..16ee3eb1627 100644
--- a/src/compiler/parser.ts
+++ b/src/compiler/parser.ts
@@ -127,7 +127,8 @@ namespace ts {
             case SyntaxKind.IntersectionType:
                 return visitNodes(cbNodes, (<UnionOrIntersectionTypeNode>node).types);
             case SyntaxKind.ParenthesizedType:
-                return visitNode(cbNode, (<ParenthesizedTypeNode>node).type);
+            case SyntaxKind.NullableType:
+                return visitNode(cbNode, (<ParenthesizedTypeNode | NullableTypeNode>node).type);
             case SyntaxKind.ObjectBindingPattern:
             case SyntaxKind.ArrayBindingPattern:
                 return visitNodes(cbNodes, (<BindingPattern>node).elements);
@@ -2413,11 +2414,21 @@ namespace ts {
 
         function parseArrayTypeOrHigher(): TypeNode {
             let type = parseNonArrayType();
-            while (!scanner.hasPrecedingLineBreak() && parseOptional(SyntaxKind.OpenBracketToken)) {
-                parseExpected(SyntaxKind.CloseBracketToken);
-                const node = <ArrayTypeNode>createNode(SyntaxKind.ArrayType, type.pos);
-                node.elementType = type;
-                type = finishNode(node);
+            while (!scanner.hasPrecedingLineBreak()) {
+                if (parseOptional(SyntaxKind.OpenBracketToken)) {
+                    parseExpected(SyntaxKind.CloseBracketToken);
+                    const node = <ArrayTypeNode>createNode(SyntaxKind.ArrayType, type.pos);
+                    node.elementType = type;
+                    type = finishNode(node);
+                }
+                else if (parseOptional(SyntaxKind.QuestionToken)) {
+                    const node = <NullableTypeNode>createNode(SyntaxKind.NullableType, type.pos);
+                    node.type = type;
+                    type = finishNode(node);
+                }
+                else {
+                    break;
+                }
             }
             return type;
         }
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index 3e59a623c2f..c2e5b166815 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -208,6 +208,7 @@ namespace ts {
         ParenthesizedType,
         ThisType,
         StringLiteralType,
+        NullableType,
         // Binding patterns
         ObjectBindingPattern,
         ArrayBindingPattern,
@@ -353,7 +354,7 @@ namespace ts {
         FirstFutureReservedWord = ImplementsKeyword,
         LastFutureReservedWord = YieldKeyword,
         FirstTypeNode = TypePredicate,
-        LastTypeNode = StringLiteralType,
+        LastTypeNode = NullableType,
         FirstPunctuation = OpenBraceToken,
         LastPunctuation = CaretEqualsToken,
         FirstToken = Unknown,
@@ -777,6 +778,11 @@ namespace ts {
         _stringLiteralTypeBrand: any;
     }
 
+    // @kind(SyntaxKind.NullableType)
+    export interface NullableTypeNode extends TypeNode {
+        type: TypeNode;
+    }
+
     // @kind(SyntaxKind.StringLiteral)
     export interface StringLiteral extends LiteralExpression {
         _stringLiteralBrand: any;