Completion list show correct entry for function expression and class expression

src/compiler/checker.ts

@@ -12170,20 +12170,20 @@ namespace ts {
                         case SyntaxKind.EnumDeclaration:
                             copySymbols(getSymbolOfNode(location).exports, meaning & SymbolFlags.EnumMember);
                             break;
-                        case SyntaxKind.ClassExpression:
-                            if ((<ClassExpression>location).name) {
-                                copySymbol(location.symbol, meaning);
-                            }
-                            // Fall through
                         case SyntaxKind.ClassDeclaration:
                         case SyntaxKind.InterfaceDeclaration:
                             if (!(memberFlags & NodeFlags.Static)) {
                                 copySymbols(getSymbolOfNode(location).members, meaning & SymbolFlags.Type);
                             }
                             break;
                         case SyntaxKind.FunctionExpression:
-                            if ((<FunctionExpression>location).name) {
-                                copySymbol(location.symbol, meaning);
+                        case SyntaxKind.ClassExpression:
+                            let name = (<FunctionExpression|ClassExpression>location).name;
+                            if (name) {
+                                let symbol = location.symbol;
+                                if (symbol.flags & meaning && !hasProperty(symbols, name.text)) {
+                                    symbols[name.text] = symbol;
+                                }
                             }
                             break;
                     }

src/services/services.ts

@@ -1423,6 +1423,9 @@ namespace ts {
         // class X {}
         export const classElement = "class";
 
+        // var x = class X {}
+        export const localClassElement = "local class";
+
         // interface Y {}
         export const interfaceElement = "interface";
 
@@ -2807,6 +2810,22 @@ namespace ts {
                     }
                 }
 
+                // Special case for function expression and class expression because despite sometimes having a name, the binder
+                // binds them to a symbol with the name "__function" and "__class" respectively. However, for completion entry, we want
+                // to display its declared name rather than "__function" and "__class".
+                //      var x = function foo () {
+                //          fo$  <- completion list should contain local name "foo"
+                //      }
+                //      foo$ <- completion list should not contain "foo"
+                if (displayName === "__function" || displayName === "__class") {
+                    displayName = symbol.declarations[0].name.getText();
+
+                    // At this point, we expect that all completion list entries have declared name including function expression
+                    // because when we gather all relevant symbols, we check that the function expression must have declared name
+                    // before adding the symbol into our symbols table. (see: getSymbolsInScope)
+                    Debug.assert(displayName !== undefined,"Expected this function expression to have declared name");
+                }
+
                 let firstCharCode = displayName.charCodeAt(0);
                 // First check of the displayName is not external module; if it is an external module, it is not valid entry
                 if ((symbol.flags & SymbolFlags.Namespace) && (firstCharCode === CharacterCodes.singleQuote || firstCharCode === CharacterCodes.doubleQuote)) {
@@ -3552,7 +3571,8 @@ namespace ts {
         function getSymbolKind(symbol: Symbol, location: Node): string {
             let flags = symbol.getFlags();
 
-            if (flags & SymbolFlags.Class) return ScriptElementKind.classElement;
+            if (flags & SymbolFlags.Class) return symbol.declarations[0].kind === SyntaxKind.ClassExpression ?
+                ScriptElementKind.localClassElement : ScriptElementKind.classElement;
             if (flags & SymbolFlags.Enum) return ScriptElementKind.enumElement;
             if (flags & SymbolFlags.TypeAlias) return ScriptElementKind.typeElement;
             if (flags & SymbolFlags.Interface) return ScriptElementKind.interfaceElement;
@@ -3761,7 +3781,16 @@ namespace ts {
                 }
             }
             if (symbolFlags & SymbolFlags.Class && !hasAddedSymbolInfo) {
-                displayParts.push(keywordPart(SyntaxKind.ClassKeyword));
+                // Special case for class expressions because we would like to indicate that
+                // the class name is local to the class body (similar to function expression)
+                //      (local class) class <className>
+                if (symbol.getName() === "__class") {
+                    pushTypePart(ScriptElementKind.localClassElement);
+                }
+                else {
+                    // Class declaration has name which is not local.
+                    displayParts.push(keywordPart(SyntaxKind.ClassKeyword));
+                }
                 displayParts.push(spacePart());
                 addFullSymbolName(symbol);
                 writeTypeParametersOfSymbol(symbol, sourceFile);

tests/cases/fourslash/completionListInNamedClassExpression.ts

@@ -0,0 +1,14 @@
+///<reference path="fourslash.ts" />
+
+//// var x = class myClass {
+////    getClassName (){
+////        m/*0*/
+////    }
+////    /*1*/
+//// }
+
+goTo.marker("0");
+verify.completionListContains("myClass", "(local class) myClass", /*documentation*/ undefined, "local class");
+
+goTo.marker("1");
+verify.completionListContains("myClass", "(local class) myClass", /*documentation*/ undefined, "local class");

tests/cases/fourslash/completionListInNamedClassExpressionWithShadowing.ts

@@ -0,0 +1,34 @@
+///<reference path="fourslash.ts" />
+
+//// class myClass { /*0*/ }
+//// /*1*/
+//// var x = class myClass {
+////    getClassName (){
+////        m/*2*/
+////    }
+////    /*3*/
+//// }
+//// var y = class {
+////    getSomeName() {
+////        /*4*/
+////    }
+////    /*5*/
+//// }
+
+goTo.marker("0");
+verify.completionListContains("myClass", "class myClass", /*documentation*/ undefined, "class");
+
+goTo.marker("1");
+verify.completionListContains("myClass", "class myClass", /*documentation*/ undefined, "class");
+
+goTo.marker("2");
+verify.completionListContains("myClass", "(local class) myClass", /*documentation*/ undefined, "local class");
+
+goTo.marker("3");
+verify.completionListContains("myClass", "(local class) myClass", /*documentation*/ undefined, "local class");
+
+goTo.marker("4");
+verify.completionListContains("myClass", "class myClass", /*documentation*/ undefined, "class");
+
+goTo.marker("5");
+verify.completionListContains("myClass", "class myClass", /*documentation*/ undefined, "class");

tests/cases/fourslash/completionListInNamedFunctionExpression1.ts

@@ -0,0 +1,8 @@
+///<reference path="fourslash.ts" />
+
+//// var x = function foo() {
+////    /*1*/
+//// }
+
+goTo.marker("1");
+verify.completionListContains("foo", "(local function) foo(): void", /*documentation*/ undefined, "local function");

tests/cases/fourslash/completionListInNamedFunctionExpressionWithShadowing.ts

@@ -0,0 +1,19 @@
+///<reference path="fourslash.ts" />
+
+//// function foo() {}
+//// /*0*/
+//// var x = function foo() {
+////    /*1*/
+//// }
+//// var y = function () {
+////    /*2*/
+//// }
+
+goTo.marker("0");
+verify.completionListContains("foo", "function foo(): void", /*documentation*/ undefined, "function");
+
+goTo.marker("1");
+verify.completionListContains("foo", "(local function) foo(): void", /*documentation*/ undefined, "local function");
+
+goTo.marker("2");
+verify.completionListContains("foo", "function foo(): void", /*documentation*/ undefined, "function")