Merge pull request #11318 from lorcanmooney/issue11213

Correct intellisense and indentation for fixed statements

src/EditorFeatures/CSharpTest/Formatting/Indentation/SmartTokenFormatterFormatRangeTests.cs

@@ -2921,6 +2921,147 @@ public void M()
             await AutoFormatTokenAsync(code, expected);
         }
 
+        [WpfFact]
+        [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
+        public async Task UsingStatementWithNestedFixedStatement()
+        {
+            var code = @"class C
+{
+    public void M()
+    {
+        using (null)
+        fixed (void* ptr = &i)
+        {
+        }$$
+    }
+}";
+
+            var expected = @"class C
+{
+    public void M()
+    {
+        using (null)
+            fixed (void* ptr = &i)
+            {
+            }
+    }
+}";
+
+            await AutoFormatTokenAsync(code, expected);
+        }
+
+        [WpfFact]
+        [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
+        public async Task FixedStatementWithNestedUsingStatement()
+        {
+            var code = @"class C
+{
+    public void M()
+    {
+        fixed (void* ptr = &i)
+        using (null)$$
+    }
+}";
+
+            var expected = @"class C
+{
+    public void M()
+    {
+        fixed (void* ptr = &i)
+            using (null)
+    }
+}";
+
+            await AutoFormatTokenAsync(code, expected);
+        }
+
+        [WpfFact]
+        [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
+        public async Task FixedStatementWithNestedFixedStatement()
+        {
+            var code = @"class C
+{
+    public void M()
+    {
+        fixed (void* ptr1 = &i)
+            fixed (void* ptr2 = &i)
+            {
+            }$$
+    }
+}";
+
+            var expected = @"class C
+{
+    public void M()
+    {
+        fixed (void* ptr1 = &i)
+        fixed (void* ptr2 = &i)
+        {
+        }
+    }
+}";
+
+            await AutoFormatTokenAsync(code, expected);
+        }
+
+        [WpfFact]
+        [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
+        public async Task FixedStatementWithNestedNotFixedStatement()
+        {
+            var code = @"class C
+{
+    public void M()
+    {
+        fixed (void* ptr = &i)
+        if (false)
+        {
+        }$$
+    }
+}";
+
+            var expected = @"class C
+{
+    public void M()
+    {
+        fixed (void* ptr = &i)
+            if (false)
+            {
+            }
+    }
+}";
+
+            await AutoFormatTokenAsync(code, expected);
+        }
+
+        [WpfFact]
+        [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
+        public async Task NotFixedStatementWithNestedFixedStatement()
+        {
+            var code = @"class C
+{
+    public void M()
+    {
+        if (false)
+        fixed (void* ptr = &i)
+        {
+        }$$
+    }
+}";
+
+            var expected = @"class C
+{
+    public void M()
+    {
+        if (false)
+            fixed (void* ptr = &i)
+            {
+            }
+    }
+}";
+
+            await AutoFormatTokenAsync(code, expected);
+        }
+
         [WpfFact]
         [WorkItem(954386, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/954386")]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]

src/Workspaces/CSharp/Portable/Extensions/ContextQuery/SyntaxTokenExtensions.cs

@@ -93,6 +93,9 @@ public static bool IsBeginningOfStatementContext(this SyntaxToken token)
             // using (expr)
             //   |
 
+            // fixed (void* v = &expr)
+            //   |
+
             // lock (expr)
             //   |
 
@@ -170,7 +173,8 @@ public static bool IsBeginningOfStatementContext(this SyntaxToken token)
                     parent.IsKind(SyntaxKind.WhileStatement) ||
                     parent.IsKind(SyntaxKind.IfStatement) ||
                     parent.IsKind(SyntaxKind.LockStatement) ||
-                    parent.IsKind(SyntaxKind.UsingStatement))
+                    parent.IsKind(SyntaxKind.UsingStatement) ||
+                    parent.IsKind(SyntaxKind.FixedStatement))
                 {
                     return true;
                 }

src/Workspaces/CSharp/Portable/Formatting/FormattingHelpers.cs

@@ -321,6 +321,12 @@ public static bool IsCloseParenInStatement(this SyntaxToken token)
                 return usingStatement.CloseParenToken.Equals(token);
             }
 
+            var fixedStatement = statement as FixedStatementSyntax;
+            if (fixedStatement != null)
+            {
+                return fixedStatement.CloseParenToken.Equals(token);
+            }
+
             return false;
         }
 
@@ -386,6 +392,7 @@ public static bool IsEmbeddedStatementOwnerWithCloseParen(this SyntaxNode node)
                    node is ForStatementSyntax ||
                    node is ForEachStatementSyntax ||
                    node is UsingStatementSyntax ||
+                   node is FixedStatementSyntax ||
                    node is LockStatementSyntax;
         }
 

src/Workspaces/CSharp/Portable/Formatting/Rules/IndentBlockFormattingRule.cs

@@ -259,6 +259,13 @@ private void AddEmbeddedStatementsIndentationOperation(List<IndentBlockOperation
                 return;
             }
 
+            var fixedStatement = node as FixedStatementSyntax;
+            if (fixedStatement != null && fixedStatement.Statement != null && !(fixedStatement.Statement is BlockSyntax || fixedStatement.Statement is FixedStatementSyntax))
+            {
+                AddEmbeddedStatementsIndentationOperation(list, fixedStatement.Statement);
+                return;
+            }
+
             var doStatement = node as DoStatementSyntax;
             if (doStatement != null && doStatement.Statement != null && !(doStatement.Statement is BlockSyntax))
             {

src/Workspaces/CSharp/Portable/Formatting/Rules/NewLineUserSettingFormattingRule.cs

@@ -21,7 +21,8 @@ private bool IsControlBlock(SyntaxNode node)
                     parent.Kind() == SyntaxKind.ForStatement || parent.Kind() == SyntaxKind.TryStatement ||
                     parent.Kind() == SyntaxKind.CatchClause || parent.Kind() == SyntaxKind.FinallyClause ||
                     parent.Kind() == SyntaxKind.LockStatement || parent.Kind() == SyntaxKind.CheckedStatement ||
-                    parent.Kind() == SyntaxKind.UncheckedStatement || parent.Kind() == SyntaxKind.SwitchSection));
+                    parent.Kind() == SyntaxKind.UncheckedStatement || parent.Kind() == SyntaxKind.SwitchSection ||
+                    parent.Kind() == SyntaxKind.FixedStatement));
         }
 
         public override AdjustSpacesOperation GetAdjustSpacesOperation(SyntaxToken previousToken, SyntaxToken currentToken, OptionSet optionSet, NextOperation<AdjustSpacesOperation> nextOperation)

src/Workspaces/CSharp/Portable/Utilities/FormattingRangeHelper.cs

@@ -359,7 +359,8 @@ private static bool IsSpecialContainingNode(SyntaxNode node)
                 node.Kind() == SyntaxKind.CatchClause ||
                 node.Kind() == SyntaxKind.FinallyClause ||
                 node.Kind() == SyntaxKind.LabeledStatement ||
-                node.Kind() == SyntaxKind.LockStatement;
+                node.Kind() == SyntaxKind.LockStatement ||
+                node.Kind() == SyntaxKind.FixedStatement;
         }
 
         private static SyntaxNode GetTopContainingNode(SyntaxNode node)