Move more code to common layer.

src/EditorFeatures/VisualBasicTest/MoveDeclarationNearReference/MoveDeclarationNearReferenceTests.vb

 ' Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
-Imports System.Threading.Tasks
 Imports Microsoft.CodeAnalysis.CodeRefactorings
-Imports Microsoft.CodeAnalysis.VisualBasic.MoveDeclarationNearReference
 Imports Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.CodeRefactorings
-Imports Roslyn.Test.Utilities
-Imports Xunit
+Imports Microsoft.CodeAnalysis.VisualBasic.MoveDeclarationNearReference
 
 Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.MoveDeclarationNearReference
     Public Class MoveDeclarationNearReferenceTests

src/Features/CSharp/Portable/MoveDeclarationNearReference/CSharpMoveDeclarationNearReferenceCodeRefactoringProvider.cs

@@ -38,21 +38,6 @@ protected override bool IsValidVariableDeclarator(VariableDeclaratorSyntax varia
         protected override SyntaxToken GetIdentifierOfVariableDeclarator(VariableDeclaratorSyntax variableDeclarator)
             => variableDeclarator.Identifier;
 
-        protected override LocalDeclarationStatementSyntax CreateMergedDeclarationStatement(
-            LocalDeclarationStatementSyntax localDeclaration, StatementSyntax statementSyntax)
-        {
-            var assignExpression = (AssignmentExpressionSyntax)((ExpressionStatementSyntax)statementSyntax).Expression;
-            var declaration = localDeclaration.Declaration;
-            var declarator = declaration.Variables[0];
-
-            return localDeclaration.ReplaceNode(
-                declarator, 
-                declarator.WithInitializer(
-                    SyntaxFactory.EqualsValueClause(
-                        assignExpression.OperatorToken,
-                        assignExpression.Right)));
-        }
-
         protected override async Task<bool> TypesAreCompatibleAsync(
             Document document, ILocalSymbol localSymbol,
             LocalDeclarationStatementSyntax declarationStatement,

src/Features/Core/Portable/MoveDeclarationNearReference/AbstractMoveDeclarationNearReferenceCodeRefactoringProvider.cs

@@ -140,7 +140,7 @@ private static async Task MoveDeclarationToFirstReferenceAsync(Document document
             Document document, State state, SyntaxEditor editor, SyntaxAnnotation warningAnnotation)
         {
             // Replace the first reference with a new declaration.
-            var declarationStatement = CreateMergedDeclarationStatement(state.DeclarationStatement, state.FirstStatementAffectedInInnermostBlock);
+            var declarationStatement = CreateMergedDeclarationStatement(document, state);
             declarationStatement = warningAnnotation == null
                 ? declarationStatement
                 : declarationStatement.WithAdditionalAnnotations(warningAnnotation);
@@ -186,8 +186,6 @@ private bool CrossesMeaningfulBlock(State state)
         protected abstract bool IsValidVariableDeclarator(TVariableDeclaratorSyntax variableDeclarator);
         protected abstract SyntaxToken GetIdentifierOfVariableDeclarator(TVariableDeclaratorSyntax variableDeclarator);
 
-        protected abstract TLocalDeclarationStatementSyntax CreateMergedDeclarationStatement(
-            TLocalDeclarationStatementSyntax localDeclaration, TStatementSyntax statementSyntax);
         protected abstract Task<bool> TypesAreCompatibleAsync(Document document, ILocalSymbol localSymbol, TLocalDeclarationStatementSyntax declarationStatement, SyntaxNode right, CancellationToken cancellationToken);
 
         private async Task<bool> CanMergeDeclarationAndAssignmentAsync(
@@ -221,6 +219,23 @@ private bool CrossesMeaningfulBlock(State state)
             return false;
         }
 
+        private TLocalDeclarationStatementSyntax CreateMergedDeclarationStatement(
+            Document document, State state)
+        {
+            var generator = SyntaxGenerator.GetGenerator(document);
+
+            var syntaxFacts = document.GetLanguageService<ISyntaxFactsService>();
+            syntaxFacts.GetPartsOfAssignmentStatement(
+                state.FirstStatementAffectedInInnermostBlock, 
+                out var left, out var operatorToken, out var right);
+
+            return state.DeclarationStatement.ReplaceNode(
+                state.VariableDeclarator,
+                generator.WithInitializer(
+                    state.VariableDeclarator,
+                    generator.EqualsValueClause(operatorToken, right)));
+        }
+
         private class MyCodeAction : CodeAction.DocumentChangeAction
         {
             public MyCodeAction(Func<CancellationToken, Task<Document>> createChangedDocument)

src/Features/Core/Portable/UseCollectionInitializer/ObjectCreationExpressionAnalyzer.cs

@@ -5,6 +5,7 @@
 using System.Threading;
 using Microsoft.CodeAnalysis.LanguageServices;
 using Microsoft.CodeAnalysis.PooledObjects;
+using Microsoft.CodeAnalysis.Shared.Extensions;
 using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.UseCollectionInitializer

src/Workspaces/CSharp/Portable/CodeGeneration/CSharpSyntaxGenerator.cs

@@ -3935,6 +3935,12 @@ public override SyntaxNode LocalDeclarationStatement(SyntaxNode type, string nam
                 VariableDeclaration(type, name, initializer));
         }
 
+        internal override SyntaxNode WithInitializer(SyntaxNode variableDeclarator, SyntaxNode initializer)
+            => ((VariableDeclaratorSyntax)variableDeclarator).WithInitializer((EqualsValueClauseSyntax)initializer);
+
+        internal override SyntaxNode EqualsValueClause(SyntaxToken operatorToken, SyntaxNode value)
+            => SyntaxFactory.EqualsValueClause(operatorToken, (ExpressionSyntax)value);
+
         private static VariableDeclarationSyntax VariableDeclaration(SyntaxNode type, string name, SyntaxNode expression = null)
         {
             return SyntaxFactory.VariableDeclaration(

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

 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
-using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
 using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Symbols;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.LanguageServices;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.Text;
 using Roslyn.Utilities;

src/Workspaces/CSharp/Portable/LanguageServices/CSharpSyntaxFactsService.cs

@@ -1450,10 +1450,12 @@ public bool IsSimpleAssignmentStatement(SyntaxNode statement)
                 ((ExpressionStatementSyntax)statement).Expression.IsKind(SyntaxKind.SimpleAssignmentExpression);
         }
 
-        public void GetPartsOfAssignmentStatement(SyntaxNode statement, out SyntaxNode left, out SyntaxNode right)
+        public void GetPartsOfAssignmentStatement(
+            SyntaxNode statement, out SyntaxNode left, out SyntaxToken operatorToken, out SyntaxNode right)
         {
             var assignment = (AssignmentExpressionSyntax)((ExpressionStatementSyntax)statement).Expression;
             left = assignment.Left;
+            operatorToken = assignment.OperatorToken;
             right = assignment.Right;
         }
 

src/Workspaces/Core/Portable/Editing/SyntaxGenerator.cs

@@ -1381,6 +1381,9 @@ protected static SyntaxList<TNode> RemoveRange<TNode>(SyntaxList<TNode> list, in
         /// </summary>
         public abstract SyntaxNode LocalDeclarationStatement(SyntaxNode type, string identifier, SyntaxNode initializer = null, bool isConst = false);
 
+        internal abstract SyntaxNode WithInitializer(SyntaxNode variableDeclarator, SyntaxNode initializer);
+        internal abstract SyntaxNode EqualsValueClause(SyntaxToken operatorToken, SyntaxNode value);
+
         /// <summary>
         /// Creates a statement that declares a single local variable.
         /// </summary>

src/Workspaces/Core/Portable/LanguageServices/SyntaxFactsService/ISyntaxFactsService.cs

@@ -93,7 +93,7 @@ internal interface ISyntaxFactsService : ILanguageService
         bool IsLeftSideOfAssignment(SyntaxNode node);
 
         bool IsSimpleAssignmentStatement(SyntaxNode statement);
-        void GetPartsOfAssignmentStatement(SyntaxNode statement, out SyntaxNode left, out SyntaxNode right);
+        void GetPartsOfAssignmentStatement(SyntaxNode statement, out SyntaxNode left, out SyntaxToken operatorToken, out SyntaxNode right);
 
         // Left side of any assignment (for example  *=  or += )
         bool IsLeftSideOfAnyAssignment(SyntaxNode node);

src/Workspaces/Core/Portable/Shared/Extensions/ISyntaxFactsServiceExtensions.cs → src/Workspaces/Core/Portable/LanguageServices/SyntaxFactsService/ISyntaxFactsServiceExtensions.cs

@@ -4,7 +4,7 @@
 using System.Linq;
 using Microsoft.CodeAnalysis.LanguageServices;
 
-namespace Microsoft.CodeAnalysis.Shared.Extensions
+namespace Microsoft.CodeAnalysis.LanguageServices
 {
     internal static class ISyntaxFactsServiceExtensions
     {
@@ -31,5 +31,12 @@ public static bool IsRegularOrDocumentationComment(this ISyntaxFactsService synt
             var leadingBlankLines = syntaxFacts.GetLeadingBlankLines(node);
             return node.GetLeadingTrivia().Skip(leadingBlankLines.Length).ToImmutableArray();
         }
+
+        public static void GetPartsOfAssignmentStatement( 
+            this ISyntaxFactsService syntaxFacts, SyntaxNode statement, 
+            out SyntaxNode left, out SyntaxNode right)
+        {
+            syntaxFacts.GetPartsOfAssignmentStatement(statement, out left, out _, out right);
+        }
     }
 }

src/Workspaces/Core/Portable/Workspaces.csproj

@@ -915,7 +915,7 @@
     <Compile Include="Shared\Extensions\ISymbolExtensions.IsUnsafeVisitor.cs" />
     <Compile Include="Shared\Extensions\ISymbolExtensions_2.cs" />
     <Compile Include="Shared\Extensions\ISymbolExtensions_Accessibility.cs" />
-    <Compile Include="Shared\Extensions\ISyntaxFactsServiceExtensions.cs" />
+    <Compile Include="LanguageServices\SyntaxFactsService\ISyntaxFactsServiceExtensions.cs" />
     <Compile Include="Shared\Extensions\ITypeGenerator.cs" />
     <Compile Include="Shared\Extensions\ITypeInferenceServiceExtensions.cs" />
     <Compile Include="Shared\Extensions\ITypeParameterSymbolExtensions.cs" />

src/Workspaces/VisualBasic/Portable/CodeGeneration/VisualBasicSyntaxGenerator.vb

@@ -438,6 +438,14 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
                 SyntaxFactory.SingletonSeparatedList(VariableDeclarator(type, identifier, initializer)))
         End Function
 
+        Friend Overrides Function WithInitializer(variableDeclarator As SyntaxNode, initializer As SyntaxNode) As SyntaxNode
+            Return DirectCast(variableDeclarator, VariableDeclaratorSyntax).WithInitializer(DirectCast(initializer, EqualsValueSyntax))
+        End Function
+
+        Friend Overrides Function EqualsValueClause(operatorToken As SyntaxToken, value As SyntaxNode) As SyntaxNode
+            Return SyntaxFactory.EqualsValue(operatorToken, DirectCast(value, ExpressionSyntax))
+        End Function
+
         Private Function VariableDeclarator(type As SyntaxNode, name As String, Optional expression As SyntaxNode = Nothing) As VariableDeclaratorSyntax
             Return SyntaxFactory.VariableDeclarator(
                 SyntaxFactory.SingletonSeparatedList(name.ToModifiedIdentifier),

src/Workspaces/VisualBasic/Portable/Extensions/SyntaxTokenExtensions.vb

@@ -3,6 +3,7 @@
 Imports System.Runtime.CompilerServices
 Imports System.Threading
 Imports Microsoft.CodeAnalysis
+Imports Microsoft.CodeAnalysis.LanguageServices
 Imports Microsoft.CodeAnalysis.VisualBasic.Syntax
 
 Namespace Microsoft.CodeAnalysis.VisualBasic.Extensions

src/Workspaces/VisualBasic/Portable/LanguageServices/VisualBasicSyntaxFactsService.vb

@@ -1352,9 +1352,10 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
             Return statement.IsKind(SyntaxKind.SimpleAssignmentStatement)
         End Function
 
-        Public Sub GetPartsOfAssignmentStatement(statement As SyntaxNode, ByRef left As SyntaxNode, ByRef right As SyntaxNode) Implements ISyntaxFactsService.GetPartsOfAssignmentStatement
+        Public Sub GetPartsOfAssignmentStatement(statement As SyntaxNode, ByRef left As SyntaxNode, ByRef operatorToken As SyntaxToken, ByRef right As SyntaxNode) Implements ISyntaxFactsService.GetPartsOfAssignmentStatement
             Dim assignment = DirectCast(statement, AssignmentStatementSyntax)
             left = assignment.Left
+            operatorToken = assignment.OperatorToken
             right = assignment.Right
         End Sub