private static Solution UpdateMainDocument(Document document, SyntaxNode root, MethodDeclarationSyntax method, IEnumerable<IGrouping<Document, ReferenceLocation>> documentGroups)
{
var mainDocGroup = documentGroups.FirstOrDefault(dg => dg.Key.Equals(document));
SyntaxNode newRoot;
if (mainDocGroup == null)
{
newRoot = root.ReplaceNode(method, method.AddModifiers(staticToken));
}
else
{
var diagnosticNodes = mainDocGroup.Select(referenceLocation => root.FindNode(referenceLocation.Location.SourceSpan)).ToList();
newRoot = root.TrackNodes(diagnosticNodes.Union(new[] { method }));
newRoot = newRoot.ReplaceNode(newRoot.GetCurrentNode(method), method.AddModifiers(staticToken));
foreach (var diagnosticNode in diagnosticNodes)
{
var token = newRoot.FindToken(diagnosticNode.GetLocation().SourceSpan.Start);
var tokenParent = token.Parent;
if (token.Parent.IsKind(SyntaxKind.IdentifierName)) continue;
var invocationExpression = newRoot.GetCurrentNode(diagnosticNode).FirstAncestorOrSelfOfType<InvocationExpressionSyntax>()?.Expression;
if (invocationExpression == null || invocationExpression.IsKind(SyntaxKind.IdentifierName)) continue;
var memberAccess = invocationExpression as MemberAccessExpressionSyntax;
if (memberAccess == null) continue;
var newMemberAccessParent = memberAccess.Parent.ReplaceNode(memberAccess, memberAccess.Name)
.WithAdditionalAnnotations(Formatter.Annotation);
newRoot = newRoot.ReplaceNode(memberAccess.Parent, newMemberAccessParent);
}
}
var newSolution = document.Project.Solution.WithDocumentSyntaxRoot(document.Id, newRoot);
return newSolution;
}
public async static Task<Solution> MakeAutoPropertyAsync(Document document, SyntaxNode root, PropertyDeclarationSyntax property, CancellationToken cancellationToken)
{
var semanticModel = await document.GetSemanticModelAsync(cancellationToken);
var getterReturn = (ReturnStatementSyntax)property.AccessorList.Accessors.First(a => a.Keyword.ValueText == "get").Body.Statements.First();
var returnIdentifier = (IdentifierNameSyntax)(getterReturn.Expression is MemberAccessExpressionSyntax ? ((MemberAccessExpressionSyntax)getterReturn.Expression).Name : getterReturn.Expression);
var returnIdentifierSymbol = semanticModel.GetSymbolInfo(returnIdentifier).Symbol;
var variableDeclarator = (VariableDeclaratorSyntax)returnIdentifierSymbol.DeclaringSyntaxReferences.First().GetSyntax();
var fieldDeclaration = variableDeclarator.FirstAncestorOfType<FieldDeclarationSyntax>();
root = root.TrackNodes(returnIdentifier, fieldDeclaration, property);
document = document.WithSyntaxRoot(root);
root = await document.GetSyntaxRootAsync(cancellationToken);
semanticModel = await document.GetSemanticModelAsync(cancellationToken);
returnIdentifier = root.GetCurrentNode(returnIdentifier);
returnIdentifierSymbol = semanticModel.GetSymbolInfo(returnIdentifier).Symbol;
var newProperty = GetSimpleProperty(property, variableDeclarator)
.WithTriviaFrom(property)
.WithAdditionalAnnotations(Formatter.Annotation);
var newSolution = await Renamer.RenameSymbolAsync(document.Project.Solution, returnIdentifierSymbol, property.Identifier.ValueText, document.Project.Solution.Workspace.Options, cancellationToken);
document = newSolution.GetDocument(document.Id);
root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
root = root.InsertNodesAfter(root.GetCurrentNode(property), new[] { newProperty });
var multipleVariableDeclaration = fieldDeclaration.Declaration.Variables.Count > 1;
if (multipleVariableDeclaration)
{
var newfieldDeclaration = fieldDeclaration.WithDeclaration(fieldDeclaration.Declaration.RemoveNode(variableDeclarator, SyntaxRemoveOptions.KeepNoTrivia));
root = root.RemoveNode(root.GetCurrentNode<SyntaxNode>(property), SyntaxRemoveOptions.KeepNoTrivia);
root = root.ReplaceNode(root.GetCurrentNode(fieldDeclaration), newfieldDeclaration);
}
else
{
root = root.RemoveNodes(root.GetCurrentNodes<SyntaxNode>(new SyntaxNode[] { fieldDeclaration, property }), SyntaxRemoveOptions.KeepNoTrivia);
}
document = document.WithSyntaxRoot(root);
return document.Project.Solution;
}
public async static Task<Solution> MakeAutoPropertyAsync(Document document, SyntaxNode root, PropertyDeclarationSyntax property, CancellationToken cancellationToken)
{
var semanticModel = await document.GetSemanticModelAsync(cancellationToken);
var getterReturn = (ReturnStatementSyntax)property.AccessorList.Accessors.First(a => a.Keyword.ValueText == "get").Body.Statements.First();
var returnIdentifier = (IdentifierNameSyntax)(getterReturn.Expression is MemberAccessExpressionSyntax
? ((MemberAccessExpressionSyntax)getterReturn.Expression).Name
: getterReturn.Expression);
var fieldSymbol = (IFieldSymbol)semanticModel.GetSymbolInfo(returnIdentifier).Symbol;
var variableDeclarator = (VariableDeclaratorSyntax)fieldSymbol.DeclaringSyntaxReferences.First().GetSyntax();
var fieldDeclaration = variableDeclarator.FirstAncestorOfType<FieldDeclarationSyntax>();
var propertySymbol = semanticModel.GetDeclaredSymbol(property);
var newRoot = root.TrackNodes(returnIdentifier, fieldDeclaration, property, variableDeclarator);
//cycle
var newDocument = document.WithSyntaxRoot(newRoot);
newRoot = await newDocument.GetSyntaxRootAsync(cancellationToken);
var newProperty = CreateAutoProperty(property, variableDeclarator, fieldSymbol, propertySymbol);
Solution newSolution;
if (IsExplicityImplementation(propertySymbol))
{
semanticModel = await newDocument.GetSemanticModelAsync(cancellationToken);
returnIdentifier = newRoot.GetCurrentNode(returnIdentifier);
fieldSymbol = (IFieldSymbol)semanticModel.GetSymbolInfo(returnIdentifier).Symbol;
newSolution = await RenameSymbolAndKeepExplicitPropertiesBoundAsync(newDocument.Project.Solution, property.Identifier.ValueText, fieldSymbol, propertySymbol, cancellationToken);
newDocument = newSolution.GetDocument(newDocument.Id);
newRoot = await newDocument.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
newRoot = newRoot.ReplaceNode(newRoot.GetCurrentNode(property), newProperty);
newSolution = newSolution.WithDocumentSyntaxRoot(newDocument.Id, newRoot);
}
else
{
var currentProperty = newRoot.GetCurrentNode(property);
var type = (TypeDeclarationSyntax)currentProperty.Parent;
var propertyIndex = type.Members.IndexOf(currentProperty);
//Remove the property: this is needed otherwise the rename that happens bellow will not be able to
//correctly redirect the references to the field, as the property will conflict with the name.
//The conflict is specially troublesome for circular references, such as the one that caused the bug #702.
newRoot = newRoot.ReplaceNode(type, type.RemoveNode(currentProperty, SyntaxRemoveOptions.KeepNoTrivia));
//cycle
newDocument = newDocument.WithSyntaxRoot(newRoot);
newRoot = await newDocument.GetSyntaxRootAsync(cancellationToken);
semanticModel = await newDocument.GetSemanticModelAsync(cancellationToken);
fieldSymbol = (IFieldSymbol)semanticModel.GetDeclaredSymbol(newRoot.GetCurrentNode(variableDeclarator));
//rename the field:
newSolution = await Renamer.RenameSymbolAsync(newDocument.Project.Solution, fieldSymbol, property.Identifier.ValueText, newDocument.Project.Solution.Workspace.Options, cancellationToken).ConfigureAwait(false);
//cycle
newDocument = newSolution.GetDocument(newDocument.Id);
newRoot = await newDocument.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
//add the property back:
var currentType = (TypeDeclarationSyntax)newRoot.GetCurrentNode(fieldDeclaration).Parent;
var newMembers = currentType.Members.Insert(propertyIndex, newProperty);
var newType = WithMembers(currentType, newMembers);
newRoot = newRoot.ReplaceNode(currentType, newType);
newSolution = newSolution.WithDocumentSyntaxRoot(newDocument.Id, newRoot);
}
newDocument = newSolution.GetDocument(newDocument.Id);
newRoot = await newDocument.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
newRoot = RemoveField(newRoot, variableDeclarator, fieldDeclaration);
return newSolution.WithDocumentSyntaxRoot(newDocument.Id, newRoot);
}
private static async Task<Solution> UpdateMainDocumentAsync(Document document, string fullMethodName, SyntaxNode root, MethodDeclarationSyntax method, IEnumerable<IGrouping<Document, ReferenceLocation>> documentGroups, CancellationToken cancellationToken)
{
var mainDocGroup = documentGroups.FirstOrDefault(dg => dg.Key.Equals(document));
SyntaxNode newRoot;
if (mainDocGroup == null)
{
newRoot = root.ReplaceNode(method, method.WithoutTrivia().AddModifiers(staticToken).WithTriviaFrom(method));
}
else
{
var newMemberAccess = (MemberAccessExpressionSyntax)SyntaxFactory.ParseExpression(fullMethodName);
newMemberAccess = newMemberAccess.WithExpression(
newMemberAccess.Expression.WithAdditionalAnnotations(Simplifier.Annotation));
var diagnosticNodes = mainDocGroup.Select(referenceLocation => root.FindNode(referenceLocation.Location.SourceSpan)).ToList();
newRoot = root.TrackNodes(diagnosticNodes.Union(new[] { method }));
var trackedMethod = newRoot.GetCurrentNode(method);
var staticMethod = method.WithoutTrivia().AddModifiers(staticToken).WithTriviaFrom(method);
newRoot = newRoot.ReplaceNode(trackedMethod, staticMethod);
foreach (var diagnosticNode in diagnosticNodes)
{
var tempDoc = document.WithSyntaxRoot(newRoot);
newRoot = await tempDoc.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
var semanticModel = await tempDoc.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
var syntaxNode = newRoot.GetCurrentNode(diagnosticNode);
var memberAccess = syntaxNode.FirstAncestorOrSelfOfType<MemberAccessExpressionSyntax>();
if (memberAccess?.Expression == null) continue;
if (!syntaxNode.Equals(memberAccess.Name)) continue;
var memberAccessExpressionSymbol = semanticModel.GetSymbolInfo(memberAccess.Expression).Symbol;
var containingMember = memberAccess.FirstAncestorOrSelfThatIsAMember();
var memberSymbol = semanticModel.GetDeclaredSymbol(containingMember);
var allContainingTypes = memberSymbol.GetAllContainingTypes().ToList();
var methodTypeSymbol = GetMethodTypeSymbol(memberAccessExpressionSymbol);
var expressionToReplaceMemberAccess = allContainingTypes.Any(t => t.Equals(methodTypeSymbol))
// ideally we would check the symbols
// but there is a bug on Roslyn 1.0, fixed on 1.1:
// https://github.com/dotnet/roslyn/issues/3096
// so if we try to check the method symbol, it fails and always returns null
// so if we find a name clash, whatever one, we fall back to the full name
? allContainingTypes.Count(t => t.MemberNames.Any(n => n == memberSymbol.Name)) > 1
? (SyntaxNode)newMemberAccess
: memberAccess.Name
: newMemberAccess;
var newMemberAccessParent = memberAccess.Parent.ReplaceNode(memberAccess, expressionToReplaceMemberAccess)
.WithAdditionalAnnotations(Formatter.Annotation)
.WithAdditionalAnnotations(Simplifier.Annotation);
newRoot = newRoot.ReplaceNode(memberAccess.Parent, newMemberAccessParent);
}
}
var newSolution = document.Project.Solution.WithDocumentSyntaxRoot(document.Id, newRoot);
return newSolution;
}
Document ImportStaticClassWithUsing(Document document, SemanticModel model, SyntaxNode root, SyntaxNode node, SymbolInfo info, CancellationToken cancellationToken)
{
var cu = root as CompilationUnitSyntax;
var visitor = new SearchImportReplacementsVisitor(model, info, cancellationToken);
visitor.Visit(root);
cu = (CompilationUnitSyntax)root.TrackNodes(visitor.ReplaceNodes);
foreach (var ma in visitor.ReplaceNodes)
{
var current = cu.GetCurrentNode<MemberAccessExpressionSyntax>(ma);
cu = cu.ReplaceNode(current, current.Name.WithAdditionalAnnotations(Formatter.Annotation));
}
var staticUsing = SyntaxFactory
.UsingDirective(SyntaxFactory.ParseName(info.Symbol.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessageFormat)))
.WithStaticKeyword(SyntaxFactory.Token(SyntaxKind.StaticKeyword))
.WithAdditionalAnnotations(Formatter.Annotation);
cu = cu.AddUsingDirective(staticUsing, node, true);
return document.WithSyntaxRoot(cu);
}
private static SyntaxNode MoveMember(SyntaxNode syntaxRoot, MemberDeclarationSyntax member, MemberDeclarationSyntax targetMember, IndentationOptions indentationOptions)
{
var firstToken = syntaxRoot.GetFirstToken();
var fileHeader = GetFileHeader(firstToken.LeadingTrivia);
syntaxRoot = syntaxRoot.TrackNodes(member, targetMember, firstToken.Parent);
var memberToMove = syntaxRoot.GetCurrentNode(member);
var targetMemberTracked = syntaxRoot.GetCurrentNode(targetMember);
if (!memberToMove.HasLeadingTrivia)
{
var targetIndentationLevel = IndentationHelper.GetIndentationSteps(indentationOptions, targetMember);
var indentationString = IndentationHelper.GenerateIndentationString(indentationOptions, targetIndentationLevel);
memberToMove = memberToMove.WithLeadingTrivia(SyntaxFactory.Whitespace(indentationString));
}
if (!HasLeadingBlankLines(targetMember)
&& HasLeadingBlankLines(member))
{
memberToMove = memberToMove.WithTrailingTrivia(memberToMove.GetTrailingTrivia().Add(SyntaxFactory.CarriageReturnLineFeed));
memberToMove = memberToMove.WithLeadingTrivia(GetLeadingTriviaWithoutLeadingBlankLines(memberToMove));
}
syntaxRoot = syntaxRoot.InsertNodesBefore(targetMemberTracked, new[] { memberToMove });
var fieldToMoveTracked = syntaxRoot.GetCurrentNodes(member).Last();
syntaxRoot = syntaxRoot.RemoveNode(fieldToMoveTracked, SyntaxRemoveOptions.KeepNoTrivia);
if (fileHeader.Any())
{
var oldFirstToken = syntaxRoot.GetCurrentNode(firstToken.Parent).ChildTokens().First();
syntaxRoot = syntaxRoot.ReplaceToken(oldFirstToken, oldFirstToken.WithLeadingTrivia(StripFileHeader(oldFirstToken.LeadingTrivia)));
var newFirstToken = syntaxRoot.GetFirstToken();
syntaxRoot = syntaxRoot.ReplaceToken(newFirstToken, newFirstToken.WithLeadingTrivia(fileHeader.AddRange(newFirstToken.LeadingTrivia)));
}
return syntaxRoot;
}
public static DiagnosticsInDoc Create(DocumentId documentId, IList<Diagnostic> diagnostics, SyntaxNode root)
{
var nodes = diagnostics.Select(d => root.FindNode(d.Location.SourceSpan)).Where(n => !n.IsMissing).ToList();
var diagnosticsInDoc = new DiagnosticsInDoc
{
DocumentId = documentId,
TrackedRoot = root.TrackNodes(nodes),
Nodes = nodes
};
return diagnosticsInDoc;
}
internal static IEnumerable<CodeAction> ScanIfElse(SemanticModel ctx, Document document, SyntaxNode root, IfStatementSyntax ifElseStatement, BinaryExpressionSyntax isExpression, out int foundCastCount)
{
foundCastCount = 0;
var innerCondition = ifElseStatement.Condition.SkipParens();
if (innerCondition != null && innerCondition.IsKind(SyntaxKind.LogicalNotExpression))
{
var c2 = ((PrefixUnaryExpressionSyntax)innerCondition).Operand.SkipParens();
if (c2.IsKind(SyntaxKind.IsExpression))
{
return HandleNegatedCase(ctx, document, root, ifElseStatement, ifElseStatement.Condition, isExpression, out foundCastCount);
}
return Enumerable.Empty<CodeAction>();
}
var castToType = isExpression.Right;
var embeddedStatment = ifElseStatement.Statement;
var rr = ctx.GetTypeInfo(castToType);
if (rr.Type == null || !rr.Type.IsReferenceType)
return Enumerable.Empty<CodeAction>();
List<SyntaxNode> foundCasts;
foundCasts = embeddedStatment.DescendantNodesAndSelf(n => !IsCast(ctx, n, rr.Type)).Where(arg => IsCast(ctx, arg, rr.Type)).ToList();
foundCasts.AddRange(ifElseStatement.Condition.DescendantNodesAndSelf(n => !IsCast(ctx, n, rr.Type)).Where(arg => arg.SpanStart > isExpression.Span.End && IsCast(ctx, arg, rr.Type)));
foundCastCount = foundCasts.Count;
return new[] {
CodeActionFactory.Create(
isExpression.Span,
DiagnosticSeverity.Info,
GettextCatalog.GetString ("Use 'as' and check for null"),
t2 => {
var varName = ReplaceAutoPropertyWithPropertyAndBackingFieldCodeRefactoringProvider.GetNameProposal(RefactoringHelpers.GuessNameFromType(rr.Type), ctx, isExpression);
var varDec = SyntaxFactory.LocalDeclarationStatement(
SyntaxFactory.VariableDeclaration(
SyntaxFactory.ParseTypeName("var"),
SyntaxFactory.SeparatedList(new [] {
SyntaxFactory.VariableDeclarator(varName)
.WithInitializer(SyntaxFactory.EqualsValueClause(
SyntaxFactory.BinaryExpression(SyntaxKind.AsExpression, isExpression.Left, isExpression.Right)
))
})
));
var outerIs = isExpression.AncestorsAndSelf().FirstOrDefault(e => !(e.Parent is ParenthesizedExpressionSyntax));
var binaryOperatorExpression = SyntaxFactory.BinaryExpression(SyntaxKind.NotEqualsExpression, SyntaxFactory.IdentifierName(varName), SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression));
SyntaxNode newRoot;
if (IsEmbeddedStatement(ifElseStatement)) {
foundCasts = ifElseStatement.DescendantNodesAndSelf(n => !IsCast(ctx, n, rr.Type)).Where(arg => IsCast(ctx, arg, rr.Type)).ToList();
var newIf = ifElseStatement.TrackNodes(foundCasts.Concat(new [] { outerIs }));
newIf = newIf.ReplaceNode((SyntaxNode)newIf.GetCurrentNode(outerIs), binaryOperatorExpression.WithAdditionalAnnotations(Formatter.Annotation));
foreach (var c in foundCasts) {
newIf = newIf.ReplaceNode((SyntaxNode)newIf.GetCurrentNode(c), SyntaxFactory.IdentifierName(varName).WithAdditionalAnnotations(Formatter.Annotation));
}
var block = SyntaxFactory.Block(new StatementSyntax[] {
varDec,
newIf
});
newRoot = root.ReplaceNode((SyntaxNode)ifElseStatement, block.WithAdditionalAnnotations(Formatter.Annotation));
} else {
newRoot = root.TrackNodes(foundCasts.Concat(new SyntaxNode[] { ifElseStatement, outerIs }) );
newRoot = newRoot.InsertNodesBefore(newRoot.GetCurrentNode(ifElseStatement), new [] { varDec.WithAdditionalAnnotations(Formatter.Annotation) });
newRoot = newRoot.ReplaceNode((SyntaxNode)newRoot.GetCurrentNode(outerIs), binaryOperatorExpression.WithAdditionalAnnotations(Formatter.Annotation));
foreach (var c in foundCasts) {
newRoot = newRoot.ReplaceNode((SyntaxNode)newRoot.GetCurrentNode(c), SyntaxFactory.IdentifierName(varName).WithAdditionalAnnotations(Formatter.Annotation));
}
}
return Task.FromResult(document.WithSyntaxRoot(newRoot));
}
)
};
}
private static SyntaxNode MoveField(SyntaxNode root, MemberDeclarationSyntax field, MemberDeclarationSyntax firstNonConst)
{
var trackedRoot = root.TrackNodes(field, firstNonConst);
var fieldToMove = trackedRoot.GetCurrentNode(field);
var firstNonConstTracked = trackedRoot.GetCurrentNode(firstNonConst);
if (!fieldToMove.HasLeadingTrivia)
{
fieldToMove = fieldToMove.WithLeadingTrivia(firstNonConstTracked.GetLeadingTrivia().Where(x => x.IsKind(SyntaxKind.WhitespaceTrivia)).LastOrDefault());
}
root = trackedRoot.InsertNodesBefore(firstNonConstTracked, new[] { fieldToMove });
var fieldToMoveTracked = root.GetCurrentNodes(field).Last();
return root.RemoveNode(fieldToMoveTracked, SyntaxRemoveOptions.KeepNoTrivia);
}
private static decimal ProcessObjectInitializer(ObjectCreationExpressionSyntax target,
decimal lastTemporaryIndex, ref SyntaxNode newRoot, ref SyntaxNode[] originalObjectExpressionSyntax,
ref IEnumerable<KeyValuePair<SyntaxNode, SyntaxNode>> replacedNodes, int depth = 0)
{
depth++;
var objectCreation = target;
if (objectCreation.Initializer.IsKind(SyntaxKind.ObjectInitializerExpression))
{
var initializerInfo = GetModel(target).GetTypeInfo(target);
var tempName = initializerInfo.Type.Name + "_helper_" + lastTemporaryIndex++;
var assignments = new List<SyntaxNode>();
foreach (var expression in objectCreation.Initializer.Expressions)
{
var localExpression = (expression as AssignmentExpressionSyntax);
if (localExpression == null)
continue;
var right = localExpression.Right;
var targets =
expression.DescendantNodes()
.OfType<ObjectCreationExpressionSyntax>()
.Where(k => k.Ancestors().OfType<ObjectCreationExpressionSyntax>().First() == target);
var objectCreationExpressionSyntaxs = targets as ObjectCreationExpressionSyntax[] ??
targets.ToArray();
var noriginalObjectExpressionSyntax =
objectCreationExpressionSyntaxs.ToArray<SyntaxNode>().ToArray();
foreach (var ntarget in noriginalObjectExpressionSyntax)
{
lastTemporaryIndex = ProcessObjectInitializer((ObjectCreationExpressionSyntax)ntarget,
lastTemporaryIndex, ref newRoot,
ref originalObjectExpressionSyntax, ref replacedNodes, depth);
}
if (noriginalObjectExpressionSyntax.Any())
{
bool contained;
try
{
newRoot.GetCurrentNode(right);
contained = true;
}
catch (Exception)
{
contained = false;
}
if (contained)
{
if (right is MemberAccessExpressionSyntax) // Since Roslyn 1.0.0, old method doesnt work ...
{
var mar = right as MemberAccessExpressionSyntax;
contained = !(mar.Expression.ToString() == replacedNodes.Last().Key.ToString());
}
else if (right is ObjectCreationExpressionSyntax)
{
var mar = right as ObjectCreationExpressionSyntax;
contained =
!mar.Initializer.DescendantNodes().OfType<ObjectCreationExpressionSyntax>().Any();
//!(mar.ToString () == replacedNodes.Last ().Key.ToString ());
}
}
if (!contained || replacedNodes.Count() == 1) // We been replaced
{
try
{
var str = replacedNodes.Last().Value.ToFullString();
if (right is MemberAccessExpressionSyntax)
{
var mar = right as MemberAccessExpressionSyntax;
right = SyntaxFactory.ParseExpression(str + "." + mar.Name.ToFullString());
}
else
{
// for
// replacedNodes.Any(k => k.Key == right);
right = SyntaxFactory.ParseExpression(str);
// (ExpressionSyntax)replacedNodes.FirstOrDefault(o => o.Key.ToFullString() == right.ToFullString()).Value;
}
replacedNodes = replacedNodes.Except(replacedNodes.Last());
}
catch (Exception)
{
// throw;
}
}
}
var newAssignment =
SyntaxFactory.ExpressionStatement(
SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression,
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName(
tempName), SyntaxFactory.IdentifierName(
localExpression.Left.As<IdentifierNameSyntax>()
.ToFullString())), right)
).NormalizeWhitespace();
assignments.Add(newAssignment);
// var varName = declarator.Identifier.Text + "_helper_"+ e + lastTemporaryIndex++;
}
var statements = new List<StatementSyntax>();
ObjectCreationExpressionSyntax newObjectCreation;
if (objectCreation.ArgumentList == null ||
(!objectCreation.ArgumentList.Arguments.Any()))
{
var text = objectCreation.WithInitializer(null).ToFullString().Trim();
if (!text.EndsWith("()"))
text += "()";
var exp = SyntaxFactory.ParseExpression(text);
newObjectCreation = (ObjectCreationExpressionSyntax)exp;
//SyntaxFactory.ObjectCreationExpression(objectCreation.Type);
}
else
{
newObjectCreation =
objectCreation.WithInitializer(null).WithArgumentList(objectCreation.ArgumentList);
}
var local = SyntaxFactory.LocalDeclarationStatement(
SyntaxFactory.VariableDeclaration(
target.Type,
SyntaxFactory.SeparatedList(new[]
{
SyntaxFactory.VariableDeclarator(
SyntaxFactory.Identifier(tempName),
null,
SyntaxFactory.EqualsValueClause(newObjectCreation))
})
)
).NormalizeWhitespace();
statements.Add(local);
statements.AddRange(assignments.Cast<StatementSyntax>());
var listS = SyntaxFactory.List(statements);
var newList2 = new List<ObjectCreationExpressionSyntax>();
var union2 = originalObjectExpressionSyntax.Union(new SyntaxNode[] { target });
foreach (var statementSyntax in union2)
{
try
{
newList2.Add((ObjectCreationExpressionSyntax)newRoot.GetCurrentNode(statementSyntax));
}
catch (Exception ex)
{
}
}
if (!newList2.Contains(target))
{
//
originalObjectExpressionSyntax =
originalObjectExpressionSyntax.Union(new SyntaxNode[] { target }).ToArray();
}
originalObjectExpressionSyntax = originalObjectExpressionSyntax.Where(l => l != null).ToArray();
newRoot = newRoot.TrackNodes(originalObjectExpressionSyntax);
try
{
var currentNode = newRoot.GetCurrentNode(target);
var lastStatement = currentNode.Ancestors().OfType<StatementSyntax>().First();
newRoot = newRoot.InsertNodesBefore(lastStatement, listS);
// var currentNodes = newRoot.GetCurrentNodes<SyntaxNode>(originalObjectExpressionSyntax);
newRoot = newRoot.TrackNodes(originalObjectExpressionSyntax);
currentNode = newRoot.GetCurrentNode(target);
var newName = SyntaxFactory.ParseExpression(tempName);
var nDict = new Dictionary<SyntaxNode, SyntaxNode>();
foreach (var replacedNode in replacedNodes)
nDict[replacedNode.Key] = replacedNode.Value;
nDict[currentNode] = newName;
replacedNodes = nDict;
// newRoot = newRoot;
newRoot = newRoot.ReplaceNode(currentNode, newName);
var newList = new List<ObjectCreationExpressionSyntax>();
var union = originalObjectExpressionSyntax.Union(nDict.Values); //.Union(new SyntaxNode[]{newName});
foreach (var statementSyntax in union)
{
try
{
// if(statementSyntax==newName)
// {
// newList.Add((ObjectCreationExpressionSyntax) (newName));
// continue;
// }
var syntaxNode = newRoot.GetCurrentNode(statementSyntax);
newList.Add((ObjectCreationExpressionSyntax)syntaxNode);
}
catch (Exception ex)
{
}
}
originalObjectExpressionSyntax = newList.ToArray();
newRoot = newRoot.TrackNodes(originalObjectExpressionSyntax);
}
catch (Exception ex)
{
}
}
return lastTemporaryIndex;
}
private static SyntaxNode CreatRootWithUsingFromMemberAccessedNode(SyntaxNode root, SemanticModel semanticModel, ref string newVariableName, ExpressionSyntax accessedNode)
{
SyntaxNode newRoot;
var memberAccessStatement = accessedNode.Parent;
var newVariableNameParts = newVariableName.Split('.');
newVariableName = newVariableNameParts[newVariableNameParts.Length - 1].ToLowerCaseFirstLetter();
var parentStatement = memberAccessStatement.FirstAncestorOrSelfThatIsAStatement();
var originalName = newVariableName;
for (int nameIncrement = 1; ; nameIncrement++)
{
var speculativeSymbol = semanticModel.GetSpeculativeSymbolInfo(parentStatement.GetLocation().SourceSpan.Start, SyntaxFactory.IdentifierName(newVariableName), SpeculativeBindingOption.BindAsExpression);
if (speculativeSymbol.Symbol == null) break;
newVariableName = originalName + nameIncrement;
}
var newVariable = SyntaxFactory.LocalDeclarationStatement(SyntaxFactory.VariableDeclaration(SyntaxFactory.ParseTypeName("var"),
SyntaxFactory.SeparatedList(new[] {
SyntaxFactory.VariableDeclarator(newVariableName).WithInitializer(SyntaxFactory.EqualsValueClause(accessedNode))
})));
newRoot = root.TrackNodes(parentStatement, accessedNode);
newRoot = newRoot.ReplaceNode(newRoot.GetCurrentNode(accessedNode), SyntaxFactory.IdentifierName(newVariableName));
var newTrackedParentStatement = newRoot.GetCurrentNode(parentStatement);
newRoot = newRoot.InsertNodesBefore(newTrackedParentStatement, new[] { newVariable });
var statement = (LocalDeclarationStatementSyntax)newRoot.GetCurrentNode(parentStatement).GetPreviousStatement();
var variableDeclaration = statement.Declaration;
var variableDeclarator = variableDeclaration.Variables.First();
newRoot = CreateRootWithUsing(newRoot, statement, u => u.WithDeclaration(variableDeclaration.WithoutLeadingTrivia()));
return newRoot;
}
public static SyntaxNode CreateUsing(SyntaxNode root, ObjectCreationExpressionSyntax objectCreation, SemanticModel semanticModel)
{
SyntaxNode newRoot;
if (objectCreation.Parent.IsKind(SyntaxKind.SimpleAssignmentExpression))
{
var assignmentExpression = (AssignmentExpressionSyntax)objectCreation.Parent;
var statement = assignmentExpression.Parent as ExpressionStatementSyntax;
var identitySymbol = (ILocalSymbol)semanticModel.GetSymbolInfo(assignmentExpression.Left).Symbol;
newRoot = UsedOutsideParentBlock(semanticModel, statement, identitySymbol)
? CreateRootAddingDisposeToEndOfMethod(root, statement, identitySymbol)
: CreateRootWithUsing(root, statement, u => u.WithExpression(assignmentExpression));
}
else if (objectCreation.Parent.IsKind(SyntaxKind.EqualsValueClause) && objectCreation.Parent.Parent.IsKind(SyntaxKind.VariableDeclarator))
{
var variableDeclarator = (VariableDeclaratorSyntax)objectCreation.Parent.Parent;
var variableDeclaration = (VariableDeclarationSyntax)variableDeclarator.Parent;
var statement = (LocalDeclarationStatementSyntax)variableDeclaration.Parent;
newRoot = CreateRootWithUsing(root, statement, u => u.WithDeclaration(variableDeclaration.WithoutLeadingTrivia()));
}
else if (objectCreation.Parent.IsKind(SyntaxKind.Argument))
{
var identifierName = GetIdentifierName(objectCreation, semanticModel);
var variableDeclaration = SyntaxFactory.VariableDeclaration(SyntaxFactory.IdentifierName(@"var"))
.WithVariables(SyntaxFactory.SingletonSeparatedList(SyntaxFactory.VariableDeclarator(SyntaxFactory.Identifier(identifierName))
.WithInitializer(SyntaxFactory.EqualsValueClause(SyntaxFactory.Token(SyntaxKind.EqualsToken), objectCreation))));
var arg = objectCreation.Parent as ArgumentSyntax;
var args = objectCreation.Parent.Parent as ArgumentListSyntax;
var newArgs = args.ReplaceNode(arg, arg.WithExpression(SyntaxFactory.IdentifierName(identifierName)));
StatementSyntax statement = objectCreation.FirstAncestorOfType<ExpressionStatementSyntax>();
if (statement != null)
{
var exprStatement = statement.ReplaceNode(args, newArgs);
var newUsingStatment = CreateUsingStatement(exprStatement, SyntaxFactory.Block(exprStatement))
.WithDeclaration(variableDeclaration);
return root.ReplaceNode(statement, newUsingStatment);
}
statement = (StatementSyntax)objectCreation.Ancestors().First(node => node is StatementSyntax);
var newStatement = statement.ReplaceNode(args, newArgs);
var statementsForUsing = new[] { newStatement }.Concat(GetChildStatementsAfter(statement));
var usingBlock = SyntaxFactory.Block(statementsForUsing);
var usingStatement = CreateUsingStatement(newStatement, usingBlock)
.WithDeclaration(variableDeclaration);
var statementsToReplace = new List<StatementSyntax> { statement };
statementsToReplace.AddRange(statementsForUsing.Skip(1));
newRoot = root.ReplaceNodes(statementsToReplace, (node, _) => node.Equals(statement) ? usingStatement : null);
}
else if (objectCreation.Parent.IsKind(SyntaxKind.SimpleMemberAccessExpression))
{
var newVariableName = objectCreation.Type.ToString();
var newVariableNameParts = newVariableName.Split('.');
newVariableName = newVariableNameParts[newVariableNameParts.Length - 1].ToLowerCaseFirstLetter();
var parentStatement = objectCreation.Parent.FirstAncestorOrSelfThatIsAStatement();
var originalName = newVariableName;
for (int nameIncrement = 1; ; nameIncrement++)
{
var speculativeSymbol = semanticModel.GetSpeculativeSymbolInfo(parentStatement.GetLocation().SourceSpan.Start, SyntaxFactory.IdentifierName(newVariableName), SpeculativeBindingOption.BindAsExpression);
if (speculativeSymbol.Symbol == null) break;
newVariableName = originalName + nameIncrement;
}
var newVariable = SyntaxFactory.LocalDeclarationStatement(SyntaxFactory.VariableDeclaration(SyntaxFactory.ParseTypeName("var"),
SyntaxFactory.SeparatedList(new[] {
SyntaxFactory.VariableDeclarator(newVariableName).WithInitializer(SyntaxFactory.EqualsValueClause(objectCreation))
})));
newRoot = root.TrackNodes(parentStatement, objectCreation);
newRoot = newRoot.ReplaceNode(newRoot.GetCurrentNode(objectCreation), SyntaxFactory.IdentifierName(newVariableName));
var newTrackedParentStatement = newRoot.GetCurrentNode(parentStatement);
newRoot = newRoot.InsertNodesBefore(newTrackedParentStatement, new[] { newVariable });
var statement = (LocalDeclarationStatementSyntax)newRoot.GetCurrentNode(parentStatement).GetPreviousStatement();
var variableDeclaration = statement.Declaration;
var variableDeclarator = variableDeclaration.Variables.First();
newRoot = CreateRootWithUsing(newRoot, statement, u => u.WithDeclaration(variableDeclaration.WithoutLeadingTrivia()));
}
else
{
newRoot = CreateRootWithUsing(root, (ExpressionStatementSyntax)objectCreation.Parent, u => u.WithExpression(objectCreation));
}
return newRoot;
}
CodeAction GetAction(Document document, SemanticModel model, SyntaxNode root, SyntaxNode node, MethodDeclarationSyntax method)
{
return CodeActionFactory.Create(node.Span, DiagnosticSeverity.Info, GettextCatalog.GetString("Extract anonymous method"), t2 =>
{
var identifier = SyntaxFactory.IdentifierName(NameGenerator.EnsureUniqueness("Method", model.LookupSymbols(node.SpanStart).Select(s => s.Name)));
var surroundingMemberDeclaration = node.GetAncestor<MemberDeclarationSyntax>();
var rootWithTrackedMember = root.TrackNodes(node, surroundingMemberDeclaration);
var newRoot = rootWithTrackedMember.ReplaceNode(rootWithTrackedMember.GetCurrentNode(node), identifier);
newRoot = newRoot
.InsertNodesBefore(newRoot.GetCurrentNode(surroundingMemberDeclaration),
new[] { method.WithTrailingTrivia(surroundingMemberDeclaration.GetTrailingTrivia()) });
return Task.FromResult(document.WithSyntaxRoot(newRoot));
});
}
