From 40824ed8a58bede88cc9ab59b5e29ff70d4597a3 Mon Sep 17 00:00:00 2001
From: Paul van Brenk <paul.van.brenk@microsoft.com>
Date: Wed, 4 Feb 2015 16:40:22 -0800
Subject: [PATCH] Added templates, assignement and arrays + tests.

---
 src/services/services.ts                      | 35 +++++++++++++++----
 ...stBuilderLocations_VariableDeclarations.ts | 24 ++++++++++---
 2 files changed, 48 insertions(+), 11 deletions(-)

diff --git a/src/services/services.ts b/src/services/services.ts
index b58e28a8b26..677af16bdc4 100644
--- a/src/services/services.ts
+++ b/src/services/services.ts
@@ -2370,6 +2370,7 @@ module ts {
                 if (containingObjectLiteral) {
                     // Object literal expression, look up possible property names from contextual type
                     isMemberCompletion = true;
+                    isNewIdentifierLocation = true;
 
                     var contextualType = typeInfoResolver.getContextualType(containingObjectLiteral);
                     if (!contextualType) {
@@ -2405,6 +2406,7 @@ module ts {
             return {
                 isMemberCompletion,
                 isNewIdentifierLocation,
+                isBuilder : isNewIdentifierDefinitionLocation,  // temporary property used to match VS implementation
                 entries: activeCompletionSession.entries
             };
 
@@ -2438,13 +2440,20 @@ module ts {
                     switch (previousToken.kind) {
                         case SyntaxKind.CommaToken:
                             return containingNodeKind === SyntaxKind.CallExpression                         // func( a, |
-                                || containingNodeKind === SyntaxKind.Constructor                            // constructor( a, |
-                                || previousToken.parent.parent.parent.kind === SyntaxKind.VariableDeclaration;     // var x = (a, b| <- this can be a lambda expression
+                                || containingNodeKind === SyntaxKind.Constructor                            // constructor( a, |   public, protected, private keywords are allowed here, so show completion
+                                || containingNodeKind === SyntaxKind.NewExpression                          // new C(a, |
+                                || containingNodeKind === SyntaxKind.ArrayLiteralExpression                 // [a, |
+                                || containingNodeKind === SyntaxKind.BinaryExpression;                      // var x = (a, |
+
               
                         case SyntaxKind.OpenParenToken:
-                            return containingNodeKind === SyntaxKind.CallExpression                         // func( |
-                                || containingNodeKind === SyntaxKind.Constructor                            // constructor( |
-                                || previousToken.parent.parent.kind === SyntaxKind.VariableDeclaration;     // var x = (a| <- this can be a lambda expression
+                            return containingNodeKind === SyntaxKind.CallExpression               // func( |
+                                || containingNodeKind === SyntaxKind.Constructor                  // constructor( |
+                                || containingNodeKind === SyntaxKind.NewExpression                // new C(a|
+                                || containingNodeKind === SyntaxKind.ParenthesizedExpression;     // var x = (a|
+
+                        case SyntaxKind.OpenBracketToken:
+                            return containingNodeKind === SyntaxKind.ArrayLiteralExpression;                 // [ |
 
                         case SyntaxKind.ModuleKeyword:                               // module | 
                             return true;
@@ -2456,7 +2465,14 @@ module ts {
                             return containingNodeKind === SyntaxKind.ClassDeclaration;  // class A{ |
 
                         case SyntaxKind.EqualsToken:
-                            return containingNodeKind === SyntaxKind.VariableDeclaration; // var x = a| <- this can be lambda expression
+                            return containingNodeKind === SyntaxKind.VariableDeclaration // var x = a|
+                            || containingNodeKind === SyntaxKind.BinaryExpression;       // x = a|
+
+                        case SyntaxKind.TemplateHead:
+                            return containingNodeKind === SyntaxKind.TemplateExpression; // `aa ${|
+
+                        case SyntaxKind.TemplateMiddle:
+                            return containingNodeKind === SyntaxKind.TemplateSpan; // `aa ${10} dd ${|
 
                         case SyntaxKind.PublicKeyword:
                         case SyntaxKind.PrivateKeyword:
@@ -2596,6 +2612,9 @@ module ts {
                         case SyntaxKind.GetKeyword:
                         case SyntaxKind.SetKeyword:
                         case SyntaxKind.ImportKeyword:
+                        case SyntaxKind.LetKeyword:
+                        case SyntaxKind.ConstKeyword:
+                        case SyntaxKind.YieldKeyword:
                             return true;
                     }
 
@@ -2607,7 +2626,9 @@ module ts {
                         case "function":
                         case "var":
                         case "static":
-                            // TODO: add let and const
+                        case "let":
+                        case "const":
+                        case "yield":
                             return true;
                     }
                 }
diff --git a/tests/cases/fourslash/completionListBuilderLocations_VariableDeclarations.ts b/tests/cases/fourslash/completionListBuilderLocations_VariableDeclarations.ts
index 5c222f901f6..45f16090fd8 100644
--- a/tests/cases/fourslash/completionListBuilderLocations_VariableDeclarations.ts
+++ b/tests/cases/fourslash/completionListBuilderLocations_VariableDeclarations.ts
@@ -1,15 +1,31 @@
 /// <reference path='fourslash.ts' />
 
-//// var x = a/*var1*/
+////var x = a/*var1*/
 
-//// var x = (b/*var2*/
+////var x = (b/*var2*/
 
-//// var x = (c, d/*var3*/
+////var x = (c, d/*var3*/
 
 //// var y : any = "", x = a/*var4*/
 
 //// var y : any = "", x = (a/*var5*/
-                                   
+
+////class C{}
+////var y = new C( 
+
+//// class C{}
+//// var y = new C(0, /*var7*/
+
+////var y = [/*var8*/
+
+////var y = [0, /*var9*/
+
+////var y = `${/*var10*/
+
+////var y = `${10} dd ${ /*var11*/
+
+////var y = 10; y=/*var12*/
+
 test.markers().forEach((m) => {
     goTo.position(m.position, m.fileName);
     verify.completionListAllowsNewIdentifier();