From cfe13dcaf345f41d87eed284231d4e8410c08887 Mon Sep 17 00:00:00 2001
From: Chuck Cullison <lcullison@gmail.com>
Date: Sun, 24 Jan 2016 18:33:41 -0500
Subject: [PATCH 1/4] Create inline method action and tests.

---
 .../Uncategorized/InlineMethodAction.cs       | 248 ++++++++++++++++
 .../CodeRefactorings.CSharp.html              |   3 +-
 .../RefactoringEssentials.csproj              |   1 +
 .../InlineMethodActionTests.cs                | 269 ++++++++++++++++++
 Tests/Tests.csproj                            |   1 +
 5 files changed, 521 insertions(+), 1 deletion(-)
 create mode 100644 RefactoringEssentials/CSharp/CodeRefactorings/Uncategorized/InlineMethodAction.cs
 create mode 100644 Tests/CSharp/CodeRefactorings/InlineMethodActionTests.cs

diff --git a/RefactoringEssentials/CSharp/CodeRefactorings/Uncategorized/InlineMethodAction.cs b/RefactoringEssentials/CSharp/CodeRefactorings/Uncategorized/InlineMethodAction.cs
new file mode 100644
index 00000000..3112e17f
--- /dev/null
+++ b/RefactoringEssentials/CSharp/CodeRefactorings/Uncategorized/InlineMethodAction.cs
@@ -0,0 +1,248 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CodeActions;
+using Microsoft.CodeAnalysis.CodeRefactorings;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.FindSymbols;
+using Microsoft.CodeAnalysis.Formatting;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace RefactoringEssentials.CSharp.CodeRefactorings.Uncategorized
+{
+    [ExportCodeRefactoringProvider(
+        LanguageNames.CSharp,
+        Name = @"Put the method's body into the body of its callers and remove the method.")]
+    public class InlineMethodAction : CodeRefactoringProvider
+    {
+        public override async Task ComputeRefactoringsAsync(CodeRefactoringContext context)
+        {
+            var document = context.Document;
+            var span = context.Span;
+            var cancellationToken = context.CancellationToken;
+
+            var model = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
+            if (model.IsFromGeneratedCode(cancellationToken))
+                return;
+
+            var root = await model.SyntaxTree.GetRootAsync(cancellationToken).ConfigureAwait(false);
+            if (root == null)
+                return;
+
+            var node = root.FindNode(span);
+            if (node == null)
+                return;
+
+            // MethodDeclaration, InvocationExpression
+            var method = node as MethodDeclarationSyntax;
+
+            if (method == null)
+            {
+                method = (node?.Parent ?? null) as MethodDeclarationSyntax;
+            }
+
+            // Ensure we are testing at a method signature.
+            if (method == null)
+                return;
+
+            // Ensure the method does not have errors.
+            if (method.ContainsDiagnostics)
+                return;
+
+            var methodSymbol = model.GetDeclaredSymbol(method);
+            var methodContainer = methodSymbol.ContainingType;
+
+            // If the method is public then it may be referenced externally.
+            // This is subjective and some may disagree with this choice of behavior.
+            var isPublic = true;
+            ISymbol cs = methodSymbol;
+            do
+            {
+                if (cs.DeclaredAccessibility == Accessibility.Public ||
+                    cs.DeclaredAccessibility == Accessibility.NotApplicable)
+                    cs = cs.ContainingSymbol;
+                else
+                    isPublic = false;
+
+            } while (isPublic && cs != null);
+
+            if (isPublic)
+                return;
+
+            // Get references to the method.
+            var methodReferences = await SymbolFinder.FindReferencesAsync(methodSymbol, document.Project.Solution, cancellationToken).ConfigureAwait(false);
+
+            // Ensure there are references.
+            if (!methodReferences.Any())
+                return;
+            // Ensure the reference has locations.
+            if (!methodReferences.First().Locations.Any())
+                return;
+
+            // Ensure the method body is simple.
+            var isSimpleMethodBody = method.Body.Statements.Count() == 1;
+
+            if (!isSimpleMethodBody)
+                return;
+
+            // Are any references made from external types?
+            var hasExternalReferences = methodReferences.Any(r =>
+           {
+               return r.Locations.Any(l =>
+               {
+                   var refType = model.GetEnclosingNamedType(l.Location.SourceSpan.Start, cancellationToken);
+                   return (refType != methodContainer);
+               });
+           });
+
+            // Ensure the method body does not reference internal members.
+            if (hasExternalReferences)
+            {
+                var statement = method.Body.Statements.First();
+                var descendents = statement.DescendantNodes();
+                foreach (var descendent in descendents)
+                {
+                    var descendentSymbol = model.GetSymbolInfo(descendent);
+
+                    if (descendentSymbol.Symbol != null)
+                    {
+                        if (descendentSymbol.Symbol.ContainingType == methodContainer)
+                        {
+                            return;
+                        }
+                    }
+                }
+            }
+
+            // Passed all checks, suggest refactoring.
+            context.RegisterRefactoring(
+                CodeAction.Create(
+                    "Inline Method",
+                    ct => InlineMethodAsync(
+                        document.Project.Solution,
+                        methodSymbol,
+                        method,
+                        ct)));
+        }
+
+        /// <summary>
+        /// Inline a method and return new solution.
+        /// </summary>
+        /// <param name="solution">The solution to modify.</param>
+        /// <param name="methodSymbol">The symbol for the method.</param>
+        /// <param name="methodDeclarationSyntax">The syntax for the method</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns></returns>
+        async Task<Solution> InlineMethodAsync(
+            Solution solution,
+            ISymbol methodSymbol,
+            MethodDeclarationSyntax methodDeclarationSyntax,
+            CancellationToken cancellationToken)
+        {
+            // Get the method's param, these will be replaced for each location.
+            var methodParams = methodDeclarationSyntax.ParameterList.Parameters;
+
+            // Get method body.
+            SyntaxNode methodBody = methodDeclarationSyntax.Body.Statements.First();
+
+            // The statement will either be a return or expression, get the expression for either.
+            // Too bad there is not a more generic way of doing this.
+            if (methodBody.IsKind(SyntaxKind.ReturnStatement))
+            {
+                var returnStatement = methodBody as ReturnStatementSyntax;
+                methodBody = returnStatement.Expression;
+            }
+            else if (methodBody.IsKind(SyntaxKind.ExpressionStatement))
+            {
+                var statement = methodBody as ExpressionStatementSyntax;
+                methodBody = statement.Expression;
+            }
+
+            // Remove trivia, we will not copy comments everywhere.
+            methodBody = methodBody.WithoutTrivia();
+
+            // Find all method references.
+            var references = SymbolFinder.FindReferencesAsync(methodSymbol, solution).Result;
+
+            // There is usually only a single reference, the method reference with referring locations.
+            // Enumerate incase there are more.
+            foreach (var reference in references)
+            {
+                // Group all referring locations by document.
+                var groupedByDocument = from location in reference.Locations
+                                        group location by location.Document into g
+                                        select new
+                                        {
+                                            Document = g.Key,
+                                            Locations = g
+                                        };
+
+                // Enumerate all referring documents and replace locations with method body.
+                foreach (var g in groupedByDocument)
+                {
+                    var document = solution.GetDocument(g.Document.Id);
+                    var model = await document.GetSemanticModelAsync(cancellationToken);
+                    var root = await model.SyntaxTree.GetRootAsync(cancellationToken);
+
+                    // Replace each referenced location in document.
+                    foreach (var location in g.Locations)
+                    {
+                        var node = root.FindNode(location.Location.SourceSpan);
+
+                        var invocationNode = node.AncestorsAndSelf().FirstOrDefault(n => n.IsKind(SyntaxKind.InvocationExpression)) as InvocationExpressionSyntax;
+
+                        var replacementNode = methodBody;
+
+                        // Replace method body's params with actual values.
+                        var args = invocationNode.ArgumentList.Arguments;
+                        for (var paramIdx = 0; paramIdx < methodParams.Count(); paramIdx++)
+                        {
+                            var param = methodParams[paramIdx];
+                            var arg = (paramIdx < args.Count) ? args[paramIdx].Expression : param.Default.Value;
+
+                            var ids = replacementNode.DescendantNodesAndSelf()
+                                .Where(n => n.IsKind(SyntaxKind.IdentifierName))
+                                .Where(n => (n as IdentifierNameSyntax).Identifier.ValueText == param.Identifier.ValueText);
+
+                            replacementNode = replacementNode.ReplaceNodes(ids, (n1, n2) => arg).WithAdditionalAnnotations(Formatter.Annotation);
+                        }
+
+                        // Replace location with final method body.
+                        root = root.ReplaceNode(invocationNode, replacementNode.WithAdditionalAnnotations(Formatter.Annotation));
+                    }
+
+                    // Replace document root.
+                    solution = solution.WithDocumentSyntaxRoot(document.Id, root);
+                }
+            }
+
+            // Because the method location may have changed after replacing references, find it again.
+            methodSymbol = SymbolFinder.FindSourceDeclarationsAsync(
+                solution,
+                methodSymbol.Name,
+                false,
+                cancellationToken).Result.Single();
+
+            references = SymbolFinder.FindReferencesAsync(methodSymbol, solution).Result;
+
+            // Remove the method.
+            foreach (var reference in references)
+            {
+                foreach (var declaringSyntaxReference in reference.Definition.DeclaringSyntaxReferences)
+                {
+                    var document = solution.GetDocument(declaringSyntaxReference.SyntaxTree);
+                    var model = document.GetSemanticModelAsync().Result;
+                    var root = model.SyntaxTree.GetRootAsync().Result;
+                    var node = root.FindNode(declaringSyntaxReference.Span);
+                    root = root.RemoveNode(node, SyntaxRemoveOptions.KeepNoTrivia);
+                    solution = solution.WithDocumentSyntaxRoot(document.Id, root);
+                }
+            }
+
+            // Return new solution.
+            return await Task.FromResult(solution);
+        }
+
+    }
+}
diff --git a/RefactoringEssentials/CodeRefactorings.CSharp.html b/RefactoringEssentials/CodeRefactorings.CSharp.html
index b436bb2d..72f53fa3 100644
--- a/RefactoringEssentials/CodeRefactorings.CSharp.html
+++ b/RefactoringEssentials/CodeRefactorings.CSharp.html
@@ -15,7 +15,7 @@
 
     -->
     <h2>Supported Refactorings</h2>
