public override SyntaxNode Visit(SyntaxNode node) { // Check each node until we find the property's parent. When we've found it, let's add a private field to it if (_propertyParent.IsEquivalentTo(node)) { var variableDeclarator = SyntaxFactory.VariableDeclarator( SyntaxFactory.Identifier(this.PrivateFieldName)); if (_crunchedProperty.IsExpressionProperty()) { variableDeclarator = variableDeclarator.WithInitializer( SyntaxFactory.EqualsValueClause( SyntaxFactory.Token(SyntaxKind.EqualsToken), _crunchedProperty.ExpressionBody.Expression)); } // Create the private "backing field" of the property var privateField = SyntaxFactory.FieldDeclaration( SyntaxFactory.VariableDeclaration(_crunchedProperty.Type, // Property Type SyntaxFactory.SeparatedList( new[] { variableDeclarator }))) // Field Name .AddModifiers(SyntaxFactory.Token(SyntaxKind.PrivateKeyword)); // Modifier (always private) // Insert the backing field just ahead of the original property var newParent = node.InsertNodesBefore(_crunchedProperty, new[] { privateField }); return base.Visit(newParent); // Return the new parent which replaces the original. } return base.Visit(node); }
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; }
internal static SyntaxNode AddBefore(SyntaxNode root, SyntaxNode loationToAddBefore, SyntaxNode nodeToAdd) { return root.InsertNodesBefore( root.GetCurrentNode(loationToAddBefore) , new List<SyntaxNode> { nodeToAdd }); }
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; }