Properly compute scope for loops with Inline-Decl.

src/EditorFeatures/CSharpTest/InlineDeclaration/CSharpInlineDeclarationTests.cs

@@ -1195,6 +1195,292 @@ private int Bar()
                                                       catalogs,
                                                       out IProjectRuleSnapshot unresolvedReferenceSnapshot);
     }
+}");
+        }
+
+        [WorkItem(17624, "https://github.com/dotnet/roslyn/issues/17624")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsInlineDeclaration)]
+        public async Task TestNotInLoops1()
+        {
+            await TestMissingAsync(
+@"
+using System;
+
+class C
+{
+    static void Main(string[] args)
+    {
+        string [|token|];
+        do
+        {
+        }
+        while (!TryExtractTokenFromEmail(out token));
+
+        Console.WriteLine(token == ""Test"");
+    }
+
+    private static bool TryExtractTokenFromEmail(out string token)
+    {
+        throw new NotImplementedException();
+    }
+}");
+        }
+
+        [WorkItem(17624, "https://github.com/dotnet/roslyn/issues/17624")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsInlineDeclaration)]
+        public async Task TestNotInLoops2()
+        {
+            await TestMissingAsync(
+@"
+using System;
+
+class C
+{
+    static void Main(string[] args)
+    {
+        string [|token|];
+        while (!TryExtractTokenFromEmail(out token))
+        {
+        }
+
+        Console.WriteLine(token == ""Test"");
+    }
+
+    private static bool TryExtractTokenFromEmail(out string token)
+    {
+        throw new NotImplementedException();
+    }
+}");
+        }
+
+        [WorkItem(17624, "https://github.com/dotnet/roslyn/issues/17624")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsInlineDeclaration)]
+        public async Task TestNotInLoops3()
+        {
+            await TestMissingAsync(
+@"
+using System;
+using System.Collections.Generic;
+
+class C
+{
+    static void Main(string[] args)
+    {
+        string [|token|];
+        foreach (var v in TryExtractTokenFromEmail(out token))
+        {
+        }
+
+        Console.WriteLine(token == ""Test"");
+    }
+
+    private static IEnumerable<bool> TryExtractTokenFromEmail(out string token)
+    {
+        throw new NotImplementedException();
+    }
+}");
+        }
+
+        [WorkItem(17624, "https://github.com/dotnet/roslyn/issues/17624")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsInlineDeclaration)]
+        public async Task TestNotInLoops4()
+        {
+            await TestMissingAsync(
+@"
+using System;
+using System.Collections.Generic;
+
+class C
+{
+    static void Main(string[] args)
+    {
+        string [|token|];
+        for ( ; TryExtractTokenFromEmail(out token); )
+        {
+        }
+
+        Console.WriteLine(token == ""Test"");
+    }
+
+    private static bool TryExtractTokenFromEmail(out string token)
+    {
+        throw new NotImplementedException();
+    }
+}");
+        }
+
+        [WorkItem(17624, "https://github.com/dotnet/roslyn/issues/17624")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsInlineDeclaration)]
+        public async Task TestInLoops1()
+        {
+            await TestInRegularAndScript1Async(
+@"
+using System;
+
+class C
+{
+    static void Main(string[] args)
+    {
+        string [|token|];
+        do
+        {
+        }
+        while (!TryExtractTokenFromEmail(out token));
+    }
+
+    private static bool TryExtractTokenFromEmail(out string token)
+    {
+        throw new NotImplementedException();
+    }
+}",
+@"
+using System;
+
+class C
+{
+    static void Main(string[] args)
+    {
+        do
+        {
+        }
+        while (!TryExtractTokenFromEmail(out string token));
+    }
+
+    private static bool TryExtractTokenFromEmail(out string token)
+    {
+        throw new NotImplementedException();
+    }
+}");
+        }
+
+        [WorkItem(17624, "https://github.com/dotnet/roslyn/issues/17624")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsInlineDeclaration)]
+        public async Task TestInLoops2()
+        {
+            await TestInRegularAndScript1Async(
+@"
+using System;
+
+class C
+{
+    static void Main(string[] args)
+    {
+        string [|token|];
+        while (!TryExtractTokenFromEmail(out token))
+        {
+        }
+    }
+
+    private static bool TryExtractTokenFromEmail(out string token)
+    {
+        throw new NotImplementedException();
+    }
+}",
+@"
+using System;
+
+class C
+{
+    static void Main(string[] args)
+    {
+        while (!TryExtractTokenFromEmail(out string token))
+        {
+        }
+    }
+
+    private static bool TryExtractTokenFromEmail(out string token)
+    {
+        throw new NotImplementedException();
+    }
+}");
+        }
+
+        [WorkItem(17624, "https://github.com/dotnet/roslyn/issues/17624")]
+        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/17635"),
+         Trait(Traits.Feature, Traits.Features.CodeActionsInlineDeclaration)]
+        public async Task TestInLoops3()
+        {
+            await TestInRegularAndScript1Async(
+@"
+using System;
+using System.Collections.Generic;
+
+class C
+{
+    static void Main(string[] args)
+    {
+        string [|token|];
+        foreach (var v in TryExtractTokenFromEmail(out token))
+        {
+        }
+    }
+
+    private static IEnumerable<bool> TryExtractTokenFromEmail(out string token)
+    {
+        throw new NotImplementedException();
+    }
+}",
+@"
+using System;
+using System.Collections.Generic;
+
+class C
+{
+    static void Main(string[] args)
+    {
+        foreach (var v in TryExtractTokenFromEmail(out string token))
+        {
+        }
+    }
+
+    private static IEnumerable<bool> TryExtractTokenFromEmail(out string token)
+    {
+        throw new NotImplementedException();
+    }
+}");
+        }
+
+        [WorkItem(17624, "https://github.com/dotnet/roslyn/issues/17624")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsInlineDeclaration)]
+        public async Task TestInLoops4()
+        {
+            await TestInRegularAndScript1Async(
+@"
+using System;
+using System.Collections.Generic;
+
+class C
+{
+    static void Main(string[] args)
+    {
+        string [|token|];
+        for ( ; TryExtractTokenFromEmail(out token); )
+        {
+        }
+    }
+
+    private static bool TryExtractTokenFromEmail(out string token)
+    {
+        throw new NotImplementedException();
+    }
+}",
+@"
+using System;
+using System.Collections.Generic;
+
+class C
+{
+    static void Main(string[] args)
+    {
+        for ( ; TryExtractTokenFromEmail(out string token); )
+        {
+        }
+    }
+
+    private static bool TryExtractTokenFromEmail(out string token)
+    {
+        throw new NotImplementedException();
+    }
 }");
         }
     }

