Navigation bar items in methods

src/services/navigationBar.ts

@@ -154,6 +154,20 @@ namespace ts.NavigationBar {
             for (let node of nodes) {
                 switch (node.kind) {
                     case SyntaxKind.ClassDeclaration:
+                        topLevelNodes.push(node);
+                        for (const member of (<ClassDeclaration>node).members) {
+                            if (member.kind === SyntaxKind.MethodDeclaration || member.kind === SyntaxKind.Constructor) {
+                                type FunctionLikeMember = MethodDeclaration | ConstructorDeclaration;
+                                if ((<FunctionLikeMember>member).body) {
+                                    // We do not include methods that does not have child functions in it, because of duplications.
+                                    if (hasNamedFunctionDeclarations((<Block>(<FunctionLikeMember>member).body).statements)) {
+                                        topLevelNodes.push(member);
+                                    }
+                                    addTopLevelNodes((<Block>(<MethodDeclaration>member).body).statements, topLevelNodes);
+                                }
+                            }
+                        }
+                        break;
                     case SyntaxKind.EnumDeclaration:
                     case SyntaxKind.InterfaceDeclaration:
                         topLevelNodes.push(node);
@@ -176,23 +190,35 @@ namespace ts.NavigationBar {
             }
         }
 
+        function hasNamedFunctionDeclarations(nodes: NodeArray<Statement>) {
+            if (forEach(nodes, s => s.kind === SyntaxKind.FunctionDeclaration && !isEmpty((<FunctionDeclaration>s).name.text))) {
+                return true;
+            }
+        }
+
         function isTopLevelFunctionDeclaration(functionDeclaration: FunctionLikeDeclaration) {
             if (functionDeclaration.kind === SyntaxKind.FunctionDeclaration) {
                 // A function declaration is 'top level' if it contains any function declarations 
                 // within it. 
                 if (functionDeclaration.body && functionDeclaration.body.kind === SyntaxKind.Block) {
                     // Proper function declarations can only have identifier names
-                    if (forEach((<Block>functionDeclaration.body).statements,
-                        s => s.kind === SyntaxKind.FunctionDeclaration && !isEmpty((<FunctionDeclaration>s).name.text))) {
-
+                    if (hasNamedFunctionDeclarations((<Block>functionDeclaration.body).statements)) {
                         return true;
                     }
 
-                    // Or if it is not parented by another function.  i.e all functions
-                    // at module scope are 'top level'.
+                    // Or if it is not parented by another function (except for parent functions that
+                    // are methods and constructors). I.e all functions at module scope are 'top level'.
                     if (!isFunctionBlock(functionDeclaration.parent)) {
                         return true;
                     }
+                    else {
+                        const grandParentKind = functionDeclaration.parent.parent.kind;
+                        if (grandParentKind === SyntaxKind.MethodDeclaration ||
+                            grandParentKind === SyntaxKind.Constructor) {
+
+                            return true;
+                        }
+                    }
                 }
             }
 
@@ -370,6 +396,10 @@ namespace ts.NavigationBar {
                 case SyntaxKind.ClassDeclaration:
                     return createClassItem(<ClassDeclaration>node);
 
+                case SyntaxKind.MethodDeclaration:
+                case SyntaxKind.Constructor:
+                    return createMemberFunctionLikeItem(<MethodDeclaration | ConstructorDeclaration>node);
+
                 case SyntaxKind.EnumDeclaration:
                     return createEnumItem(<EnumDeclaration>node);
 
@@ -407,7 +437,7 @@ namespace ts.NavigationBar {
 
             function createModuleItem(node: ModuleDeclaration): NavigationBarItem {
                 let moduleName = getModuleName(node);
-                
+
                 let childItems = getItemsWorker(getChildNodes((<Block>getInnermostModule(node).body).statements), createChildItem);
 
                 return getNavigationBarItem(moduleName,
@@ -422,7 +452,7 @@ namespace ts.NavigationBar {
                 if (node.body && node.body.kind === SyntaxKind.Block) {
                     let childItems = getItemsWorker(sortNodes((<Block>node.body).statements), createChildItem);
 
-                    return getNavigationBarItem(!node.name ? "default": node.name.text ,
+                    return getNavigationBarItem(!node.name ? "default": node.name.text,
                         ts.ScriptElementKind.functionElement,
                         getNodeModifiers(node),
                         [getNodeSpan(node)],
@@ -433,6 +463,31 @@ namespace ts.NavigationBar {
                 return undefined;
             }
 
+            function createMemberFunctionLikeItem(node: MethodDeclaration | ConstructorDeclaration) {
+                if (node.body && node.body.kind === SyntaxKind.Block) {
+                    let childItems = getItemsWorker(sortNodes((<Block>node.body).statements), createChildItem);
+                    let scriptElementKind: string;
+                    let memberFunctionName: string;
+                    if (node.kind === SyntaxKind.MethodDeclaration) {
+                        memberFunctionName = getPropertyNameForPropertyNameNode(node.name);
+                        scriptElementKind = ts.ScriptElementKind.memberFunctionElement;
+                    }
+                    else {
+                        memberFunctionName = "constructor";
+                        scriptElementKind = ts.ScriptElementKind.constructorImplementationElement;
+                    }
+
+                    return getNavigationBarItem(memberFunctionName,
+                        scriptElementKind,
+                        getNodeModifiers(node),
+                        [getNodeSpan(node)],
+                        childItems,
+                        getIndent(node));
+                }
+
+                return undefined;
+            }
+
             function createSourceFileItem(node: SourceFile): ts.NavigationBarItem {
                 let childItems = getItemsWorker(getChildNodes(node.statements), createChildItem);
 

tests/cases/fourslash/navigationBarItemsInsideMethodsAndConstructors.ts

@@ -0,0 +1,42 @@
+/// <reference path="fourslash.ts"/>
+
+////class Class {
+////    constructor() {
+////        {| "itemName": "LocalFunctionInConstructor", "kind": "function", "parentName": "Class"|}function LocalFunctionInConstructor() {
+////
+////        }
+////
+////        {| "itemName": "LocalInterfaceInConstrcutor", "kind": "interface", "parentName": "foo"|}interface LocalInterfaceInConstrcutor {
+////        }
+////
+////        enum LocalEnumInConstructor {
+////            {| "itemName": "LocalEnumMemberInConstructor", "kind": "property", "parentName": "LocalEnumInConstructor"|}LocalEnumMemberInConstructor,
+////        }
+////    }
+////
+////    method() {
+////        {| "itemName": "LocalFunctionInMethod", "kind": "function", "parentName": "foo"|}function LocalFunctionInMethod() {
+////            {| "itemName": "LocalFunctionInLocalFunctionInMethod", "kind": "function", "parentName": "bar"|}function LocalFunctionInLocalFunctionInMethod() {
+////
+////            }
+////        }
+////
+////        {| "itemName": "LocalInterfaceInMethod", "kind": "interface", "parentName": "foo"|}interface LocalInterfaceInMethod {
+////        }
+////
+////        enum LocalEnumInMethod {
+////            {| "itemName": "LocalEnumMemberInMethod", "kind": "property", "parentName": "foo"|}LocalEnumMemberInMethod,
+////        }
+////    }
+////
+////    emptyMethod() { // Non child functions method should not be duplicated
+////
+////    }
+////}
+
+test.markers().forEach((marker) => {
+    verify.getScriptLexicalStructureListContains(marker.data.itemName, marker.data.kind, marker.fileName, marker.data.parentName);
+});
+
+// no other items
+verify.getScriptLexicalStructureListCount(17);