-    <p>102 code refactorings for C#</p>
+    <p>103 code refactorings for C#</p>
     <ul>
       <li>Adds another accessor (AddAnotherAccessorCodeRefactoringProvider)</li>
       <li>Add braces (AddBracesCodeRefactoringProvider)</li>
@@ -82,6 +82,7 @@ <h2>Supported Refactorings</h2>
       <li>Import static class with using directive in file (ImportStaticClassWithUsingCodeRefactoringProvider)</li>
       <li>Initialize auto property from constructor parameter (InitializeAutoPropertyFromConstructorParameterCodeRefactoringProvider)</li>
       <li>Initialize field from constructor parameter (InitializeFieldFromConstructorParameterCodeRefactoringProvider)</li>
+      <li>Put the method's body into the body of its callers and remove the method. (InlineMethodAction)</li>
       <li>Insert anonymous method signature (InsertAnonymousMethodSignatureCodeRefactoringProvider)</li>
       <li>Invert conditional operator (InvertConditionalOperatorCodeRefactoringProvider)</li>
       <li>Invert if (InvertIfCodeRefactoringProvider)</li>
diff --git a/RefactoringEssentials/RefactoringEssentials.csproj b/RefactoringEssentials/RefactoringEssentials.csproj
index 414b2e53..bbdc448b 100644
--- a/RefactoringEssentials/RefactoringEssentials.csproj
+++ b/RefactoringEssentials/RefactoringEssentials.csproj
@@ -54,6 +54,7 @@
     <Compile Include="CSharp\CodeRefactorings\Synced\ContractEnsuresNotNullReturnRefactoringProvider.cs" />
     <Compile Include="CSharp\CodeRefactorings\Synced\MergeNestedIfAction.cs" />
     <Compile Include="CSharp\ConvertUnitTestToVB.cs" />
+    <Compile Include="CSharp\CodeRefactorings\Uncategorized\InlineMethodAction.cs" />
     <Compile Include="CSharp\SyntaxExtensions.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="CSharp\CodeRefactorings\Synced\AddAnotherAccessorCodeRefactoringProvider.cs" />
