Add IndentGuides for more types of C# blocks.

src/EditorFeatures/Core/Implementation/Structure/AbstractStructureTaggerProvider.cs

@@ -195,10 +195,13 @@ protected sealed override ITaggerEventSource CreateEventSource(ITextView textVie
                     var parentTag = tagSpanStack.Count > 0 ? tagSpanStack.Peek() : null;
                     var tag = CreateTag(parentTag?.Tag, snapshot, region);
 
-                    var tagSpan = new TagSpan<TRegionTag>(spanToCollapse, tag);
+                    if (tag != null)
+                    {
+                        var tagSpan = new TagSpan<TRegionTag>(spanToCollapse, tag);
 
-                    context.AddTag(tagSpan);
-                    tagSpanStack.Push(tagSpan);
+                        context.AddTag(tagSpan);
+                        tagSpanStack.Push(tagSpan);
+                    }
                 }
             }
         }

src/EditorFeatures/Core/Implementation/Structure/VisualStudio14StructureTaggerProvider.cs

@@ -55,6 +55,11 @@ public override int GetHashCode(IOutliningRegionTag obj)
         protected override IOutliningRegionTag CreateTag(
             IOutliningRegionTag parentTag, ITextSnapshot snapshot, BlockSpan region)
         {
+            if (!region.IsCollapsible)
+            {
+                return null;
+            }
+
             return new RoslynOutliningRegionTag(
                 this.TextEditorFactoryService,
                 this.ProjectionBufferFactoryService,

src/EditorFeatures/Next/Structure/VisualStudio15StructureTaggerProvider.cs

@@ -65,7 +65,7 @@ private class RoslynBlockTag : RoslynOutliningRegionTag, IBlockTag
 
             public string Type => ConvertType(BlockSpan.Type);
 
-            public bool IsCollapsible => true;
+            public bool IsCollapsible => BlockSpan.IsCollapsible;
 
             public RoslynBlockTag(
                 ITextEditorFactoryService textEditorFactoryService,
@@ -129,6 +129,8 @@ private string ConvertType(string type)
                     case BlockTypes.Enum:
                     case BlockTypes.Other:
                     case BlockTypes.Xml:
+                    case BlockTypes.LocalFunction:
+                    case BlockTypes.Using:
                     default:
                         return PredefinedStructureTypes.Unknown;
                 }

src/Features/CSharp/Portable/CSharpFeatures.csproj

@@ -60,6 +60,7 @@
     </Compile>
     <Compile Include="AddBraces\CSharpAddBracesCodeFixProvider.cs" />
     <Compile Include="AddBraces\CSharpAddBracesDiagnosticAnalyzer.cs" />
+    <Compile Include="Structure\Providers\BlockSyntaxStructureProvider.cs" />
     <Compile Include="ChangeSignature\ChangeSignatureCodeRefactoringProvider.cs" />
     <Compile Include="ChangeSignature\ChangeSignatureFormattingRule.cs" />
     <Compile Include="ChangeSignature\CSharpChangeSignatureService.cs" />

src/Features/CSharp/Portable/Structure/CSharpBlockStructureProvider.cs

@@ -15,6 +15,7 @@ internal class CSharpBlockStructureProvider : AbstractBlockStructureProvider
 
             builder.Add<AccessorDeclarationSyntax, AccessorDeclarationStructureProvider>();
             builder.Add<AnonymousMethodExpressionSyntax, AnonymousMethodExpressionStructureProvider>();
+            builder.Add<BlockSyntax, BlockSyntaxStructureProvider>();
             builder.Add<ClassDeclarationSyntax, TypeDeclarationStructureProvider, MetadataAsSource.MetadataTypeDeclarationStructureProvider>();
             builder.Add<CompilationUnitSyntax, CompilationUnitStructureProvider>();
             builder.Add<ConstructorDeclarationSyntax, ConstructorDeclarationStructureProvider, MetadataAsSource.MetadataConstructorDeclarationStructureProvider>();

src/Features/CSharp/Portable/Structure/Providers/BlockSyntaxStructureProvider.cs

+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using System;
+using System.Threading;
+using Microsoft.CodeAnalysis.CSharp.Extensions;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Structure;
+using Microsoft.CodeAnalysis.Text;
+
+namespace Microsoft.CodeAnalysis.CSharp.Structure
+{
+    internal class BlockSyntaxStructureProvider : AbstractSyntaxNodeStructureProvider<BlockSyntax>
+    {
+        protected override void CollectBlockSpans(
+            BlockSyntax node, ArrayBuilder<BlockSpan> spans, CancellationToken cancellationToken)
+        {
+            var parentKind = node.Parent.Kind();
+            if (node.Parent is StatementSyntax ||
+                parentKind == SyntaxKind.CatchClause ||
+                parentKind == SyntaxKind.FinallyClause ||
+                parentKind == SyntaxKind.ElseClause)
+            {
+                spans.Add(new BlockSpan(
+                    isCollapsible: node.IsParentKind(SyntaxKind.LocalFunctionStatement), 
+                    textSpan: GetTextSpan(node), 
+                    hintSpan: node.Parent.Span,
+                    type: GetType(node.Parent)));
+            }
+        }
+
+        private TextSpan GetTextSpan(BlockSyntax node)
+        {
+            var previousToken = node.GetFirstToken().GetPreviousToken();
+            if (previousToken.IsKind(SyntaxKind.None))
+            {
+                return node.Span;
+            }
+
+            return TextSpan.FromBounds(previousToken.Span.End, node.Span.End);
+        }
+
+        private string GetType(SyntaxNode parent)
+        {
+            switch (parent.Kind())
+            {
+                case SyntaxKind.TryStatement: return BlockTypes.TryCatchFinally;
+                case SyntaxKind.CatchClause: return BlockTypes.TryCatchFinally;
+                case SyntaxKind.FinallyClause: return BlockTypes.TryCatchFinally;
+
+                case SyntaxKind.LockStatement: return BlockTypes.Lock;
+                case SyntaxKind.UsingStatement: return BlockTypes.Using;
+
+                case SyntaxKind.ForStatement: return BlockTypes.Loop;
+                case SyntaxKind.ForEachStatement: return BlockTypes.Loop;
+                case SyntaxKind.ForEachComponentStatement: return BlockTypes.Loop;
+                case SyntaxKind.WhileStatement: return BlockTypes.Loop;
+                case SyntaxKind.DoStatement: return BlockTypes.Loop;
+
+                case SyntaxKind.IfStatement: return BlockTypes.Conditional;
+                case SyntaxKind.ElseClause: return BlockTypes.Conditional;
+
+                case SyntaxKind.Block: return BlockTypes.Standalone;
+
+                case SyntaxKind.LocalFunctionStatement: return BlockTypes.LocalFunction;
+
+                default: return BlockTypes.Other;
+            }
+        }
+    }
+}
\ No newline at end of file

src/Features/CSharp/Portable/Structure/Providers/EventDeclarationStructureProvider.cs

 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
-using System.Collections.Immutable;
 using System.Threading;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Structure;

src/Features/Core/Portable/Structure/BlockTypes.cs

@@ -29,9 +29,11 @@ internal static class BlockTypes
         // Statements
         public const string Case = nameof(Case);
         public const string Conditional = nameof(Conditional);
+        public const string LocalFunction = nameof(LocalFunction);
         public const string Lock = nameof(Lock);
         public const string Loop = nameof(Loop);
         public const string TryCatchFinally = nameof(TryCatchFinally);
+        public const string Using = nameof(Using);
         public const string Standalone = nameof(Standalone);
 
         // Expressions

src/Features/Core/Portable/Structure/Syntax/AbstractSyntaxNodeStructureProvider.cs

@@ -9,7 +9,7 @@ namespace Microsoft.CodeAnalysis.Structure
     internal abstract class AbstractSyntaxNodeStructureProvider<TSyntaxNode> : AbstractSyntaxStructureProvider
         where TSyntaxNode : SyntaxNode
     {
-        public override void CollectBlockSpans(
+        public sealed override void CollectBlockSpans(
             Document document,
             SyntaxNode node,
             ArrayBuilder<BlockSpan> spans,