From 49ae5c71173ff559f87beafa96b8d133ff1f3976 Mon Sep 17 00:00:00 2001
From: Sheetal Nandi <shkamat@microsoft.com>
Date: Wed, 12 Nov 2014 14:23:59 -0800
Subject: [PATCH 1/4] Fixes the quickInfo and completion list details for let
 and adds test cases for let and const Handles #1083

---
 src/services/navigationBar.ts                 |  3 ++
 src/services/services.ts                      | 13 ++++++-
 .../constQuickInfoAndCompletionList.ts        | 37 +++++++++++++++++++
 .../letQuickInfoAndCompletionList.ts          | 28 ++++++++++++++
 tests/cases/fourslash/navbar_let.ts           | 13 +++++++
 tests/cases/fourslash/navigateItemsConst.ts   | 16 ++++++++
 tests/cases/fourslash/navigateItemsLet.ts     | 16 ++++++++
 7 files changed, 124 insertions(+), 2 deletions(-)
 create mode 100644 tests/cases/fourslash/constQuickInfoAndCompletionList.ts
 create mode 100644 tests/cases/fourslash/letQuickInfoAndCompletionList.ts
 create mode 100644 tests/cases/fourslash/navbar_let.ts
 create mode 100644 tests/cases/fourslash/navigateItemsConst.ts
 create mode 100644 tests/cases/fourslash/navigateItemsLet.ts

