From c56b4165ec69d7db3c51c0e37a8f984f0abd3453 Mon Sep 17 00:00:00 2001
From: Vladimir Matveev <vladima@microsoft.com>
Date: Mon, 21 Sep 2015 22:22:25 -0700
Subject: [PATCH] disambiguate: 'implements' starts heritage clause vs
 'implements' is a class name

---
 src/compiler/parser.ts                        | 19 +++++++++++++++++--
 .../reference/implementsInClassExpression.js  | 16 ++++++++++++++++
 .../implementsInClassExpression.symbols       | 15 +++++++++++++++
 .../implementsInClassExpression.types         | 16 ++++++++++++++++
 .../compiler/implementsInClassExpression.ts   |  7 +++++++
 5 files changed, 71 insertions(+), 2 deletions(-)
 create mode 100644 tests/baselines/reference/implementsInClassExpression.js
 create mode 100644 tests/baselines/reference/implementsInClassExpression.symbols
 create mode 100644 tests/baselines/reference/implementsInClassExpression.types
 create mode 100644 tests/cases/compiler/implementsInClassExpression.ts

diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts
index 330ad05518b..23fb846c0b4 100644
--- a/src/compiler/parser.ts
+++ b/src/compiler/parser.ts
@@ -4809,7 +4809,7 @@ namespace ts {
             node.decorators = decorators;
             setModifiers(node, modifiers);
             parseExpected(SyntaxKind.ClassKeyword);
-            node.name = parseOptionalIdentifier();
+            node.name = parseNameOfClassDeclarationOrExpression();
             node.typeParameters = parseTypeParameters();
             node.heritageClauses = parseHeritageClauses(/*isClassHeritageClause*/ true);
 
@@ -4825,7 +4825,22 @@ namespace ts {
 
             return finishNode(node);
         }
-
+        
+        function parseNameOfClassDeclarationOrExpression(): Identifier {
+            // implements is a future reserved word so
+            // 'class implements' might mean either
+            // - class expression with omitted name, 'implements' starts heritage clause
+            // - class with name 'implements' 
+            // 'isImplementsClause' helps to disambiguate between these two cases 
+            return isIdentifier() && !isImplementsClause()
+                ? parseIdentifier()
+                : undefined;
+        }
+        
+        function isImplementsClause() {
+            return token === SyntaxKind.ImplementsKeyword && lookAhead(nextTokenIsIdentifierOrKeyword)
+        }
+        
         function parseHeritageClauses(isClassHeritageClause: boolean): NodeArray<HeritageClause> {
             // ClassTail[Yield,Await] : (Modified) See 14.5
             //      ClassHeritage[?Yield,?Await]opt { ClassBody[?Yield,?Await]opt }
diff --git a/tests/baselines/reference/implementsInClassExpression.js b/tests/baselines/reference/implementsInClassExpression.js
new file mode 100644
index 00000000000..9ac092289f5
--- /dev/null
+++ b/tests/baselines/reference/implementsInClassExpression.js
@@ -0,0 +1,16 @@
+//// [implementsInClassExpression.ts]
+interface Foo {
+    doThing(): void;
+}
+
+let cls = class implements Foo {
+    doThing() { }
+}
+
+//// [implementsInClassExpression.js]
+var cls = (function () {
+    function class_1() {
+    }
+    class_1.prototype.doThing = function () { };
+    return class_1;
+})();
diff --git a/tests/baselines/reference/implementsInClassExpression.symbols b/tests/baselines/reference/implementsInClassExpression.symbols
new file mode 100644
index 00000000000..f65c3456320
--- /dev/null
+++ b/tests/baselines/reference/implementsInClassExpression.symbols
@@ -0,0 +1,15 @@
+=== tests/cases/compiler/implementsInClassExpression.ts ===
+interface Foo {
+>Foo : Symbol(Foo, Decl(implementsInClassExpression.ts, 0, 0))
+
+    doThing(): void;
+>doThing : Symbol(doThing, Decl(implementsInClassExpression.ts, 0, 15))
+}
+
+let cls = class implements Foo {
+>cls : Symbol(cls, Decl(implementsInClassExpression.ts, 4, 3))
+>Foo : Symbol(Foo, Decl(implementsInClassExpression.ts, 0, 0))
+
+    doThing() { }
+>doThing : Symbol((Anonymous class).doThing, Decl(implementsInClassExpression.ts, 4, 32))
+}
diff --git a/tests/baselines/reference/implementsInClassExpression.types b/tests/baselines/reference/implementsInClassExpression.types
new file mode 100644
index 00000000000..d3647c30ff1
--- /dev/null
+++ b/tests/baselines/reference/implementsInClassExpression.types
@@ -0,0 +1,16 @@
+=== tests/cases/compiler/implementsInClassExpression.ts ===
+interface Foo {
+>Foo : Foo
+
+    doThing(): void;
+>doThing : () => void
+}
+
+let cls = class implements Foo {
+>cls : typeof (Anonymous class)
+>class implements Foo {    doThing() { }} : typeof (Anonymous class)
+>Foo : Foo
+
+    doThing() { }
+>doThing : () => void
+}
diff --git a/tests/cases/compiler/implementsInClassExpression.ts b/tests/cases/compiler/implementsInClassExpression.ts
new file mode 100644
index 00000000000..4504c6a2622
--- /dev/null
+++ b/tests/cases/compiler/implementsInClassExpression.ts
@@ -0,0 +1,7 @@
+interface Foo {
+    doThing(): void;
+}
+
+let cls = class implements Foo {
+    doThing() { }
+}
\ No newline at end of file