From 2953c7f0b2f187aa68664d1e8f7fb4118f777992 Mon Sep 17 00:00:00 2001
From: Andy Hanson <anhans@microsoft.com>
Date: Mon, 15 Aug 2016 11:16:36 -0700
Subject: [PATCH 1/2] Use an enum in checkClassForDuplicateDeclarations to aid
 readability

---
 src/compiler/checker.ts | 20 ++++++++++++--------
 1 file changed, 12 insertions(+), 8 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index ab76950ec4..6f5d2dce12 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -13794,15 +13794,19 @@ namespace ts {
         }
 
         function checkClassForDuplicateDeclarations(node: ClassLikeDeclaration) {
-            const getter = 1, setter = 2, property = getter | setter;
+            const enum Meaning {
+                Getter = 1,
+                Setter = 2,
+                Property = Getter | Setter
+            }
 
-            const instanceNames = createMap<number>();
-            const staticNames = createMap<number>();
+            const instanceNames = createMap<Meaning>();
+            const staticNames = createMap<Meaning>();
             for (const member of node.members) {
                 if (member.kind === SyntaxKind.Constructor) {
                     for (const param of (member as ConstructorDeclaration).parameters) {
                         if (isParameterPropertyDeclaration(param)) {
-                            addName(instanceNames, param.name, (param.name as Identifier).text, property);
+                            addName(instanceNames, param.name, (param.name as Identifier).text, Meaning.Property);
                         }
                     }
                 }
@@ -13814,22 +13818,22 @@ namespace ts {
                     if (memberName) {
                         switch (member.kind) {
                             case SyntaxKind.GetAccessor:
-                                addName(names, member.name, memberName, getter);
+                                addName(names, member.name, memberName, Meaning.Getter);
                                 break;
 
                             case SyntaxKind.SetAccessor:
-                                addName(names, member.name, memberName, setter);
+                                addName(names, member.name, memberName, Meaning.Setter);
                                 break;
 
                             case SyntaxKind.PropertyDeclaration:
-                                addName(names, member.name, memberName, property);
+                                addName(names, member.name, memberName, Meaning.Property);
                                 break;
                         }
                     }
                 }
             }
 
-            function addName(names: Map<number>, location: Node, name: string, meaning: number) {
+            function addName(names: Map<Meaning>, location: Node, name: string, meaning: Meaning) {
                 const prev = names[name];
                 if (prev) {
                     if (prev & meaning) {

From 8f1960fd3474fdbfd70d3dd1d0d86aa6d3e17a2e Mon Sep 17 00:00:00 2001
From: Andy Hanson <anhans@microsoft.com>
Date: Mon, 15 Aug 2016 11:43:40 -0700
Subject: [PATCH 2/2] Rename to Accessor

---
 src/compiler/checker.ts | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 6f5d2dce12..6e51e418ee 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -13794,19 +13794,19 @@ namespace ts {
         }
 
         function checkClassForDuplicateDeclarations(node: ClassLikeDeclaration) {
-            const enum Meaning {
+            const enum Accessor {
                 Getter = 1,
                 Setter = 2,
                 Property = Getter | Setter
             }
 
-            const instanceNames = createMap<Meaning>();
-            const staticNames = createMap<Meaning>();
+            const instanceNames = createMap<Accessor>();
+            const staticNames = createMap<Accessor>();
             for (const member of node.members) {
                 if (member.kind === SyntaxKind.Constructor) {
                     for (const param of (member as ConstructorDeclaration).parameters) {
                         if (isParameterPropertyDeclaration(param)) {
-                            addName(instanceNames, param.name, (param.name as Identifier).text, Meaning.Property);
+                            addName(instanceNames, param.name, (param.name as Identifier).text, Accessor.Property);
                         }
                     }
                 }
@@ -13818,22 +13818,22 @@ namespace ts {
                     if (memberName) {
                         switch (member.kind) {
                             case SyntaxKind.GetAccessor:
-                                addName(names, member.name, memberName, Meaning.Getter);
+                                addName(names, member.name, memberName, Accessor.Getter);
                                 break;
 
                             case SyntaxKind.SetAccessor:
-                                addName(names, member.name, memberName, Meaning.Setter);
+                                addName(names, member.name, memberName, Accessor.Setter);
                                 break;
 
                             case SyntaxKind.PropertyDeclaration:
-                                addName(names, member.name, memberName, Meaning.Property);
+                                addName(names, member.name, memberName, Accessor.Property);
                                 break;
                         }
                     }
                 }
             }
 
-            function addName(names: Map<Meaning>, location: Node, name: string, meaning: Meaning) {
+            function addName(names: Map<Accessor>, location: Node, name: string, meaning: Accessor) {
                 const prev = names[name];
                 if (prev) {
                     if (prev & meaning) {