Allow reserved words in type queries.

src/compiler/parser.ts

@@ -865,12 +865,13 @@ module ts {
             return createMissingList<T>();
         }
 
-        function parseEntityName(): 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);
                 node.left = entity;
-                node.right = parseIdentifier();
+                node.right = allowReservedWords ? parseIdentifierName() : parseIdentifier();
                 entity = finishNode(node);
             }
             return entity;
@@ -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();
             }
@@ -909,7 +910,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);
         }
 
@@ -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);

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;
+})();

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
+}