diff --git a/Tests/CSharp/CodeRefactorings/InlineMethodActionTests.cs b/Tests/CSharp/CodeRefactorings/InlineMethodActionTests.cs
new file mode 100644
index 00000000..4cbe335b
--- /dev/null
+++ b/Tests/CSharp/CodeRefactorings/InlineMethodActionTests.cs
@@ -0,0 +1,269 @@
+using NUnit.Framework;
+using RefactoringEssentials.CSharp.CodeRefactorings.Uncategorized;
+
+namespace RefactoringEssentials.Tests.CSharp.CodeRefactorings
+{
+    [TestFixture]
+    public class InlineMethodActionTests : CSharpCodeRefactoringTestBase
+    {
+        [Test]
+        [Description("Do not suggest refactoring unless the cursor is over the method signature (excluding arguments).")]
+        public void DoesNotRefactorWhenNotOnMethodSignature()
+        {
+            TestWrongContext<InlineMethodAction>(
+@"
+class Animal
+{
+    public void Foo() {
+        var x = Bar(5, 1);
+    }
+
+    public int Bar(int a, int b) {
+        //// Simple math.
+        return $(a + b);
+    }
+
+}");
+
+            TestWrongContext<InlineMethodAction>(
+@"
+class Animal
+{
+    public void Foo() {
+        var x = Bar(5, 1);
+    }
+
+    public int Bar(int a, int b) {
+        //// Simple math.
+        $return (a + b);
+    }
+
+}");
+
+            TestWrongContext<InlineMethodAction>(
+@"
+class Animal
+{
+    public void Foo() {
+        var x = Bar(5, 1);
+    }
+
+    public int Bar(int a, int $b) {
+        //// Simple math.
+        return (a + b);
+    }
+
+}");
+        }
+
+        [Test]
+        [Description("Do not inline a method with errors, that would just make more errors.")]
+        public void DoesNotRefactorMethodWithErrors()
+        {
+            TestWrongContext<InlineMethodAction>(
+@"
+class Animal
+{
+    public void Foo() {
+        var x = Bar(5, 1);
+    }
+
+    public int $Bar(int a, int b) {
+        //// Simple math.
+        return (a + b) This is invalid syntax!;
+    }
+
+}");
+        }
+
+        [Test]
+        [Description("Do not inline an external public method. It may be referenced externally and refactoring may be breaking.")]
+        public void DoesNotRefactorPublicExternalMethods()
+        {
+            TestWrongContext<InlineMethodAction>(
+@"
+public class Animal
+{
+    public void Foo() {
+        var x = Bar(5, 1);
+    }
+
+    public int $Bar(int a, int b) {
+        //// Simple math.
+        return (a + b);
+    }
+
+}");
+        }
+
+        [Test]
+        [Description("Do not inline a method without any references, that is not our interest.")]
+        public void DoesNotRefactorUnreferencedMethods()
+        {
+            TestWrongContext<InlineMethodAction>(
+@"
+class Animal
+{
+
+    // Method without any references.
+    public int $Bar(int a, int b) {
+        //// Simple math.
+        return (a + b);
+    }
+}");
+        }
+
+        [Test]
+        [Description("Do not inline a method with more than 1 line of code. This test may be invalid as the capability of method inlining is expanded.")]
+        public void DoesNotRefactorComplexMethod()
+        {
+            TestWrongContext<InlineMethodAction>(
+@"
+class Animal
+{
+    public void Foo() {
+        var x = Bar(1, 2);
+    }
+
+    // A complex method, one with multiple lines of code.
+    public int $Bar(int a, int b) {
+        //// Simple math.
+        var result = (a + b);
+        return result;
+    }
+}");
+        }
+
+        [Test]
+        [Description("Test that inline method is not refactored when contains internal member access.")]
+        public void DoNotInlineMethodBecauseOfInternalMemberAccess()
+        {
+            TestWrongContext<InlineMethodAction>(
+@"class Dog : Animal {
+    
+    public void DoLegs() {
+        AddLeg();
+        AddLeg();
+        AddLeg();
+        AddLeg();
+    }
+}
+
+class Animal
+{
+    private int legs = 0;
+    
+    protected void $AddLeg() {
+        //// Simple math.
+        legs++;
+    }
+
+}");
+        }
+
+        [Test]
+        [Description("Inline a method with return type.")]
+        public void InlineReturnMethod()
+        {
+            Test<InlineMethodAction>(
+@"class TestClass
+{
+    public void Foo() {
+        var x = Bar(5, 1);
+    }
+
+    public int $Bar(int a, int b) {
+        //// Simple math.
+        return (a + b);
+    }
+
+}",
+@"class TestClass
+{
+    public void Foo() {
+        var x = (5 + 1);
+    }
+
+}");
+        }
+
+        [Test]
+        [Description("Inline a method without return type.")]
+        public void InlineVoidMethod()
+        {
+            Test<InlineMethodAction>(
+@"class TestClass
+{
+    public void Foo() {
+        Bar(5, 1);
+    }
+
+    public void $Bar(int a, int b) {
+        //// Simple math.
+        Console.Writeline(a + b);
+    }
+
+}",
+@"class TestClass
+{
+    public void Foo() {
+        Console.Writeline(5 + 1);
+    }
+
+}");
+        }
+
+        [Test]
+        [Description("Inline a method with multiple references.")]
+        public void InlineMethodWithMultipleReferences()
+        {
+            Test<InlineMethodAction>(
+@"class TestClass
+{
+    public void Foo() {
+        var x = Bar(5, 1);
+        var x2 = Bar(10, 2);
+    }
+
+    public int $Bar(int a, int b) {
+        return (a + b);
+    }
+
+}",
+@"class TestClass
+{
+    public void Foo() {
+        var x = (5 + 1);
+        var x2 = (10 + 2);
+    }
+
+}");
+        }
+
+        [Test]
+        [Description("Inline a method with optional parameters.")]
+        public void InlineMethodWithOptionalParam()
+        {
+            Test<InlineMethodAction>(
+@"class TestClass
+{
+    public void Foo() {
+        var x = Bar(5, 1);
+    }
+
+    public int $Bar(int a, int b, int c = 0) {
+        //// Simple math.
+        return (a + b + c);
+    }
+
+}",
+@"class TestClass
+{
+    public void Foo() {
+        var x = (5 + 1 + 0);
+    }
+
+}");
+        }
+    }
+}
diff --git a/Tests/Tests.csproj b/Tests/Tests.csproj
index c4d45d46..9c783044 100644
--- a/Tests/Tests.csproj
+++ b/Tests/Tests.csproj
@@ -142,6 +142,7 @@
     <Compile Include="CSharp\CodeRefactorings\ImportStaticClassWithUsingTests.cs" />
     <Compile Include="CSharp\CodeRefactorings\InitializeAutoPropertyFromConstructorParameterTests.cs" />
     <Compile Include="CSharp\CodeRefactorings\InitializeFieldFromConstructorParameterTests.cs" />
+    <Compile Include="CSharp\CodeRefactorings\InlineMethodActionTests.cs" />
     <Compile Include="CSharp\CodeRefactorings\InsertAnonymousMethodSignatureTests.cs" />
     <Compile Include="CSharp\CodeRefactorings\IntroduceConstantTests.cs" />
     <Compile Include="CSharp\CodeRefactorings\IntroduceFormatItemTests.cs" />

From 414f9b6dc779afe0f32a1bf9432e5dad65214993 Mon Sep 17 00:00:00 2001
From: Chuck Cullison <lcullison@gmail.com>
Date: Sun, 24 Jan 2016 18:40:31 -0500
Subject: [PATCH 2/4] Added additional test for cross class changes.

---
 .../InlineMethodActionTests.cs                | 31 +++++++++++++++++++
 1 file changed, 31 insertions(+)

diff --git a/Tests/CSharp/CodeRefactorings/InlineMethodActionTests.cs b/Tests/CSharp/CodeRefactorings/InlineMethodActionTests.cs
index 4cbe335b..2384254b 100644
--- a/Tests/CSharp/CodeRefactorings/InlineMethodActionTests.cs
+++ b/Tests/CSharp/CodeRefactorings/InlineMethodActionTests.cs
@@ -263,6 +263,37 @@ public void Foo() {
         var x = (5 + 1 + 0);
     }
 
+}");
+        }
+
+        [Test]
+        [Description("Inline a method with references in another classes.")]
+        public void InlineMethodWithReferenceInAnotherClass()
+        {
+            Test<InlineMethodAction>(
+@"class Dog : Animal
+{
+    public void DoLegs() {
+        Bark();
+    }
+}
+
+class Animal
+{
+    protected void $Bark() {
+        //// Simple math.
+        Console.Writeline(""bark"");
+    }
+}",
+@"class Dog : Animal
+{
+    public void DoLegs() {
+        Console.Writeline(""bark"");
+    }
+}
+
+class Animal
+{
 }");
         }
     }

From e98d109e6c3e3a5a53cd3a22d0ab1a44cc08d5a5 Mon Sep 17 00:00:00 2001
From: Chuck Cullison <lcullison@gmail.com>
Date: Sat, 6 Feb 2016 09:28:28 -0500
Subject: [PATCH 3/4] Added delegate reference handling. Added test for
 multiple document modification and supporting helper classes.

---
 .../Uncategorized/InlineMethodAction.cs       |  96 +++++--
 .../InlineMethodActionTests.cs                | 245 +++++++++++++++++-
 Tests/Common/Utils.cs                         |  75 +++++-
 Tests/Common/WorkspaceHelpers.cs              | 199 ++++++++++++++
 Tests/Common/WorkspaceTestUtil.cs             | 166 ++++++++++++
 Tests/Tests.csproj                            |   2 +
 6 files changed, 755 insertions(+), 28 deletions(-)
 create mode 100644 Tests/Common/WorkspaceHelpers.cs
 create mode 100644 Tests/Common/WorkspaceTestUtil.cs

diff --git a/RefactoringEssentials/CSharp/CodeRefactorings/Uncategorized/InlineMethodAction.cs b/RefactoringEssentials/CSharp/CodeRefactorings/Uncategorized/InlineMethodAction.cs
index 3112e17f..625120fe 100644
--- a/RefactoringEssentials/CSharp/CodeRefactorings/Uncategorized/InlineMethodAction.cs
+++ b/RefactoringEssentials/CSharp/CodeRefactorings/Uncategorized/InlineMethodAction.cs
@@ -50,6 +50,12 @@ public override async Task ComputeRefactoringsAsync(CodeRefactoringContext conte
             if (method.ContainsDiagnostics)
                 return;
 
+            // Ensure the method body is simple.
+            var isSimpleMethodBody = method.Body.Statements.Count() == 1;
+
+            if (!isSimpleMethodBody)
+                return;
+
             var methodSymbol = model.GetDeclaredSymbol(method);
             var methodContainer = methodSymbol.ContainingType;
 
@@ -76,16 +82,11 @@ public override async Task ComputeRefactoringsAsync(CodeRefactoringContext conte
             // Ensure there are references.
             if (!methodReferences.Any())
                 return;
+
             // Ensure the reference has locations.
             if (!methodReferences.First().Locations.Any())
                 return;
 
-            // Ensure the method body is simple.
-            var isSimpleMethodBody = method.Body.Statements.Count() == 1;
-
-            if (!isSimpleMethodBody)
-                return;
-
             // Are any references made from external types?
             var hasExternalReferences = methodReferences.Any(r =>
            {
@@ -190,26 +191,46 @@ group location by location.Document into g
                     {
                         var node = root.FindNode(location.Location.SourceSpan);
 
-                        var invocationNode = node.AncestorsAndSelf().FirstOrDefault(n => n.IsKind(SyntaxKind.InvocationExpression)) as InvocationExpressionSyntax;
+                        // If location is invocation, replace it.
+                        if (node.Parent.IsKind(SyntaxKind.InvocationExpression))
+                        {
+                            var invocationNode = node.Parent as InvocationExpressionSyntax;
+                            root = ReplaceInvocationExpression(root, invocationNode, methodBody, methodParams);
+                        }
 
-                        var replacementNode = methodBody;
+                        // If the location is member access. foo.Bar(1, 2);
+                        if (node.Parent != null
+                            && node.Parent.IsKind(SyntaxKind.SimpleMemberAccessExpression)
+                            && node.Parent.Parent != null
+                            && node.Parent.Parent.IsKind(SyntaxKind.InvocationExpression))
+                        {
+                            var invocationNode = node.Parent.Parent as InvocationExpressionSyntax;
+                            root = ReplaceInvocationExpression(root, invocationNode, methodBody, methodParams);
+                        }
 
-                        // Replace method body's params with actual values.
-                        var args = invocationNode.ArgumentList.Arguments;
-                        for (var paramIdx = 0; paramIdx < methodParams.Count(); paramIdx++)
+                        // If location is argument, convert to lambda expression.
+                        if (node.IsKind(SyntaxKind.Argument))
                         {
-                            var param = methodParams[paramIdx];
-                            var arg = (paramIdx < args.Count) ? args[paramIdx].Expression : param.Default.Value;
+                            var argument = node as ArgumentSyntax;
 
-                            var ids = replacementNode.DescendantNodesAndSelf()
-                                .Where(n => n.IsKind(SyntaxKind.IdentifierName))
-                                .Where(n => (n as IdentifierNameSyntax).Identifier.ValueText == param.Identifier.ValueText);
+                            SyntaxNode newArgument;
+                            ParameterListSyntax paramList = SyntaxFactory.ParameterList();
 
-                            replacementNode = replacementNode.ReplaceNodes(ids, (n1, n2) => arg).WithAdditionalAnnotations(Formatter.Annotation);
-                        }
+                            // If method has params, prep them for the lambda.
+                            if (methodParams.Any())
+                            {
+                                var lambdaParams = from methodParam in methodParams
+                                                   select SyntaxFactory.Parameter(methodParam.AttributeLists, methodParam.Modifiers, methodParam.Type, methodParam.Identifier, null);
+                                var lambdaParamList = SyntaxFactory.SeparatedList<ParameterSyntax>(lambdaParams);
+                                paramList = SyntaxFactory.ParameterList(lambdaParamList);
+                            }
 
-                        // Replace location with final method body.
-                        root = root.ReplaceNode(invocationNode, replacementNode.WithAdditionalAnnotations(Formatter.Annotation));
+                            var lambda = SyntaxFactory.ParenthesizedLambdaExpression(paramList, methodBody as CSharpSyntaxNode);
+                            newArgument = SyntaxFactory.Argument(lambda);
+
+                            // Replace location with final method body.
+                            root = root.ReplaceNode(argument, newArgument.WithAdditionalAnnotations(Formatter.Annotation));
+                        }
                     }
 
                     // Replace document root.
@@ -244,5 +265,40 @@ group location by location.Document into g
             return await Task.FromResult(solution);
         }
 
+        /// <summary>
+        /// Replace invocation with method body.
+        /// </summary>
+        /// <param name="root">The root of the document.</param>
+        /// <param name="invocationNode">The invocation node to replace.</param>
+        /// <param name="methodBody">The body of the inlined method.</param>
+        /// <param name="methodParams">The parameters of the inlined method.</param>
+        /// <returns>
+        /// The new root with the invocation node replaced by the inline method body.
+        /// </returns>
+        SyntaxNode ReplaceInvocationExpression(
+            SyntaxNode root,
+            InvocationExpressionSyntax invocationNode,
+            SyntaxNode methodBody,
+            SeparatedSyntaxList<ParameterSyntax> methodParams)
+        {
+            var replacementNode = methodBody;
+
+            var args = invocationNode.ArgumentList.Arguments;
+            for (var paramIdx = 0; paramIdx < methodParams.Count(); paramIdx++)
+            {
+                var param = methodParams[paramIdx];
+                var arg = (paramIdx < args.Count) ? args[paramIdx].Expression : param.Default.Value;
+
+                var ids = replacementNode.DescendantNodesAndSelf()
+                    .Where(n => n.IsKind(SyntaxKind.IdentifierName))
+                    .Where(n => (n as IdentifierNameSyntax).Identifier.ValueText == param.Identifier.ValueText);
+
+                replacementNode = replacementNode.ReplaceNodes(ids, (n1, n2) => arg).WithAdditionalAnnotations(Formatter.Annotation);
+            }
+
+            // Replace location with final method body.
+            return root.ReplaceNode(invocationNode, replacementNode.WithAdditionalAnnotations(Formatter.Annotation));
+        }
+
     }
 }
diff --git a/Tests/CSharp/CodeRefactorings/InlineMethodActionTests.cs b/Tests/CSharp/CodeRefactorings/InlineMethodActionTests.cs
index 2384254b..d15cdaf0 100644
--- a/Tests/CSharp/CodeRefactorings/InlineMethodActionTests.cs
+++ b/Tests/CSharp/CodeRefactorings/InlineMethodActionTests.cs
@@ -1,15 +1,23 @@
-using NUnit.Framework;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Host.Mef;
+using NUnit.Framework;
 using RefactoringEssentials.CSharp.CodeRefactorings.Uncategorized;
+using RefactoringEssentials.Tests.Common;
 
 namespace RefactoringEssentials.Tests.CSharp.CodeRefactorings
 {
+    /// <summary>
+    /// Tests the <see cref="InlineMethodAction"/> <see cref="Microsoft.CodeAnalysis.CodeRefactorings.CodeRefactoringProvider"/>.
+    /// </summary>
     [TestFixture]
     public class InlineMethodActionTests : CSharpCodeRefactoringTestBase
     {
         [Test]
-        [Description("Do not suggest refactoring unless the cursor is over the method signature (excluding arguments).")]
+        [Description("Do not suggest refactoring unless the method signature is marked (excluding arguments).")]
         public void DoesNotRefactorWhenNotOnMethodSignature()
         {
+            // Ensure the inline method action is only invoked when the method's signature is marked.
+
             TestWrongContext<InlineMethodAction>(
 @"
 class Animal
@@ -60,6 +68,8 @@ public int Bar(int a, int $b) {
         [Description("Do not inline a method with errors, that would just make more errors.")]
         public void DoesNotRefactorMethodWithErrors()
         {
+            // Do no inline a method with errors, that would only propogate the errors.
+
             TestWrongContext<InlineMethodAction>(
 @"
 class Animal
@@ -80,6 +90,10 @@ public void Foo() {
         [Description("Do not inline an external public method. It may be referenced externally and refactoring may be breaking.")]
         public void DoesNotRefactorPublicExternalMethods()
         {
+            // Class Animal is public as is Animal.Bar. Therefore Animal.Bar is an external reference.
+            // External references may be in use by software outside the scope of the current workspace.
+            // Removing an external reference could break unknown consumers.
+
             TestWrongContext<InlineMethodAction>(
 @"
 public class Animal
@@ -100,6 +114,8 @@ public void Foo() {
         [Description("Do not inline a method without any references, that is not our interest.")]
         public void DoesNotRefactorUnreferencedMethods()
         {
+            // Animal.Bar is not referenced by any code and that is not the concern of the inline method action.
+
             TestWrongContext<InlineMethodAction>(
 @"
 class Animal
@@ -117,6 +133,9 @@ class Animal
         [Description("Do not inline a method with more than 1 line of code. This test may be invalid as the capability of method inlining is expanded.")]
         public void DoesNotRefactorComplexMethod()
         {
+            // Animal.Bar is considered complex because it has more than one line of code.
+            // At this time we are not refactoring complex methods.
+
             TestWrongContext<InlineMethodAction>(
 @"
 class Animal
@@ -135,9 +154,13 @@ public void Foo() {
         }
 
         [Test]
-        [Description("Test that inline method is not refactored when contains internal member access.")]
+        [Description("Do not inline a method when contains internal member access.")]
         public void DoNotInlineMethodBecauseOfInternalMemberAccess()
         {
+            // Do not inline method Animal.AddLeg because its body references internal member Animal.leg.
+            // AddLeg references internal member legs.
+            // Class Dog cannot refer to Animal.legs.
+
             TestWrongContext<InlineMethodAction>(
 @"class Dog : Animal {
     
@@ -162,7 +185,7 @@ class Animal
         }
 
         [Test]
-        [Description("Inline a method with return type.")]
+        [Description("Inline a method with return type. int Bar()")]
         public void InlineReturnMethod()
         {
             Test<InlineMethodAction>(
@@ -188,7 +211,7 @@ public void Foo() {
         }
 
         [Test]
-        [Description("Inline a method without return type.")]
+        [Description("Inline a method without return type. void Bar()")]
         public void InlineVoidMethod()
         {
             Test<InlineMethodAction>(
@@ -210,6 +233,115 @@ public void Foo() {
         Console.Writeline(5 + 1);
     }
 
+}");
+        }
+
+        [Test]
+        [Description("Inline a method and replace a member access invocation. foo.Bar(1, 2)")]
+        public void InlineMethodReplaceMemberAccess()
+        {
+            Test<InlineMethodAction>(
+@"class TestClass
+{
+    public void Foo() {
+        var tc = new TestClass();
+        tc.Bar(5, 1);
+    }
+
+    public void $Bar(int a, int b) {
+        //// Simple math.
+        Console.Writeline(a + b);
+    }
+
+}",
+@"class TestClass
+{
+    public void Foo() {
+        var tc = new TestClass();
+        Console.Writeline(5 + 1);
+    }
+
+}");
+        }
+
+        [Test]
+        [Description("Inline a method and replace a delegate reference.")]
+        public void InlineMethodReplaceDelegate()
+        {
+            // Method Foo invokes Foo3 with a delegate Bar.
+            // The delegate Bar will be replaced with inline method in the form of lambda syntax.
+
+            Test<InlineMethodAction>(
+@"class TestClass
+{
+    public void Foo() {
+        Foo3(Bar);
+    }
+
+    public void Foo3(Action act)
+    {
+        var x = act();
+    }
+
+    public void $Bar() {
+        Console.Writeline(""Blah"");
+    }
+
+}",
+@"class TestClass
+{
+    public void Foo() {
+        Foo3(() => Console.Writeline(""Blah""));
+    }
+
+    public void Foo3(Action act)
+    {
+        var x = act();
+    }
+
+}");
+        }
+
+        [Test]
+        [Description("Inline a method with a lambda, remove optional value.")]
+        public void InlineMethodWithParenthesizedLambdaReference()
+        {
+            // Method Foo invokes Foo3 with a delegate Bar.
+            // The delegate Bar will be replaced with inline method in the form of lambda syntax.
+            // Additionally, the lambda method will contain the parameters of the inline method Bar.
+            // Note that optional parameter b is not supported by lambda syntax and its default value is removed.
+            // See the below stackoverflow answer for more detail.
+            // http://stackoverflow.com/a/14249310/2735
+
+            Test<InlineMethodAction>(
+@"class TestClass
+{
+    public void Foo() {
+        Foo3(Bar);
+    }
+
+    public void Foo3(Func<int, int, int> act)
+    {
+        var x = act(1, 2);
+    }
+
+    public int $Bar(int a, int b = 1) {
+        //// Simple math.
+        return (a + b);
+    }
+
+}",
+@"class TestClass
+{
+    public void Foo() {
+        Foo3((int a, int b) => (a + b));
+    }
+
+    public void Foo3(Func<int, int, int> act)
+    {
+        var x = act(1, 2);
+    }
+
 }");
         }
 
@@ -217,23 +349,33 @@ public void Foo() {
         [Description("Inline a method with multiple references.")]
         public void InlineMethodWithMultipleReferences()
         {
+            // Test multiple references and syntax changes.
+            // Modifying code will rearrange a document's syntax.
+            // If 2 locations in the same document are known, changing the code for one location may invalidate the location of the other.
+
             Test<InlineMethodAction>(
 @"class TestClass
 {
     public void Foo() {
         var x = Bar(5, 1);
-        var x2 = Bar(10, 2);
     }
 
     public int $Bar(int a, int b) {
         return (a + b);
     }
 
+    public void Foo2() {
+        var x2 = Bar(10, 2);
+    }
+
 }",
 @"class TestClass
 {
     public void Foo() {
         var x = (5 + 1);
+    }
+
+    public void Foo2() {
         var x2 = (10 + 2);
     }
 
@@ -244,6 +386,8 @@ public void Foo() {
         [Description("Inline a method with optional parameters.")]
         public void InlineMethodWithOptionalParam()
         {
+            // Ensure that the optional parameter c in Bar is not lost.
+
             Test<InlineMethodAction>(
 @"class TestClass
 {
@@ -296,5 +440,92 @@ class Animal
 {
 }");
         }
+
+        [Test]
+        [Description("Test to ensure that references withing multiple documents are properly handled.")]
+        public void MultipleDocumentTest()
+        {
+            // ClassA is in document named ClassA, ClassB is in document named ClassB.
+            // Method ClassA.Foo invokes ClassB.Bar, the invocation of ClassB.Bar will be replaced by body of ClassB.Bar.
+
+            var solutionId = SolutionId.CreateNewId();
+            var projectId = ProjectId.CreateNewId();
+            var projectName = "ProjectA";
+            var document1Id = DocumentId.CreateNewId(projectId);
+            var document1Name = "ClassA";
+            var document2Id = DocumentId.CreateNewId(projectId);
+            var document2Name = "ClassB";
+
+            // Create Test Workspace
+            var testWorkspace = new AdhocWorkspace(MefHostServices.DefaultHost, "Temp");
+            testWorkspace.AddSolution(WorkspaceHelpers.CreateSolution(
+                solutionId,
+                new[] {
+                    WorkspaceHelpers.CreateCSharpProject(projectId, projectName, new []
+                    {
+                        WorkspaceHelpers.CreateDocument(document1Id, document1Name,
+@"class ClassA
+{
+    public void Foo() {
+        var x = ClassB.Bar(5, 1);
     }
-}
+}"),
+                        WorkspaceHelpers.CreateDocument(document2Id, document2Name,
+@"class ClassB
+{
+    public void Foo() {
+        var x = Bar(10, 2);
+    }
+
+    public static int $Bar(int a, int b, int c = 0) {
+        //// Simple math.
+        return (a + b + c);
+    }
+
+    public void Foo2() {
+        var x = Bar(10, 2);
+    }
+}")
+                    })
+                }));
+
+            // Create expected workspace
+            var expWorkspace = new AdhocWorkspace();
+            expWorkspace.AddSolution(WorkspaceHelpers.CreateSolution(
+                solutionId,
+                new[] {
+                    WorkspaceHelpers.CreateCSharpProject(
+                        projectId,
+                        projectName,
+                        new []
+                        {
+                            WorkspaceHelpers.CreateDocument(document1Id,document1Name,
+@"class ClassA
+{
+    public void Foo() {
+        var x = (5 + 1 + 0);
+    }
+}"),
+                            WorkspaceHelpers.CreateDocument(document2Id,document2Name ,
+@"class ClassB
+{
+    public void Foo() {
+        var x = (10 + 2 + 0);
+    }
+
+    public void Foo2() {
+        var x = (10 + 2 + 0);
+    }
+}")
+                        })
+            }));
+
+            // Run action
+            var alteredWorkspace = WorkspaceTestUtil.RunRefactoringProvider<InlineMethodAction>(testWorkspace);
+
+            // Assert expected workspace equals altered workspace.
+            WorkspaceTestUtil.AssertEqual(expWorkspace, alteredWorkspace);
+        }
+
+    }
+}
\ No newline at end of file
diff --git a/Tests/Common/Utils.cs b/Tests/Common/Utils.cs
index 677c353d..1adda95b 100644
--- a/Tests/Common/Utils.cs
+++ b/Tests/Common/Utils.cs
@@ -1,4 +1,5 @@
-using System;
+using Microsoft.CodeAnalysis.Text;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
@@ -28,5 +29,77 @@ internal static string HomogenizeEol(string str)
             }
             return sb.ToString();
         }
+
+        /// <summary>
+        /// Parse the provided text for demarcated text spans.
+        /// Single char selected text is demarcated with "$" or "…".
+        /// Range selected text starts with "&lt;-" and ends with "&gt;-".
+        /// Marked text starts with "-[" and ends with "]-".
+        /// </summary>
+        /// <param name="input">The text to find text spans in.</param>
+        /// <param name="selectedSpan">A <see cref="TextSpan"/> of selected text.</param>
+        /// <param name="markedSpan">A <see cref="TextSpan"/> of marked text.</param>
+        /// <returns>
+        /// The text without any demarcation syntax.
+        /// </returns>
+        internal static string ParseText(string input, out TextSpan selectedSpan, out TextSpan markedSpan)
+        {
+            int start = -1, end = -1;
+            int start2 = -1, end2 = -1;
+            var result = new StringBuilder(input.Length);
+            int upper = input.Length - 1;
+            for (int i = 0; i < upper; i++)
+            {
+                var ch = input[i];
+                if (ch == '$' && (i + 1 >= upper || input[i + 1] != '"') || ch == '…')
+                {
+                    start = end = i;
+                    continue;
+                }
+                if (ch == '<' && input[i + 1] == '-')
+                {
+                    start = i;
+                    i++;
+                    continue;
+                }
+                if (ch == '-' && input[i + 1] == '>')
+                {
+                    end = i;
+                    i++;
+                    continue;
+                }
+
+                if (ch == '-' && input[i + 1] == '[')
+                {
+                    start2 = result.Length;
+                    i++;
+                    continue;
+                }
+                if (ch == ']' && input[i + 1] == '-')
+                {
+                    end2 = result.Length;
+                    i++;
+                    continue;
+                }
+                result.Append(ch);
+            }
+
+            if (upper >= 0)
+            {
+                var lastChar = input[upper];
+                if (lastChar == '$')
+                {
+                    start = end = upper;
+                }
+                else
+                {
+                    result.Append(lastChar);
+                }
+            }
+
+            selectedSpan = start < 0 ? new TextSpan() : TextSpan.FromBounds(start, end);
+            markedSpan = start2 < 0 ? new TextSpan() : TextSpan.FromBounds(start2, end2);
+            return result.ToString();
+        }
     }
 }
diff --git a/Tests/Common/WorkspaceHelpers.cs b/Tests/Common/WorkspaceHelpers.cs
new file mode 100644
index 00000000..6e77d632
--- /dev/null
+++ b/Tests/Common/WorkspaceHelpers.cs
@@ -0,0 +1,199 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.Text;
+using Microsoft.CodeAnalysis.VisualBasic;
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Linq;
+
+namespace RefactoringEssentials.Tests.Common
+{
+    /// <summary>
+    /// Helps create workspace objects suitable for testing; solutions, projects and documents.
+    /// </summary>
+    static class WorkspaceHelpers
+    {
+        /// <summary>
+        /// Default CSharp parse options.
+        /// </summary>
+        static readonly ParseOptions DefaultCSharpParseOptions = new CSharpParseOptions(
+                    Microsoft.CodeAnalysis.CSharp.LanguageVersion.CSharp6,
+                    DocumentationMode.Diagnose | DocumentationMode.Parse,
+                    SourceCodeKind.Regular,
+                    ImmutableArray.Create("DEBUG", "TEST")
+                );
+
+        /// <summary>
+        /// Default CSharp compilation options.
+        /// </summary>
+        static readonly CSharpCompilationOptions DefaultCSharpCompilationOptions = new CSharpCompilationOptions(
+                        OutputKind.DynamicallyLinkedLibrary,
+                        "",
+                        "",
+                        "Script",
+                        null,
+                        OptimizationLevel.Debug,
+                        false,
+                        true
+                    );
+
+        /// <summary>
+        /// Default VB Parse Options.
+        /// </summary>
+        static readonly ParseOptions DefaultVBParseOptions = new VisualBasicParseOptions(
+                    Microsoft.CodeAnalysis.VisualBasic.LanguageVersion.VisualBasic14,
+                    DocumentationMode.Diagnose | DocumentationMode.Parse,
+                    SourceCodeKind.Regular
+                );
+
+        /// <summary>
+        /// Default VB compilation options.
+        /// </summary>
+        static readonly VisualBasicCompilationOptions DefaultVisualBasicCompilationOptions = new VisualBasicCompilationOptions(
+                        OutputKind.DynamicallyLinkedLibrary,
+                        "",
+                        ""
+                    );
+
+        static readonly MetadataReference mscorlib = MetadataReference.CreateFromFile(typeof(Console).Assembly.Location);
+        static readonly MetadataReference systemAssembly = MetadataReference.CreateFromFile(typeof(System.ComponentModel.BrowsableAttribute).Assembly.Location);
+        static readonly MetadataReference systemXmlLinq = MetadataReference.CreateFromFile(typeof(System.Xml.Linq.XElement).Assembly.Location);
+        static readonly MetadataReference systemCore = MetadataReference.CreateFromFile(typeof(Enumerable).Assembly.Location);
+
+        /// <summary>
+        /// Default references.
+        /// </summary>
+        static readonly MetadataReference[] DefaultMetadataReferences = {
+                mscorlib,
+                systemAssembly,
+                systemCore,
+                systemXmlLinq
+            };
+
+        /// <summary>
+        /// Create a solution.
+        /// </summary>
+        /// <param name="solutionId">The ID of the solution.</param>
+        /// <returns></returns>
+        public static SolutionInfo CreateSolution(SolutionId solutionId)
+        {
+            return CreateSolution(solutionId, null);
+        }
+
+        /// <summary>
+        /// Create a solution with projects.
+        /// </summary>
+        /// <param name="solutionId">The ID of the solution.</param>
+        /// <param name="projects">The solution's projects.</param>
+        /// <returns></returns>
+        public static SolutionInfo CreateSolution(SolutionId solutionId, IEnumerable<ProjectInfo> projects)
+        {
+            return SolutionInfo.Create(
+                solutionId,
+                VersionStamp.Create(),
+                null,
+                projects);
+        }
+
+        /// <summary>
+        /// Create a <see cref="ProjectInfo"/> suitable for CSharp code.
+        /// </summary>
+        /// <param name="projectId">The ID of the project.</param>
+        /// <param name="name">The name of the project.</param>
+        /// <returns></returns>
+        public static ProjectInfo CreateCSharpProject(ProjectId projectId, string name)
+        {
+            return CreateCSharpProject(projectId, name, null);
+        }
+
+        /// <summary>
+        /// Create a <see cref="ProjectInfo"/> suitable for CSharp code.
+        /// </summary>
+        /// <param name="projectId">The ID of the project.</param>
+        /// <param name="name">The name of the project.</param>
+        /// <param name="documents">The project's documents.</param>
+        /// <returns></returns>
+        public static ProjectInfo CreateCSharpProject(ProjectId projectId, string name, IEnumerable<DocumentInfo> documents)
+        {
+            return ProjectInfo.Create(
+                    projectId,
+                    VersionStamp.Create(),
+                    name,
+                    name,
+                    LanguageNames.CSharp,
+                    null,
+                    null,
+                    new CSharpCompilationOptions(
+                        OutputKind.DynamicallyLinkedLibrary,
+                        "",
+                        "",
+                        "Script",
+                        null,
+                        OptimizationLevel.Debug,
+                        false,
+                        true
+                    ),
+                    DefaultCSharpParseOptions,
+                    documents,
+                    null,
+                    DiagnosticTestBase.DefaultMetadataReferences
+                ).WithMetadataReferences(DefaultMetadataReferences);
+        }
+
+        /// <summary>
+        /// Create a <see cref="ProjectInfo"/> suitable for Visual Basic code.
+        /// </summary>
+        /// <param name="projectId">The ID of the project.</param>
+        /// <param name="name">The name of the project.</param>
+        /// <returns></returns>
+        public static ProjectInfo CreateVisualBasicProject(ProjectId projectId, string name)
+        {
+            return CreateVisualBasicProject(projectId, name, null);
+        }
+
+        /// <summary>
+        /// Create a <see cref="ProjectInfo"/> suitable for Visual Basic code.
+        /// </summary>
+        /// <param name="projectId">The ID of the project.</param>
+        /// <param name="name">The name of the project.</param>
+        /// <param name="documents">The project's documents.</param>
+        /// <returns></returns>
+        public static ProjectInfo CreateVisualBasicProject(ProjectId projectId, string name, IEnumerable<DocumentInfo> documents)
+        {
+            return ProjectInfo.Create(
+                    projectId,
+                    VersionStamp.Create(),
+                    name,
+                    name,
+                    LanguageNames.VisualBasic,
+                    null,
+                    null,
+                    DefaultVisualBasicCompilationOptions,
+                    DefaultVBParseOptions,
+                    documents,
+                    null,
+                    DiagnosticTestBase.DefaultMetadataReferences
+                ).WithMetadataReferences(DefaultMetadataReferences);
+        }
+
+        /// <summary>
+        /// Creates a <see cref="DocumentInfo"/> suitable for testing.
+        /// </summary>
+        /// <param name="documentId">The ID of the document.</param>
+        /// <param name="name">The filename of the document.</param>
+        /// <param name="text">The test content of the file.</param>
+        /// <returns></returns>
+        public static DocumentInfo CreateDocument(DocumentId documentId, string name, string text)
+        {
+            return DocumentInfo.Create(
+                documentId,
+                name,
+                null,
+                SourceCodeKind.Regular,
+                TextLoader.From(TextAndVersion.Create(SourceText.From(text), VersionStamp.Create()))
+                );
+        }
+                
+    }
+}
diff --git a/Tests/Common/WorkspaceTestUtil.cs b/Tests/Common/WorkspaceTestUtil.cs
new file mode 100644
index 00000000..86fb18ce
--- /dev/null
+++ b/Tests/Common/WorkspaceTestUtil.cs
@@ -0,0 +1,166 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CodeActions;
+using Microsoft.CodeAnalysis.CodeRefactorings;
+using Microsoft.CodeAnalysis.Text;
+using NUnit.Framework;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+
+namespace RefactoringEssentials.Tests.Common
+{
+    /// <summary>
+    /// Utility methods for testing actions with workspaces.
+    /// </summary>
+    static class WorkspaceTestUtil
+    {
+        /// <summary>
+        /// Refactor a workspace with a <see cref="CodeRefactoringProvider"/> type.
+        /// The workspace will be searched for an entry point to test refactoring using well known entry point syntax.
+        /// </summary>
+        /// <typeparam name="T">A <see cref="CodeRefactoringProvider"/> type.</typeparam>
+        /// <param name="workspace">A workspace to refactor.</param>
+        /// <returns>
+        /// A new workspace which is the result of the refactoring.
+        /// </returns>
+        public static Workspace RunRefactoringProvider<T>(Workspace workspace) where T : CodeRefactoringProvider, new()
+        {
+            var sln = workspace.CurrentSolution;
+
+            Document doc = null;
+            var emptySpan = new TextSpan();
+            var selectedSpan = new TextSpan();
+            var markedSpan = new TextSpan();
+
+            // Search each project and document for selected and marked text.
+            foreach (var project in sln.Projects)
+            {
+                foreach (var document in project.Documents)
+                {
+                    TextSpan newSelectedSpan;
+                    TextSpan newMarkedSpan;
+                    var txt = Utils.ParseText(document.GetTextAsync().Result.ToString(), out newSelectedSpan, out newMarkedSpan);
+                    if (newSelectedSpan != emptySpan || markedSpan != emptySpan)
+                    {
+                        // Fail if multiple documents are demarcated.
+                        if (doc != null)
+                            Assert.Fail("Multiple text spans must not be chosen.");
+
+                        sln = sln.WithDocumentText(document.Id, SourceText.From(txt));
+                        workspace.TryApplyChanges(sln);
+
+                        doc = workspace.CurrentSolution.GetDocument(document.Id);
+                        selectedSpan = newSelectedSpan;
+                        markedSpan = newMarkedSpan;
+                    }
+                }
+            }
+
+            // Fail if no documents are demarcated.
+            if (doc == null)
+                Assert.Fail("Text spans must be chosen.");
+
+            // Prepare refactoring context and action.
+            var actions = new List<CodeAction>();
+            var context = new CodeRefactoringContext(
+                doc,
+                selectedSpan,
+                actions.Add,
+                default(CancellationToken));
+
+            var action = new T();
+            action.ComputeRefactoringsAsync(context).Wait();
+
+            if (markedSpan.Start > 0)
+            {
+                foreach (var nra in actions.OfType<NRefactoryCodeAction>())
+                {
+                    Assert.AreEqual(markedSpan, nra.TextSpan, "Activation span does not match.");
+                }
+            }
+
+            // Apply code actions to workspace.
+            var a = actions[0];
+            foreach (var op in a.GetOperationsAsync(default(CancellationToken)).Result)
+            {
+                op.Apply(workspace, default(CancellationToken));
+            }
+
+            return workspace;
+        }
+
+        /// <summary>
+        /// Assert workspaces are equivalent.
+        /// </summary>
+        /// <param name="expected">The expected workspace.</param>
+        /// <param name="actual">The actual workspace.</param>
+        public static void AssertEqual(Workspace expected, Workspace actual)
+        {
+            var expectedSln = expected.CurrentSolution;
+            var actualSln = actual.CurrentSolution;
+
+            AssertEqual(expectedSln, actualSln);
+        }
+
+        /// <summary>
+        /// Assert solutions are equivalent.
+        /// </summary>
+        /// <param name="expected">The expected <see cref="Solution"/>.</param>
+        /// <param name="actual">The actual <see cref="Solution"/>.</param>
+        public static void AssertEqual(Solution expected, Solution actual)
+        {
+            var expectedSln = expected;
+            var actualSln = actual;
+
+            // Assert project counts match.
+            if (expectedSln.Projects.Count() != actualSln.Projects.Count())
+                Assert.Fail($"Project counts do not match. Expected; {expectedSln.Projects.Count()}, Actual: {actualSln.Projects.Count()}.");
+
+            // Loop through projects, ensure it exists in both solutions and test equivalence.
+            foreach (var expProject in expectedSln.Projects)
+            {
+                var actProject = actualSln.GetProject(expProject.Id);
+                if (actProject == null)
+                    Assert.Fail($"Project with ID \"{ expProject.Id}\" and name\"{expProject.Name}\" does not exist.");
+
+                AssertEqual(expProject, actProject);
+            }
+        }
+
+        /// <summary>
+        /// Assert projects are equivalent.
+        /// </summary>
+        /// <param name="expected">The expected <see cref="Project"/>.</param>
+        /// <param name="actual">The actual <see cref="Project"/>.</param>
+        public static void AssertEqual(Project expected, Project actual)
+        {
+            // Assert document counts match.
+            if (expected.Documents.Count() != actual.Documents.Count())
+                Assert.Fail($"Document counts do not match for project named \"{expected.Name}\". Expected; {expected.Documents.Count()}, Actual: {actual.Documents.Count()}.");
+
+            // Loop through documents, ensure it exists in both projects and test equivalence.
+            foreach (var expDoc in expected.Documents)
+            {
+                var actDoc = actual.GetDocument(expDoc.Id);
+                if (actDoc == null)
+                    Assert.Fail($"Document with ID \"{ expDoc.Id}\" and name\"{expDoc.Name}\" does not exist.");
+
+                AssertEqual(expDoc, actDoc);
+            }
+        }
+
+        /// <summary>
+        /// Assert documents are equivalent.
+        /// </summary>
+        /// <param name="expected">The expected <see cref="Document"/>.</param>
+        /// <param name="actual">The actual <see cref="Document"/>.</param>
+        public static void AssertEqual(Document expected, Document actual)
+        {
+            var expText = Utils.HomogenizeEol(expected.GetTextAsync().Result.ToString());
+            var actText = Utils.HomogenizeEol(actual.GetTextAsync().Result.ToString());
+
+            if (!string.Equals(expText, actText))
+                Assert.Fail($"Document with name\"{expected.Name}\" does not match. Expected:\n{expText}\nActual:\n{actText}\n");
+        }
+    }
+}
diff --git a/Tests/Tests.csproj b/Tests/Tests.csproj
index 9c783044..13377910 100644
--- a/Tests/Tests.csproj
+++ b/Tests/Tests.csproj
@@ -125,7 +125,9 @@
     </Compile>
     <Compile Include="Common\CodeFixTestBase.cs" />
     <Compile Include="Common\CodeRefactoringTestBase.cs" />
+    <Compile Include="Common\WorkspaceHelpers.cs" />
     <Compile Include="Common\Utils.cs" />
+    <Compile Include="Common\WorkspaceTestUtil.cs" />
     <Compile Include="CSharp\CodeFixes\CSharpCodeFixTestBase.cs" />
     <Compile Include="CSharp\CodeFixes\CS0108UseNewKeywordIfHidingIntendedTests.cs" />
     <Compile Include="CSharp\CodeFixes\CS0152DuplicateCaseLabelValueTests.cs" />

From 98e359d08dc5e476a8da3a855a15c08166cb7181 Mon Sep 17 00:00:00 2001
From: Chuck Cullison <lcullison@gmail.com>
Date: Sun, 14 Feb 2016 11:59:08 -0500
Subject: [PATCH 4/4] Fixed to properly handle multiple documents. Modified the
 cross document unit test so that it would produce this concern and recoded to
 meet it. Added an additional unit test for ensuring document changes do not
 undo each other.

---
 .../Uncategorized/InlineMethodAction.cs       | 251 +++++++++---------
 .../InlineMethodActionTests.cs                |  54 ++--
 2 files changed, 168 insertions(+), 137 deletions(-)

diff --git a/RefactoringEssentials/CSharp/CodeRefactorings/Uncategorized/InlineMethodAction.cs b/RefactoringEssentials/CSharp/CodeRefactorings/Uncategorized/InlineMethodAction.cs
index 625120fe..67240066 100644
--- a/RefactoringEssentials/CSharp/CodeRefactorings/Uncategorized/InlineMethodAction.cs
+++ b/RefactoringEssentials/CSharp/CodeRefactorings/Uncategorized/InlineMethodAction.cs
@@ -56,12 +56,31 @@ public override async Task ComputeRefactoringsAsync(CodeRefactoringContext conte
             if (!isSimpleMethodBody)
                 return;
 
+            // Get method body.
+            SyntaxNode methodBody = method.Body.Statements.First();
+
+            // The statement will either be a return or expression, get the expression for either.
+            // Too bad there is not a more generic way of doing this.
+            if (methodBody.IsKind(SyntaxKind.ReturnStatement))
+            {
+                var returnStatement = methodBody as ReturnStatementSyntax;
+                methodBody = returnStatement.Expression;
+            }
+            else if (methodBody.IsKind(SyntaxKind.ExpressionStatement))
+            {
+                var statement = methodBody as ExpressionStatementSyntax;
+                methodBody = statement.Expression;
+            }
+            else
+            {
+                // If we do not understand what the method body is then do not refactor.
+                return;
+            }
+
             var methodSymbol = model.GetDeclaredSymbol(method);
-            var methodContainer = methodSymbol.ContainingType;
 
-            // If the method is public then it may be referenced externally.
-            // This is subjective and some may disagree with this choice of behavior.
-            var isPublic = true;
+            // If the method is external then it may be called externally.
+            var isExternalAccessibility = true;
             ISymbol cs = methodSymbol;
             do
             {
@@ -69,35 +88,33 @@ public override async Task ComputeRefactoringsAsync(CodeRefactoringContext conte
                     cs.DeclaredAccessibility == Accessibility.NotApplicable)
                     cs = cs.ContainingSymbol;
                 else
-                    isPublic = false;
+                    isExternalAccessibility = false;
 
-            } while (isPublic && cs != null);
+            } while (isExternalAccessibility && cs != null);
 
-            if (isPublic)
+            if (isExternalAccessibility)
                 return;
 
-            // Get references to the method.
-            var methodReferences = await SymbolFinder.FindReferencesAsync(methodSymbol, document.Project.Solution, cancellationToken).ConfigureAwait(false);
+            // Get callers of the method.
+            var callers = await SymbolFinder.FindCallersAsync(methodSymbol, document.Project.Solution, cancellationToken).ConfigureAwait(false);
 
-            // Ensure there are references.
-            if (!methodReferences.Any())
+            // Ensure there are callers.
+            if (callers == null || !callers.Any())
                 return;
 
             // Ensure the reference has locations.
-            if (!methodReferences.First().Locations.Any())
+            if (!callers.First().Locations.Any())
                 return;
 
+            var methodContainer = methodSymbol.ContainingType;
+
             // Are any references made from external types?
-            var hasExternalReferences = methodReferences.Any(r =>
+            var hasExternalReferences = callers.Any((SymbolCallerInfo r) =>
            {
-               return r.Locations.Any(l =>
-               {
-                   var refType = model.GetEnclosingNamedType(l.Location.SourceSpan.Start, cancellationToken);
-                   return (refType != methodContainer);
-               });
+               return (r.CallingSymbol.ContainingType != methodContainer);
            });
 
-            // Ensure the method body does not reference internal members.
+            // If the method is called externally, ensure the method body does not reference internal members.
             if (hasExternalReferences)
             {
                 var statement = method.Body.Statements.First();
@@ -108,7 +125,9 @@ public override async Task ComputeRefactoringsAsync(CodeRefactoringContext conte
 
                     if (descendentSymbol.Symbol != null)
                     {
-                        if (descendentSymbol.Symbol.ContainingType == methodContainer)
+                        // If symbol is internal and not a parameter.
+                        if (descendentSymbol.Symbol.ContainingType == methodContainer
+                            && descendentSymbol.Symbol.ContainingSymbol != methodSymbol)
                         {
                             return;
                         }
@@ -123,7 +142,8 @@ public override async Task ComputeRefactoringsAsync(CodeRefactoringContext conte
                     ct => InlineMethodAsync(
                         document.Project.Solution,
                         methodSymbol,
-                        method,
+                        methodBody,
+                        method.ParameterList,
                         ct)));
         }
 
@@ -131,134 +151,121 @@ public override async Task ComputeRefactoringsAsync(CodeRefactoringContext conte
         /// Inline a method and return new solution.
         /// </summary>
         /// <param name="solution">The solution to modify.</param>
-        /// <param name="methodSymbol">The symbol for the method.</param>
-        /// <param name="methodDeclarationSyntax">The syntax for the method</param>
+        /// <param name="methodSymbol">The symbol of the method.</param>
+        /// <param name="methodBody">The body of the method.</param>
+        /// <param name="methodParams">The parameters of the method.</param>
         /// <param name="cancellationToken">The cancellation token.</param>
         /// <returns></returns>
         async Task<Solution> InlineMethodAsync(
             Solution solution,
             ISymbol methodSymbol,
-            MethodDeclarationSyntax methodDeclarationSyntax,
+            SyntaxNode methodBody,
+            ParameterListSyntax methodParams,
             CancellationToken cancellationToken)
         {
-            // Get the method's param, these will be replaced for each location.
-            var methodParams = methodDeclarationSyntax.ParameterList.Parameters;
+            // Remove trivia, we will not copy comments everywhere.
+            methodBody = methodBody.WithoutTrivia();
 
-            // Get method body.
-            SyntaxNode methodBody = methodDeclarationSyntax.Body.Statements.First();
+            // Find all method callers.
+            var callers = SymbolFinder.FindCallersAsync(methodSymbol, solution).Result;
 
-            // The statement will either be a return or expression, get the expression for either.
-            // Too bad there is not a more generic way of doing this.
-            if (methodBody.IsKind(SyntaxKind.ReturnStatement))
-            {
-                var returnStatement = methodBody as ReturnStatementSyntax;
-                methodBody = returnStatement.Expression;
-            }
-            else if (methodBody.IsKind(SyntaxKind.ExpressionStatement))
+            var locationsByDocument = from caller in callers
+                                      from location in caller.Locations
+                                      group location by location.SourceTree into g
+                                      select new
+                                      {
+                                          SourceTree = g.Key,
+                                          Locations = g
+                                      };
+
+
+            foreach (var locationByDocument in locationsByDocument)
             {
-                var statement = methodBody as ExpressionStatementSyntax;
-                methodBody = statement.Expression;
-            }
+                // Get source tree.
+                var tree = locationByDocument.SourceTree;
+                if (tree == null) continue;
 
-            // Remove trivia, we will not copy comments everywhere.
-            methodBody = methodBody.WithoutTrivia();
+                // Get document.
+                var document = solution.GetDocument(tree);
+                if (document == null) continue;
 
-            // Find all method references.
-            var references = SymbolFinder.FindReferencesAsync(methodSymbol, solution).Result;
+                // Get root syntax.
+                var root = await document.GetSyntaxRootAsync(cancellationToken);
+                if (root == null) continue;
 
-            // There is usually only a single reference, the method reference with referring locations.
-            // Enumerate incase there are more.
-            foreach (var reference in references)
-            {
-                // Group all referring locations by document.
-                var groupedByDocument = from location in reference.Locations
-                                        group location by location.Document into g
-                                        select new
-                                        {
-                                            Document = g.Key,
-                                            Locations = g
-                                        };
-
-                // Enumerate all referring documents and replace locations with method body.
-                foreach (var g in groupedByDocument)
+                // Enumerate locations and replace in root.
+                foreach (var location in locationByDocument.Locations)
                 {
-                    var document = solution.GetDocument(g.Document.Id);
-                    var model = await document.GetSemanticModelAsync(cancellationToken);
-                    var root = await model.SyntaxTree.GetRootAsync(cancellationToken);
+                    if (!location.IsInSource) continue;
 
-                    // Replace each referenced location in document.
-                    foreach (var location in g.Locations)
-                    {
-                        var node = root.FindNode(location.Location.SourceSpan);
+                    // Get node and ensure it exists.
+                    var node = root.FindNode(location.SourceSpan);
+                    if (node == null) continue;
 
-                        // If location is invocation, replace it.
-                        if (node.Parent.IsKind(SyntaxKind.InvocationExpression))
-                        {
-                            var invocationNode = node.Parent as InvocationExpressionSyntax;
-                            root = ReplaceInvocationExpression(root, invocationNode, methodBody, methodParams);
-                        }
+                    // If location is invocation, replace it.
+                    if (node.Parent.IsKind(SyntaxKind.InvocationExpression))
+                    {
+                        var invocationNode = node.Parent as InvocationExpressionSyntax;
+                        root = ReplaceInvocationExpression(root, invocationNode, methodBody, methodParams);
+                    }
 
-                        // If the location is member access. foo.Bar(1, 2);
-                        if (node.Parent != null
-                            && node.Parent.IsKind(SyntaxKind.SimpleMemberAccessExpression)
-                            && node.Parent.Parent != null
-                            && node.Parent.Parent.IsKind(SyntaxKind.InvocationExpression))
-                        {
-                            var invocationNode = node.Parent.Parent as InvocationExpressionSyntax;
-                            root = ReplaceInvocationExpression(root, invocationNode, methodBody, methodParams);
-                        }
+                    // If the location is member access. foo.Bar(1, 2);
+                    if (node.Parent != null
+                        && node.Parent.IsKind(SyntaxKind.SimpleMemberAccessExpression)
+                        && node.Parent.Parent != null
+                        && node.Parent.Parent.IsKind(SyntaxKind.InvocationExpression))
+                    {
+                        var invocationNode = node.Parent.Parent as InvocationExpressionSyntax;
+                        root = ReplaceInvocationExpression(root, invocationNode, methodBody, methodParams);
+                    }
 
-                        // If location is argument, convert to lambda expression.
-                        if (node.IsKind(SyntaxKind.Argument))
-                        {
-                            var argument = node as ArgumentSyntax;
+                    // If location is delegate, convert to lambda expression.
+                    if (node.IsKind(SyntaxKind.Argument))
+                    {
+                        var argument = node as ArgumentSyntax;
 
-                            SyntaxNode newArgument;
-                            ParameterListSyntax paramList = SyntaxFactory.ParameterList();
+                        SyntaxNode newArgument;
+                        ParameterListSyntax paramList = SyntaxFactory.ParameterList();
 
-                            // If method has params, prep them for the lambda.
-                            if (methodParams.Any())
-                            {
-                                var lambdaParams = from methodParam in methodParams
-                                                   select SyntaxFactory.Parameter(methodParam.AttributeLists, methodParam.Modifiers, methodParam.Type, methodParam.Identifier, null);
-                                var lambdaParamList = SyntaxFactory.SeparatedList<ParameterSyntax>(lambdaParams);
-                                paramList = SyntaxFactory.ParameterList(lambdaParamList);
-                            }
+                        // If method has params, prep them for the lambda.
+                        if (methodParams.Parameters.Any())
+                        {
+                            var lambdaParams = from methodParam in methodParams.Parameters
+                                               select SyntaxFactory.Parameter(methodParam.AttributeLists, methodParam.Modifiers, methodParam.Type, methodParam.Identifier, null);
+                            var lambdaParamList = SyntaxFactory.SeparatedList<ParameterSyntax>(lambdaParams);
+                            paramList = SyntaxFactory.ParameterList(lambdaParamList);
+                        }
 
-                            var lambda = SyntaxFactory.ParenthesizedLambdaExpression(paramList, methodBody as CSharpSyntaxNode);
-                            newArgument = SyntaxFactory.Argument(lambda);
+                        var lambda = SyntaxFactory.ParenthesizedLambdaExpression(paramList, methodBody as CSharpSyntaxNode);
+                        newArgument = SyntaxFactory.Argument(lambda);
 
-                            // Replace location with final method body.
-                            root = root.ReplaceNode(argument, newArgument.WithAdditionalAnnotations(Formatter.Annotation));
-                        }
+                        // Replace location with final method body.
+                        root = root.ReplaceNode(argument, newArgument.WithAdditionalAnnotations(Formatter.Annotation));
                     }
-
-                    // Replace document root.
-                    solution = solution.WithDocumentSyntaxRoot(document.Id, root);
                 }
+
+                // Replace document syntax root.
+                solution = solution.WithDocumentSyntaxRoot(document.Id, root);
             }
 
             // Because the method location may have changed after replacing references, find it again.
             methodSymbol = SymbolFinder.FindSourceDeclarationsAsync(
-                solution,
-                methodSymbol.Name,
-                false,
-                cancellationToken).Result.Single();
+                    solution,
+                    methodSymbol.Name,
+                    false,
+                    cancellationToken).Result.Single();
 
-            references = SymbolFinder.FindReferencesAsync(methodSymbol, solution).Result;
-
-            // Remove the method.
-            foreach (var reference in references)
+            // Remove inlined method.
+            foreach (var methodLocation in methodSymbol.Locations)
             {
-                foreach (var declaringSyntaxReference in reference.Definition.DeclaringSyntaxReferences)
-                {
-                    var document = solution.GetDocument(declaringSyntaxReference.SyntaxTree);
-                    var model = document.GetSemanticModelAsync().Result;
-                    var root = model.SyntaxTree.GetRootAsync().Result;
-                    var node = root.FindNode(declaringSyntaxReference.Span);
-                    root = root.RemoveNode(node, SyntaxRemoveOptions.KeepNoTrivia);
-                    solution = solution.WithDocumentSyntaxRoot(document.Id, root);
-                }
+                if (!methodLocation.IsInSource) continue;
+
+                var tree = methodLocation.SourceTree;
+                var documentId = solution.GetDocumentId(tree);
+                var root = await tree.GetRootAsync(cancellationToken);
+                var node = root.FindNode(methodLocation.SourceSpan);
+                root = root.RemoveNode(node, SyntaxRemoveOptions.KeepNoTrivia);
+                solution = solution.WithDocumentSyntaxRoot(documentId, root);
             }
 
             // Return new solution.
@@ -279,14 +286,14 @@ SyntaxNode ReplaceInvocationExpression(
             SyntaxNode root,
             InvocationExpressionSyntax invocationNode,
             SyntaxNode methodBody,
-            SeparatedSyntaxList<ParameterSyntax> methodParams)
+            ParameterListSyntax methodParams)
         {
             var replacementNode = methodBody;
 
             var args = invocationNode.ArgumentList.Arguments;
-            for (var paramIdx = 0; paramIdx < methodParams.Count(); paramIdx++)
+            for (var paramIdx = 0; paramIdx < methodParams.Parameters.Count(); paramIdx++)
             {
-                var param = methodParams[paramIdx];
+                var param = methodParams.Parameters[paramIdx];
                 var arg = (paramIdx < args.Count) ? args[paramIdx].Expression : param.Default.Value;
 
                 var ids = replacementNode.DescendantNodesAndSelf()
diff --git a/Tests/CSharp/CodeRefactorings/InlineMethodActionTests.cs b/Tests/CSharp/CodeRefactorings/InlineMethodActionTests.cs
index d15cdaf0..038b7340 100644
--- a/Tests/CSharp/CodeRefactorings/InlineMethodActionTests.cs
+++ b/Tests/CSharp/CodeRefactorings/InlineMethodActionTests.cs
@@ -407,6 +407,45 @@ public void Foo() {
         var x = (5 + 1 + 0);
     }
 
+}");
+        }
+
+        [Test]
+        [Description("Inline a method and ensure it properly traverses document.")]
+        public void InlineMethodTraversesDocument()
+        {
+            // While replacing syntax, if not handled, it is possible to undo one change with another.
+            // This is a gotcha of working with syntax trees and immutable types.
+            // In this example, Foo and Foo2 should be updated with the inline method body while method Bar is removed.
+            // If not properly handled, it is possible that Foo is updated and subsequenty undone when Foo2 is updated.
+
+            Test<InlineMethodAction>(
+@"class TestClass
+{
+    public void Foo() {
+        var x = Bar(5, 1);
+    }
+
+    public int $Bar(int a, int b, int c = 0) {
+        //// Simple math.
+        return (a + b + c);
+    }
+
+    public void Foo2() {
+        var x = Bar(6, 2);
+    }
+
+}",
+@"class TestClass
+{
+    public void Foo() {
+        var x = (5 + 1 + 0);
+    }
+
+    public void Foo2() {
+        var x = (6 + 2 + 0);
+    }
+
 }");
         }
 
@@ -473,18 +512,10 @@ public void Foo() {
                         WorkspaceHelpers.CreateDocument(document2Id, document2Name,
 @"class ClassB
 {
-    public void Foo() {
-        var x = Bar(10, 2);
-    }
-
     public static int $Bar(int a, int b, int c = 0) {
         //// Simple math.
         return (a + b + c);
     }
-
-    public void Foo2() {
-        var x = Bar(10, 2);
-    }
 }")
                     })
                 }));
@@ -509,13 +540,6 @@ public void Foo() {
                             WorkspaceHelpers.CreateDocument(document2Id,document2Name ,
 @"class ClassB
 {
-    public void Foo() {
-        var x = (10 + 2 + 0);
-    }
-
-    public void Foo2() {
-        var x = (10 + 2 + 0);
-    }
 }")
                         })
             }));