Outlining spans for a standalone block shouldn't have the span of their parent.

Author: CyrusNajmabadi

Jakefile

@@ -58,7 +58,8 @@ var servicesSources = [
     "shims.ts",
     "signatureHelp.ts",
     "utilities.ts",
-    "navigationBar.ts"
+    "navigationBar.ts",
+    "outliningElementsCollector.ts"
 ].map(function (f) {
     return path.join(servicesDirectory, f);
 }));

src/services/outliningElementsCollector.ts

@@ -33,13 +33,14 @@ module ts {
     export module OutliningElementsCollector {
         export function collectElements(sourceFile: SourceFile): OutliningSpan[] {
             var elements: OutliningSpan[] = [];
+            var collapseText = "...";
 
             function addOutliningSpan(hintSpanNode: Node, startElement: Node, endElement: Node, autoCollapse: boolean) {
                 if (hintSpanNode && startElement && endElement) {
                     var span: OutliningSpan = {
                         textSpan: TypeScript.TextSpan.fromBounds(startElement.pos, endElement.end),
                         hintSpan: TypeScript.TextSpan.fromBounds(hintSpanNode.getStart(), hintSpanNode.end),
-                        bannerText: "...",
+                        bannerText: collapseText,
                         autoCollapse: autoCollapse
                     };
                     elements.push(span);
@@ -66,10 +67,39 @@ module ts {
                 }
                 switch (n.kind) {
                     case SyntaxKind.Block:
+                        var parent = n.parent;
+                        var openBrace = findChildOfKind(n, SyntaxKind.OpenBraceToken, sourceFile);
+                        var closeBrace = findChildOfKind(n, SyntaxKind.CloseBraceToken, sourceFile);
+
+                        // Check if the block is standalone, or 'attached' to some parent statement.
+                        // If the latter, we want to collaps the block, but consider its hint span
+                        // to be the entire span of the parent.
+                        if (parent.kind === SyntaxKind.DoStatement ||
+                            parent.kind === SyntaxKind.ForInStatement ||
+                            parent.kind === SyntaxKind.ForStatement ||
+                            parent.kind === SyntaxKind.IfStatement ||
+                            parent.kind === SyntaxKind.WhileStatement ||
+                            parent.kind === SyntaxKind.WithStatement) {
+                            
+                            addOutliningSpan(parent, openBrace, closeBrace, autoCollapse(n));
+                        }
+                        else {
+                            // Block was a standalone block.  In this case we want to only collapse
+                            // the span of the block, independent of any parent span.
+                            var span = TypeScript.TextSpan.fromBounds(n.getStart(), n.end);
+                            elements.push({
+                                textSpan: span,
+                                hintSpan: span,
+                                bannerText: collapseText,
+                                autoCollapse: autoCollapse(n)
+                            });
+                        }
+                        break;
+
+
                     case SyntaxKind.FunctionBlock:
                     case SyntaxKind.ModuleBlock:
                     case SyntaxKind.TryBlock:
-                    case SyntaxKind.TryBlock:
                     case SyntaxKind.CatchBlock:
                     case SyntaxKind.FinallyBlock:
                         var openBrace = findChildOfKind(n, SyntaxKind.OpenBraceToken, sourceFile);