From 0550b9363532dbc414c42ff4c9c18fe35b52aab6 Mon Sep 17 00:00:00 2001
From: Anders Hejlsberg <andersh@microsoft.com>
Date: Tue, 22 Jul 2014 15:11:24 -0700
Subject: [PATCH 1/2] Allow reserved words in type queries. Fixes #181.

---
 src/compiler/parser.ts                        |  6 ++--
 .../reference/typeQueryWithReservedWords.js   | 29 +++++++++++++++++++
 .../typeQueries/typeQueryWithReservedWords.ts | 14 +++++++++
 3 files changed, 46 insertions(+), 3 deletions(-)
 create mode 100644 tests/baselines/reference/typeQueryWithReservedWords.js
 create mode 100644 tests/cases/conformance/types/specifyingTypes/typeQueries/typeQueryWithReservedWords.ts

diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts
index 6ce2ef1461f..9b3d9594c4e 100644
--- a/src/compiler/parser.ts
+++ b/src/compiler/parser.ts
@@ -865,12 +865,12 @@ module ts {
             return createMissingList<T>();
         }
 
-        function parseEntityName(): EntityName {
+        function parseEntityName(allowReservedWords?: boolean): EntityName {
             var entity: EntityName = parseIdentifier();
             while (parseOptional(SyntaxKind.DotToken)) {
                 var node = <QualifiedName>createNode(SyntaxKind.QualifiedName, entity.pos);
                 node.left = entity;
-                node.right = parseIdentifier();
+                node.right = allowReservedWords ? parseIdentifierName() : parseIdentifier();
                 entity = finishNode(node);
             }
             return entity;
@@ -909,7 +909,7 @@ module ts {
         function parseTypeQuery(): TypeQueryNode {
             var node = <TypeQueryNode>createNode(SyntaxKind.TypeQuery);
             parseExpected(SyntaxKind.TypeOfKeyword);
-            node.exprName = parseEntityName();
+            node.exprName = parseEntityName(/*allowReservedWords*/ true);
             return finishNode(node);
         }
 
diff --git a/tests/baselines/reference/typeQueryWithReservedWords.js b/tests/baselines/reference/typeQueryWithReservedWords.js
new file mode 100644
index 00000000000..e6e7f86541b
--- /dev/null
+++ b/tests/baselines/reference/typeQueryWithReservedWords.js
@@ -0,0 +1,29 @@
+//// [typeQueryWithReservedWords.ts]
+class Controller {
+    create() {
+    }
+    delete() {
+    }
+    var() {
+    }
+}
+
+interface IScope {
+    create: typeof Controller.prototype.create;  
+    delete: typeof Controller.prototype.delete;  // Should not error
+    var: typeof Controller.prototype.var;        // Should not error
+}
+
+
+//// [typeQueryWithReservedWords.js]
+var Controller = (function () {
+    function Controller() {
+    }
+    Controller.prototype.create = function () {
+    };
+    Controller.prototype.delete = function () {
+    };
+    Controller.prototype.var = function () {
+    };
+    return Controller;
+})();
diff --git a/tests/cases/conformance/types/specifyingTypes/typeQueries/typeQueryWithReservedWords.ts b/tests/cases/conformance/types/specifyingTypes/typeQueries/typeQueryWithReservedWords.ts
new file mode 100644
index 00000000000..5fb9d2233f1
--- /dev/null
+++ b/tests/cases/conformance/types/specifyingTypes/typeQueries/typeQueryWithReservedWords.ts
@@ -0,0 +1,14 @@
+class Controller {
+    create() {
+    }
+    delete() {
+    }
+    var() {
+    }
+}
+
+interface IScope {
+    create: typeof Controller.prototype.create;  
+    delete: typeof Controller.prototype.delete;  // Should not error
+    var: typeof Controller.prototype.var;        // Should not error
+}

From 1c594d06a234ad095d94dbb53cc044b40956cbb1 Mon Sep 17 00:00:00 2001
From: Anders Hejlsberg <andersh@microsoft.com>
Date: Wed, 23 Jul 2014 10:17:39 -0700
Subject: [PATCH 2/2] Addressing CR feedback. Making allowReservedWords
 parameter of parseEntityName non-optional.

---
 src/compiler/parser.ts | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts
index 9b3d9594c4e..99e5c40f054 100644
--- a/src/compiler/parser.ts
+++ b/src/compiler/parser.ts
@@ -865,7 +865,8 @@ module ts {
             return createMissingList<T>();
         }
 
-        function parseEntityName(allowReservedWords?: boolean): EntityName {
+        // The allowReservedWords parameter controls whether reserved words are permitted after the first dot
+        function parseEntityName(allowReservedWords: boolean): EntityName {
             var entity: EntityName = parseIdentifier();
             while (parseOptional(SyntaxKind.DotToken)) {
                 var node = <QualifiedName>createNode(SyntaxKind.QualifiedName, entity.pos);
@@ -899,7 +900,7 @@ module ts {
 
         function parseTypeReference(): TypeReferenceNode {
             var node = <TypeReferenceNode>createNode(SyntaxKind.TypeReference);
-            node.typeName = parseEntityName();
+            node.typeName = parseEntityName(/*allowReservedWords*/ false);
             if (!scanner.hasPrecedingLineBreak() && token === SyntaxKind.LessThanToken) {
                 node.typeArguments = parseTypeArguments();
             }
@@ -2815,7 +2816,7 @@ module ts {
             parseExpected(SyntaxKind.ImportKeyword);
             node.name = parseIdentifier();
             parseExpected(SyntaxKind.EqualsToken);
-            var entityName = parseEntityName();
+            var entityName = parseEntityName(/*allowReservedWords*/ false);
             if (entityName.kind === SyntaxKind.Identifier && (<Identifier>entityName).text === "require" && parseOptional(SyntaxKind.OpenParenToken)) {
                 node.externalModuleName = parseStringLiteral();
                 parseExpected(SyntaxKind.CloseParenToken);