public SyntaxNode link(SyntaxNode node, out Compilation result)
{
var tree = node.SyntaxTree;
SemanticModel model = compilation_.GetSemanticModel(node.SyntaxTree);
node = node.ReplaceNodes(node.GetAnnotatedNodes(Compiler.LinkerAnnotationId), (oldNode, newNode) =>
{
var annotation = oldNode.GetAnnotations(Compiler.LinkerAnnotationId).First();
if (oldNode.SyntaxTree != model.SyntaxTree)
{
oldNode = model.SyntaxTree.GetRoot().GetAnnotatedNodes(Compiler.LinkerAnnotationId).
Where(i => i.GetAnnotations(Compiler.LinkerAnnotationId).First().Data == annotation.Data).First();
}
return ctx_.Link(oldNode, newNode, annotation.Data, model);
});
result = compilation_.ReplaceSyntaxTree(tree, node.SyntaxTree);
model = result.GetSemanticModel(node.SyntaxTree);
return ctx_.ApplyLinkerInfo(node, model, result, out result);
}
private static SyntaxNode StripMultipleBlankLines(SyntaxNode syntaxRoot)
{
var replaceMap = new Dictionary<SyntaxToken, SyntaxToken>();
var usingDirectives = syntaxRoot.GetAnnotatedNodes(UsingCodeFixAnnotation).Cast<UsingDirectiveSyntax>();
foreach (var usingDirective in usingDirectives)
{
var nextToken = usingDirective.SemicolonToken.GetNextToken(true);
// start at -1 to compensate for the always present end-of-line.
var count = -1;
// count the blanks lines at the end of the using statement.
foreach (var trivia in usingDirective.SemicolonToken.TrailingTrivia.Reverse())
{
if (!trivia.IsKind(SyntaxKind.EndOfLineTrivia))
{
break;
}
count++;
}
// count the blank lines at the start of the next token
foreach (var trivia in nextToken.LeadingTrivia)
{
if (!trivia.IsKind(SyntaxKind.EndOfLineTrivia))
{
break;
}
count++;
}
if (count > 1)
{
replaceMap[nextToken] = nextToken.WithLeadingTrivia(nextToken.LeadingTrivia.Skip(count - 1));
}
}
var newSyntaxRoot = syntaxRoot.ReplaceTokens(replaceMap.Keys, (original, rewritten) => replaceMap[original]);
return newSyntaxRoot;
}
private Document PerformAction(Document document, SemanticModel model, SyntaxNode root, String name,
PropertyDeclarationSyntax newProperty, SyntaxAnnotation propAnno, SyntaxAnnotation fieldAnno)
{
var oldField = root.GetAnnotatedNodes(fieldAnno).First() as FieldDeclarationSyntax;
if (oldField.Declaration.Variables.Count == 1)
{
var newRoot = root.RemoveNode(oldField, SyntaxRemoveOptions.KeepNoTrivia);
var oldProperty = newRoot.GetAnnotatedNodes(propAnno).First();
newRoot = newRoot.ReplaceNode((SyntaxNode)oldProperty, newProperty);
return document.WithSyntaxRoot(newRoot);
}
else
{
FieldDeclarationSyntax newField = oldField.WithDeclaration(SyntaxFactory.VariableDeclaration(oldField.Declaration.Type));
//need to replace the field with one missing the variable field
foreach (var variable in oldField.Declaration.Variables)
{
if (!variable.Identifier.ValueText.Equals(name))
newField = newField.AddDeclarationVariables(variable);
}
var newRoot = root.ReplaceNode((SyntaxNode)oldField, newField.WithAdditionalAnnotations(Formatter.Annotation).WithLeadingTrivia(oldField.GetLeadingTrivia()));
var oldProperty = newRoot.GetAnnotatedNodes(propAnno).First();
newRoot = newRoot.ReplaceNode((SyntaxNode)oldProperty, newProperty.WithAdditionalAnnotations(Formatter.Annotation).WithLeadingTrivia(oldProperty.GetLeadingTrivia()));
return document.WithSyntaxRoot(newRoot);
}
}
private static ConstructorDeclarationSyntax GetConstructor(SyntaxNode newRoot, SyntaxAnnotation annotation)
{
return (ConstructorDeclarationSyntax)newRoot.GetAnnotatedNodes(annotation).First();
}