diff --git a/src/services/navigationBar.ts b/src/services/navigationBar.ts
index ca06d40fa8..b8106fc18d 100644
--- a/src/services/navigationBar.ts
+++ b/src/services/navigationBar.ts
@@ -238,6 +238,9 @@ module ts.NavigationBar {
                     if (node.flags & NodeFlags.Const) {
                         return createItem(node, getTextOfNode((<VariableDeclaration>node).name), ts.ScriptElementKind.constantElement);
                     }
+                    else if (node.flags & NodeFlags.Let) {
+                        return createItem(node, getTextOfNode((<VariableDeclaration>node).name), ts.ScriptElementKind.letElement);
+                    }
                     else {
                         return createItem(node, getTextOfNode((<VariableDeclaration>node).name), ts.ScriptElementKind.variableElement);
                     }
diff --git a/src/services/services.ts b/src/services/services.ts
index 800d63738f..4cf65d820c 100644
--- a/src/services/services.ts
+++ b/src/services/services.ts
@@ -1225,6 +1225,8 @@ module ts {
         static alias = "alias";
 
         static constantElement = "constant";
+
+        static letElement = "let";
     }
 
     export class ScriptElementKindModifier {
@@ -2857,9 +2859,12 @@ module ts {
                 if (isFirstDeclarationOfSymbolParameter(symbol)) {
                     return ScriptElementKind.parameterElement;
                 }
-                else if(symbol.valueDeclaration && symbol.valueDeclaration.flags & NodeFlags.Const) {
+                else if (symbol.valueDeclaration && symbol.valueDeclaration.flags & NodeFlags.Const) {
                     return ScriptElementKind.constantElement;
                 }
+                else if (forEach(symbol.declarations, declaration => declaration.flags & NodeFlags.Let)) {
+                    return ScriptElementKind.letElement;
+                }
                 return isLocalVariableOrFunction(symbol) ? ScriptElementKind.localVariableElement : ScriptElementKind.variableElement;
             }
             if (flags & SymbolFlags.Function) return isLocalVariableOrFunction(symbol) ? ScriptElementKind.localFunctionElement : ScriptElementKind.functionElement;
@@ -2915,7 +2920,11 @@ module ts {
                 case SyntaxKind.InterfaceDeclaration: return ScriptElementKind.interfaceElement;
                 case SyntaxKind.TypeAliasDeclaration: return ScriptElementKind.typeElement;
                 case SyntaxKind.EnumDeclaration: return ScriptElementKind.enumElement;
-                case SyntaxKind.VariableDeclaration: return node.flags & NodeFlags.Const ? ScriptElementKind.constantElement: ScriptElementKind.variableElement;
+                case SyntaxKind.VariableDeclaration: return node.flags & NodeFlags.Const ?
+                    ScriptElementKind.constantElement :
+                    node.flags & NodeFlags.Let ?
+                    ScriptElementKind.letElement :
+                    ScriptElementKind.variableElement;
                 case SyntaxKind.FunctionDeclaration: return ScriptElementKind.functionElement;
                 case SyntaxKind.GetAccessor: return ScriptElementKind.memberGetAccessorElement;
                 case SyntaxKind.SetAccessor: return ScriptElementKind.memberSetAccessorElement;
diff --git a/tests/cases/fourslash/constQuickInfoAndCompletionList.ts b/tests/cases/fourslash/constQuickInfoAndCompletionList.ts
new file mode 100644
index 0000000000..421a9819d4
--- /dev/null
+++ b/tests/cases/fourslash/constQuickInfoAndCompletionList.ts
@@ -0,0 +1,37 @@
+/// <reference path='fourslash.ts' />
+
+////const /*1*/a = 10;
+////var x = /*2*/a;
+/////*3*/
+////function foo() {
+////    const /*4*/b = 20;
+////    var y = /*5*/b;
+////    var z = /*6*/a;
+////    /*7*/
+////}
+goTo.marker('1');
+verify.quickInfoIs("(constant) a: number");
+
+goTo.marker('2');
+verify.completionListContains("a", "(constant) a: number");
+verify.quickInfoIs("(constant) a: number");
+
+goTo.marker('3');
+verify.completionListContains("a", "(constant) a: number");
+
+goTo.marker('4');
+verify.quickInfoIs("(constant) b: number");
+
+goTo.marker('5');
+verify.completionListContains("a", "(constant) a: number");
+verify.completionListContains("b", "(constant) b: number");
+verify.quickInfoIs("(constant) b: number");
+
+goTo.marker('6');
+verify.completionListContains("a", "(constant) a: number");
+verify.completionListContains("b", "(constant) b: number");
+verify.quickInfoIs("(constant) a: number");
+
+goTo.marker('7');
+verify.completionListContains("a", "(constant) a: number");
+verify.completionListContains("b", "(constant) b: number");
\ No newline at end of file
diff --git a/tests/cases/fourslash/letQuickInfoAndCompletionList.ts b/tests/cases/fourslash/letQuickInfoAndCompletionList.ts
new file mode 100644
index 0000000000..127b4d626f
--- /dev/null
+++ b/tests/cases/fourslash/letQuickInfoAndCompletionList.ts
@@ -0,0 +1,28 @@
+/// <reference path='fourslash.ts' />
+
+////let /*1*/a = 10;
+/////*2*/a = 30;
+////function foo() {
+////    let /*3*/b = 20;
+////    /*4*/b = /*5*/a;
+////}
+
+goTo.marker('1');
+verify.quickInfoIs("(let) a: number");
+
+goTo.marker('2');
+verify.completionListContains("a", "(let) a: number");
+verify.quickInfoIs("(let) a: number");
+
+goTo.marker('3');
+verify.quickInfoIs("(let) b: number");
+
+goTo.marker('4');
+verify.completionListContains("a", "(let) a: number");
+verify.completionListContains("b", "(let) b: number");
+verify.quickInfoIs("(let) b: number");
+
+goTo.marker('5');
+verify.completionListContains("a", "(let) a: number");
+verify.completionListContains("b", "(let) b: number");
+verify.quickInfoIs("(let) a: number");
\ No newline at end of file
diff --git a/tests/cases/fourslash/navbar_let.ts b/tests/cases/fourslash/navbar_let.ts
new file mode 100644
index 0000000000..841382abc5
--- /dev/null
+++ b/tests/cases/fourslash/navbar_let.ts
@@ -0,0 +1,13 @@
+/// <reference path="fourslash.ts" />
+
+//// {| "itemName": "c", "kind": "let", "parentName": "" |}let c = 0;
+
+test.markers().forEach(marker => {
+    verify.getScriptLexicalStructureListContains(
+        marker.data.itemName,
+        marker.data.kind,
+        marker.fileName,
+        marker.data.parentName,
+        marker.data.isAdditionalRange,
+        marker.position);
+});
\ No newline at end of file
diff --git a/tests/cases/fourslash/navigateItemsConst.ts b/tests/cases/fourslash/navigateItemsConst.ts
new file mode 100644
index 0000000000..6f0fdf717f
--- /dev/null
+++ b/tests/cases/fourslash/navigateItemsConst.ts
@@ -0,0 +1,16 @@
+/// <reference path="fourslash.ts" />
+
+////{| "itemName": "c", "kind": "constant", "parentName": "" |}const c = 10;
+////function foo() {
+////    {| "itemName": "d", "kind": "constant", "parentName": "foo" |}const d = 10;
+////}
+
+test.markers().forEach(marker => {
+    verify.navigationItemsListContains(
+        marker.data.itemName,
+        marker.data.kind,
+        marker.data.itemName,
+        "exact",
+        marker.fileName,
+        marker.data.parentName);
+});
\ No newline at end of file
diff --git a/tests/cases/fourslash/navigateItemsLet.ts b/tests/cases/fourslash/navigateItemsLet.ts
new file mode 100644
index 0000000000..dc39952270
--- /dev/null
+++ b/tests/cases/fourslash/navigateItemsLet.ts
@@ -0,0 +1,16 @@
+/// <reference path="fourslash.ts" />
+
+////{| "itemName": "c", "kind": "let", "parentName": "" |}let c = 10;
+////function foo() {
+////    {| "itemName": "d", "kind": "let", "parentName": "foo" |}let d = 10;
+////}
+
+test.markers().forEach(marker => {
+    verify.navigationItemsListContains(
+        marker.data.itemName,
+        marker.data.kind,
+        marker.data.itemName,
+        "exact",
+        marker.fileName,
+        marker.data.parentName);
+});
\ No newline at end of file

From 0fdb0fa2d401400ce6718dc5395ad1effe45b03e Mon Sep 17 00:00:00 2001
From: Sheetal Nandi <shkamat@microsoft.com>
Date: Wed, 12 Nov 2014 14:24:51 -0800
Subject: [PATCH 2/4] Quickinfo and completion entry should display const enum
 enumName if enum is constant Handles #1084

---
 src/services/services.ts                          |  5 +++++
 .../constEnumQuickInfoAndCompletionList.ts        | 15 +++++++++++++++
 2 files changed, 20 insertions(+)
 create mode 100644 tests/cases/fourslash/constEnumQuickInfoAndCompletionList.ts

diff --git a/src/services/services.ts b/src/services/services.ts
index 4cf65d820c..8d48f0bfe1 100644
--- a/src/services/services.ts
+++ b/src/services/services.ts
@@ -3099,6 +3099,11 @@ module ts {
             }
             if (symbolFlags & SymbolFlags.Enum) {
                 addNewLineIfDisplayPartsExist();
+                if (forEach(symbol.declarations, declaration =>
+                    declaration.kind === SyntaxKind.EnumDeclaration && isConstEnumDeclaration(<EnumDeclaration>declaration))) {
+                    displayParts.push(keywordPart(SyntaxKind.ConstKeyword));
+                    displayParts.push(spacePart());
+                }
                 displayParts.push(keywordPart(SyntaxKind.EnumKeyword));
                 displayParts.push(spacePart());
                 addFullSymbolName(symbol);
diff --git a/tests/cases/fourslash/constEnumQuickInfoAndCompletionList.ts b/tests/cases/fourslash/constEnumQuickInfoAndCompletionList.ts
new file mode 100644
index 0000000000..aa90fd2e18
--- /dev/null
+++ b/tests/cases/fourslash/constEnumQuickInfoAndCompletionList.ts
@@ -0,0 +1,15 @@
+/// <reference path='fourslash.ts' />
+
+////const enum /*1*/e {
+////    a,
+////    b,
+////    c
+////}
+/////*2*/e.a;
+
+goTo.marker('1');
+verify.quickInfoIs("const enum e");
+
+goTo.marker('2');
+verify.completionListContains("e", "const enum e");
+verify.quickInfoIs("const enum e");
\ No newline at end of file

From 5e94f4a5c2b71d0286a445935ecb1859afa94787 Mon Sep 17 00:00:00 2001
From: Sheetal Nandi <shkamat@microsoft.com>
Date: Wed, 12 Nov 2014 15:40:45 -0800
Subject: [PATCH 3/4] Code review feedback

---
 src/compiler/binder.ts        |  4 ++--
 src/compiler/checker.ts       |  6 +++---
 src/compiler/emitter.ts       | 18 +++++++++---------
 src/compiler/parser.ts        | 20 ++++++++++++++------
 src/services/navigationBar.ts |  2 +-
 src/services/services.ts      | 15 +++++++--------
 6 files changed, 36 insertions(+), 29 deletions(-)

diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts
index fe3009da3a..cdc868f408 100644
--- a/src/compiler/binder.ts
+++ b/src/compiler/binder.ts
@@ -18,7 +18,7 @@ module ts {
             return ModuleInstanceState.NonInstantiated;
         }
         // 2. const enum declarations don't make module instantiated
-        else if (node.kind === SyntaxKind.EnumDeclaration && isConstEnumDeclaration(<EnumDeclaration>node)) {
+        else if (isConstEnumDeclaration(node)) {
             return ModuleInstanceState.ConstEnumOnly;
         }
         // 3. non - exported import declarations
@@ -402,7 +402,7 @@ module ts {
                     bindDeclaration(<Declaration>node, SymbolFlags.TypeAlias, SymbolFlags.TypeAliasExcludes, /*isBlockScopeContainer*/ false);
                     break;
                 case SyntaxKind.EnumDeclaration:
-                    if (isConstEnumDeclaration(<EnumDeclaration>node)) {
+                    if (isConst(node)) {
                         bindDeclaration(<Declaration>node, SymbolFlags.ConstEnum, SymbolFlags.ConstEnumExcludes, /*isBlockScopeContainer*/ false);
                     }
                     else {
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 5a990d4e9d..ec075dbce4 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -7940,7 +7940,7 @@ module ts {
                 var enumType = getDeclaredTypeOfSymbol(enumSymbol);
                 var autoValue = 0;
                 var ambient = isInAmbientContext(node);
-                var enumIsConst = isConstEnumDeclaration(node);
+                var enumIsConst = isConst(node);
 
                 forEach(node.members, member => {
                     // TODO(jfreeman): Check that it is not a computed name
@@ -8111,10 +8111,10 @@ module ts {
             var firstDeclaration = getDeclarationOfKind(enumSymbol, node.kind);
             if (node === firstDeclaration) {
                 if (enumSymbol.declarations.length > 1) {
-                    var enumIsConst = isConstEnumDeclaration(node);
+                    var enumIsConst = isConst(node);
                     // check that const is placed\omitted on all enum declarations
                     forEach(enumSymbol.declarations, decl => {
-                        if (isConstEnumDeclaration(<EnumDeclaration>decl) !== enumIsConst) {
+                        if (isConstEnumDeclaration(decl) !== enumIsConst) {
                             error(decl.name, Diagnostics.Enum_declarations_must_all_be_const_or_non_const);
                         }
                     });
diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts
index f61d4403ee..937b64979e 100644
--- a/src/compiler/emitter.ts
+++ b/src/compiler/emitter.ts
@@ -1271,10 +1271,10 @@ module ts {
                 write(" ");
                 endPos = emitToken(SyntaxKind.OpenParenToken, endPos);
                 if (node.declarations) {
-                    if (node.declarations[0] && node.declarations[0].flags & NodeFlags.Let) {
+                    if (node.declarations[0] && isLet(node.declarations[0])) {
                         emitToken(SyntaxKind.LetKeyword, endPos);
                     }
-                    else if (node.declarations[0] && node.declarations[0].flags & NodeFlags.Const) {
+                    else if (node.declarations[0] && isConst(node.declarations[0])) {
                         emitToken(SyntaxKind.ConstKeyword, endPos);
                     }
                     else {
@@ -1299,7 +1299,7 @@ module ts {
                 write(" ");
                 endPos = emitToken(SyntaxKind.OpenParenToken, endPos);
                 if (node.declaration) {
-                    if (node.declaration.flags & NodeFlags.Let) {
+                    if (isLet(node.declaration)) {
                         emitToken(SyntaxKind.LetKeyword, endPos);
                     }
                     else {
@@ -1445,10 +1445,10 @@ module ts {
             function emitVariableStatement(node: VariableStatement) {
                 emitLeadingComments(node);
                 if (!(node.flags & NodeFlags.Export)) {
-                    if (node.flags & NodeFlags.Let) {
+                    if (isLet(node)) {
                         write("let ");
                     }
-                    else if (node.flags & NodeFlags.Const) {
+                    else if (isConst(node)) {
                         write("const ");
                     }
                     else {
@@ -1901,7 +1901,7 @@ module ts {
 
             function emitEnumDeclaration(node: EnumDeclaration) {
                 // const enums are completely erased during compilation.
-                var isConstEnum = isConstEnumDeclaration(node);
+                var isConstEnum = isConst(node);
                 if (isConstEnum && !compilerOptions.preserveConstEnums) {
                     return;
                 }
@@ -2754,7 +2754,7 @@ module ts {
                 if (resolver.isDeclarationVisible(node)) {
                     emitJsDocComments(node);
                     emitDeclarationFlags(node);
-                    if (isConstEnumDeclaration(node)) {
+                    if (isConst(node)) {
                         write("const ")
                     }
                     write("enum ");
@@ -3041,10 +3041,10 @@ module ts {
                 if (hasDeclarationWithEmit) {
                     emitJsDocComments(node);
                     emitDeclarationFlags(node);
-                    if (node.flags & NodeFlags.Let) {
+                    if (isLet(node)) {
                         write("let ");
                     }
-                    else if (node.flags & NodeFlags.Const) {
+                    else if (isConst(node)) {
                         write("const ");
                     }
                     else {
diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts
index 4849cb8c89..01a5f05229 100644
--- a/src/compiler/parser.ts
+++ b/src/compiler/parser.ts
@@ -116,8 +116,16 @@ module ts {
         return (file.flags & NodeFlags.DeclarationFile) !== 0;
     }
 
-    export function isConstEnumDeclaration(node: EnumDeclaration): boolean {
-        return (node.flags & NodeFlags.Const) !== 0;
+    export function isConstEnumDeclaration(node: Declaration): boolean {
+        return node.kind === SyntaxKind.EnumDeclaration && !!(node.flags & NodeFlags.Const);
+    }
+
+    export function isConst(node: Declaration): boolean {
+        return !!(node.flags & NodeFlags.Const);
+    }
+
+    export function isLet(node: Declaration): boolean {
+        return !!(node.flags & NodeFlags.Let);
     }
 
     export function isPrologueDirective(node: Node): boolean {
@@ -3480,18 +3488,18 @@ module ts {
                 grammarErrorOnNode(node, Diagnostics.Variable_declaration_list_cannot_be_empty);
             }
             if (languageVersion < ScriptTarget.ES6) {
-                if (node.flags & NodeFlags.Let) {
+                if (isLet(node)) {
                     grammarErrorOnNode(node, Diagnostics.let_declarations_are_only_available_when_targeting_ECMAScript_6_and_higher);
                 }
-                else if (node.flags & NodeFlags.Const) {
+                else if (isConst(node)) {
                     grammarErrorOnNode(node, Diagnostics.const_declarations_are_only_available_when_targeting_ECMAScript_6_and_higher);
                 }
             }
             else if (!allowLetAndConstDeclarations) {
-                if (node.flags & NodeFlags.Let) {
+                if (isLet(node)) {
                     grammarErrorOnNode(node, Diagnostics.let_declarations_can_only_be_declared_inside_a_block);
                 }
-                else if (node.flags & NodeFlags.Const) {
+                else if (isConst(node)) {
                     grammarErrorOnNode(node, Diagnostics.const_declarations_can_only_be_declared_inside_a_block);
                 }
             }
diff --git a/src/services/navigationBar.ts b/src/services/navigationBar.ts
index b8106fc18d..fd3ea13ce6 100644
--- a/src/services/navigationBar.ts
+++ b/src/services/navigationBar.ts
@@ -235,7 +235,7 @@ module ts.NavigationBar {
                     return createItem(node, getTextOfNode((<FunctionLikeDeclaration>node).name), ts.ScriptElementKind.functionElement);
 
                 case SyntaxKind.VariableDeclaration:
-                    if (node.flags & NodeFlags.Const) {
+                    if (isConst(node)) {
                         return createItem(node, getTextOfNode((<VariableDeclaration>node).name), ts.ScriptElementKind.constantElement);
                     }
                     else if (node.flags & NodeFlags.Let) {
diff --git a/src/services/services.ts b/src/services/services.ts
index 8d48f0bfe1..bf9bdb0ee7 100644
--- a/src/services/services.ts
+++ b/src/services/services.ts
@@ -2859,7 +2859,7 @@ module ts {
                 if (isFirstDeclarationOfSymbolParameter(symbol)) {
                     return ScriptElementKind.parameterElement;
                 }
-                else if (symbol.valueDeclaration && symbol.valueDeclaration.flags & NodeFlags.Const) {
+                else if (symbol.valueDeclaration && isConst(symbol.valueDeclaration)) {
                     return ScriptElementKind.constantElement;
                 }
                 else if (forEach(symbol.declarations, declaration => declaration.flags & NodeFlags.Let)) {
@@ -2920,11 +2920,11 @@ module ts {
                 case SyntaxKind.InterfaceDeclaration: return ScriptElementKind.interfaceElement;
                 case SyntaxKind.TypeAliasDeclaration: return ScriptElementKind.typeElement;
                 case SyntaxKind.EnumDeclaration: return ScriptElementKind.enumElement;
-                case SyntaxKind.VariableDeclaration: return node.flags & NodeFlags.Const ?
-                    ScriptElementKind.constantElement :
-                    node.flags & NodeFlags.Let ?
-                    ScriptElementKind.letElement :
-                    ScriptElementKind.variableElement;
+                case SyntaxKind.VariableDeclaration: return isConst(node)
+                    ? ScriptElementKind.constantElement
+                    : node.flags & NodeFlags.Let
+                        ? ScriptElementKind.letElement
+                        : ScriptElementKind.variableElement;
                 case SyntaxKind.FunctionDeclaration: return ScriptElementKind.functionElement;
                 case SyntaxKind.GetAccessor: return ScriptElementKind.memberGetAccessorElement;
                 case SyntaxKind.SetAccessor: return ScriptElementKind.memberSetAccessorElement;
@@ -3099,8 +3099,7 @@ module ts {
             }
             if (symbolFlags & SymbolFlags.Enum) {
                 addNewLineIfDisplayPartsExist();
-                if (forEach(symbol.declarations, declaration =>
-                    declaration.kind === SyntaxKind.EnumDeclaration && isConstEnumDeclaration(<EnumDeclaration>declaration))) {
+                if (forEach(symbol.declarations, declaration => isConstEnumDeclaration(declaration))) {
                     displayParts.push(keywordPart(SyntaxKind.ConstKeyword));
                     displayParts.push(spacePart());
                 }

From 0877a650c35a740cd17ba732d896037f3d551fa2 Mon Sep 17 00:00:00 2001
From: Sheetal Nandi <shkamat@microsoft.com>
Date: Wed, 12 Nov 2014 18:42:31 -0800
Subject: [PATCH 4/4] Code review feedback

---
 src/services/navigationBar.ts                 |  4 +--
 src/services/services.ts                      | 10 +++----
 .../fourslash/completionEntryForConst.ts      |  2 +-
 .../constQuickInfoAndCompletionList.ts        | 26 +++++++++----------
 tests/cases/fourslash/navbar_const.ts         |  2 +-
 tests/cases/fourslash/navigateItemsConst.ts   |  4 +--
 .../fourslash/quickInfoForConstDeclaration.ts |  2 +-
 7 files changed, 25 insertions(+), 25 deletions(-)

diff --git a/src/services/navigationBar.ts b/src/services/navigationBar.ts
index fd3ea13ce6..be865a6d23 100644
--- a/src/services/navigationBar.ts
+++ b/src/services/navigationBar.ts
@@ -236,9 +236,9 @@ module ts.NavigationBar {
 
                 case SyntaxKind.VariableDeclaration:
                     if (isConst(node)) {
-                        return createItem(node, getTextOfNode((<VariableDeclaration>node).name), ts.ScriptElementKind.constantElement);
+                        return createItem(node, getTextOfNode((<VariableDeclaration>node).name), ts.ScriptElementKind.constElement);
                     }
-                    else if (node.flags & NodeFlags.Let) {
+                    else if (isLet(node)) {
                         return createItem(node, getTextOfNode((<VariableDeclaration>node).name), ts.ScriptElementKind.letElement);
                     }
                     else {
diff --git a/src/services/services.ts b/src/services/services.ts
index bf9bdb0ee7..0a2eb21ced 100644
--- a/src/services/services.ts
+++ b/src/services/services.ts
@@ -1224,7 +1224,7 @@ module ts {
 
         static alias = "alias";
 
-        static constantElement = "constant";
+        static constElement = "const";
 
         static letElement = "let";
     }
@@ -2860,9 +2860,9 @@ module ts {
                     return ScriptElementKind.parameterElement;
                 }
                 else if (symbol.valueDeclaration && isConst(symbol.valueDeclaration)) {
-                    return ScriptElementKind.constantElement;
+                    return ScriptElementKind.constElement;
                 }
-                else if (forEach(symbol.declarations, declaration => declaration.flags & NodeFlags.Let)) {
+                else if (forEach(symbol.declarations, declaration => isLet(declaration))) {
                     return ScriptElementKind.letElement;
                 }
                 return isLocalVariableOrFunction(symbol) ? ScriptElementKind.localVariableElement : ScriptElementKind.variableElement;
@@ -2921,7 +2921,7 @@ module ts {
                 case SyntaxKind.TypeAliasDeclaration: return ScriptElementKind.typeElement;
                 case SyntaxKind.EnumDeclaration: return ScriptElementKind.enumElement;
                 case SyntaxKind.VariableDeclaration: return isConst(node)
-                    ? ScriptElementKind.constantElement
+                    ? ScriptElementKind.constElement
                     : node.flags & NodeFlags.Let
                         ? ScriptElementKind.letElement
                         : ScriptElementKind.variableElement;
@@ -3023,7 +3023,7 @@ module ts {
                             switch (symbolKind) {
                                 case ScriptElementKind.memberVariableElement:
                                 case ScriptElementKind.variableElement:
-                                case ScriptElementKind.constantElement:
+                                case ScriptElementKind.constElement:
                                 case ScriptElementKind.parameterElement:
                                 case ScriptElementKind.localVariableElement:
                                     // If it is call or construct signature of lambda's write type name
diff --git a/tests/cases/fourslash/completionEntryForConst.ts b/tests/cases/fourslash/completionEntryForConst.ts
index f6b7cc42d6..dc2b2358b0 100644
--- a/tests/cases/fourslash/completionEntryForConst.ts
+++ b/tests/cases/fourslash/completionEntryForConst.ts
@@ -4,4 +4,4 @@
 /////**/
 
 goTo.marker();
-verify.completionListContains("c", /*text*/ undefined, /*documentation*/ undefined, "constant");
\ No newline at end of file
+verify.completionListContains("c", "(const) c: string", /*documentation*/ undefined, "const");
\ No newline at end of file
diff --git a/tests/cases/fourslash/constQuickInfoAndCompletionList.ts b/tests/cases/fourslash/constQuickInfoAndCompletionList.ts
index 421a9819d4..59a793df40 100644
--- a/tests/cases/fourslash/constQuickInfoAndCompletionList.ts
+++ b/tests/cases/fourslash/constQuickInfoAndCompletionList.ts
@@ -10,28 +10,28 @@
 ////    /*7*/
 ////}
 goTo.marker('1');
-verify.quickInfoIs("(constant) a: number");
+verify.quickInfoIs("(const) a: number");
 
 goTo.marker('2');
-verify.completionListContains("a", "(constant) a: number");
-verify.quickInfoIs("(constant) a: number");
+verify.completionListContains("a", "(const) a: number");
+verify.quickInfoIs("(const) a: number");
 
 goTo.marker('3');
-verify.completionListContains("a", "(constant) a: number");
+verify.completionListContains("a", "(const) a: number");
 
 goTo.marker('4');
-verify.quickInfoIs("(constant) b: number");
+verify.quickInfoIs("(const) b: number");
 
 goTo.marker('5');
-verify.completionListContains("a", "(constant) a: number");
-verify.completionListContains("b", "(constant) b: number");
-verify.quickInfoIs("(constant) b: number");
+verify.completionListContains("a", "(const) a: number");
+verify.completionListContains("b", "(const) b: number");
+verify.quickInfoIs("(const) b: number");
 
 goTo.marker('6');
-verify.completionListContains("a", "(constant) a: number");
-verify.completionListContains("b", "(constant) b: number");
-verify.quickInfoIs("(constant) a: number");
+verify.completionListContains("a", "(const) a: number");
+verify.completionListContains("b", "(const) b: number");
+verify.quickInfoIs("(const) a: number");
 
 goTo.marker('7');
-verify.completionListContains("a", "(constant) a: number");
-verify.completionListContains("b", "(constant) b: number");
\ No newline at end of file
+verify.completionListContains("a", "(const) a: number");
+verify.completionListContains("b", "(const) b: number");
\ No newline at end of file
diff --git a/tests/cases/fourslash/navbar_const.ts b/tests/cases/fourslash/navbar_const.ts
index ede2a9cd1d..6c0738747f 100644
--- a/tests/cases/fourslash/navbar_const.ts
+++ b/tests/cases/fourslash/navbar_const.ts
@@ -1,6 +1,6 @@
 /// <reference path="fourslash.ts" />
 
-//// {| "itemName": "c", "kind": "constant", "parentName": "" |}const c = 0;
+//// {| "itemName": "c", "kind": "const", "parentName": "" |}const c = 0;
 
 test.markers().forEach(marker => {
     verify.getScriptLexicalStructureListContains(
diff --git a/tests/cases/fourslash/navigateItemsConst.ts b/tests/cases/fourslash/navigateItemsConst.ts
index 6f0fdf717f..d5ccb31066 100644
--- a/tests/cases/fourslash/navigateItemsConst.ts
+++ b/tests/cases/fourslash/navigateItemsConst.ts
@@ -1,8 +1,8 @@
 /// <reference path="fourslash.ts" />
 
-////{| "itemName": "c", "kind": "constant", "parentName": "" |}const c = 10;
+////{| "itemName": "c", "kind": "const", "parentName": "" |}const c = 10;
 ////function foo() {
-////    {| "itemName": "d", "kind": "constant", "parentName": "foo" |}const d = 10;
+////    {| "itemName": "d", "kind": "const", "parentName": "foo" |}const d = 10;
 ////}
 
 test.markers().forEach(marker => {
diff --git a/tests/cases/fourslash/quickInfoForConstDeclaration.ts b/tests/cases/fourslash/quickInfoForConstDeclaration.ts
index dc234b0405..2b1f108c57 100644
--- a/tests/cases/fourslash/quickInfoForConstDeclaration.ts
+++ b/tests/cases/fourslash/quickInfoForConstDeclaration.ts
@@ -3,4 +3,4 @@
 ////const /**/c = 0 ;
 
 goTo.marker();
-verify.quickInfoIs("(constant) c: number");
\ No newline at end of file
+verify.quickInfoIs("(const) c: number");
\ No newline at end of file