src/Features/CSharp/Portable/InlineDeclaration/CSharpInlineDeclarationDiagnosticAnalyzer.cs

@@ -155,7 +155,7 @@ private void AnalyzeSyntaxNode(SyntaxNodeAnalysisContext context, INamedTypeSymb
             // If the local has an initializer, only allow the refactoring if it is initialized
             // with a simple literal or 'default' expression.  i.e. it's ok to inline "var v = 0"
             // since there are no side-effects of the initialization.  However something like
-            // "var v = M()" shoudl not be inlined as that could break program semantics.
+            // "var v = M()" should not be inlined as that could break program semantics.
             if (localDeclarator.Initializer != null)
             {
                 if (!(localDeclarator.Initializer.Value is LiteralExpressionSyntax) &&
@@ -323,6 +323,15 @@ private SyntaxNode GetOutArgumentScope(SyntaxNode argumentExpression)
                     return current;
                 }
 
+                // Any loop construct defines a scope for out-variables.
+                if (current.Kind() == SyntaxKind.WhileStatement ||
+                    current.Kind() == SyntaxKind.DoStatement ||
+                    current.Kind() == SyntaxKind.ForStatement ||
+                    current.Kind() == SyntaxKind.ForEachStatement)
+                {
+                    return current;
+                }
+
                 if (current is StatementSyntax)
                 {
                     // We hit a statement containing the out-argument.  Statements can have one of