public static Span HasValidCopyright(this CompilationUnitSyntax node)
{
if (node == null)
{
return(null);
}
Error error = Test.CodeCompliance.Query.HasValidCopyright(node.GetLeadingTrivia(), DateTime.Now.Year).Information.FirstOrDefault() as Error;
if (error != null)
{
return(error.Location.Line.ToSpan(node.GetLeadingTrivia().ToString()));
}
return(null);
}
public static CompilationUnitSyntax AddUsings(this CompilationUnitSyntax compilationUnit, bool keepSingleLineCommentsOnTop, params UsingDirectiveSyntax[] usings)
{
if (compilationUnit == null)
{
throw new ArgumentNullException(nameof(compilationUnit));
}
if (usings == null)
{
throw new ArgumentNullException(nameof(usings));
}
if (keepSingleLineCommentsOnTop &&
usings.Length > 0 &&
!compilationUnit.Usings.Any())
{
SyntaxTriviaList leadingTrivia = compilationUnit.GetLeadingTrivia();
SyntaxTrivia[] topTrivia = GetTopSingleLineComments(leadingTrivia).ToArray();
if (topTrivia.Length > 0)
{
compilationUnit = compilationUnit.WithoutLeadingTrivia();
usings[0] = usings[0].WithLeadingTrivia(topTrivia);
usings[usings.Length - 1] = usings[usings.Length - 1].WithTrailingTrivia(leadingTrivia.Skip(topTrivia.Length));
}
}
return(compilationUnit.AddUsings(usings));
}
public override void VisitCompilationUnit(CompilationUnitSyntax compilationUnit)
{
foreach (var m in compilationUnit.ChildNodes())
{
Cx.Try(m, null, () => ((CSharpSyntaxNode)m).Accept(this));
}
ExtractGlobalStatements(compilationUnit);
// Gather comments:
foreach (var trivia in compilationUnit.DescendantTrivia(compilationUnit.Span, descendIntoTrivia: true))
{
CommentPopulator.ExtractComment(Cx, trivia);
}
foreach (var trivia in compilationUnit.GetLeadingTrivia())
{
CommentPopulator.ExtractComment(Cx, trivia);
}
foreach (var trivia in compilationUnit.GetTrailingTrivia())
{
CommentPopulator.ExtractComment(Cx, trivia);
}
}
private static CompilationUnitSyntax RemoveLeadingTrivia(CompilationUnitSyntax root)
{
if (root.HasLeadingTrivia)
{
return(root.ReplaceTrivia(root.GetLeadingTrivia(), (trivia, syntaxTrivia) => default(SyntaxTrivia)));
}
return(root);
}
public override SyntaxNode VisitCompilationUnit(CompilationUnitSyntax node)
{
string leadingComment = node.GetLeadingTrivia().ToFullString();
if (leadingComment.StartsWith(CommentText) || leadingComment.Contains("<auto-generated>"))
{
return(node);
}
else
{
return(node.WithLeadingTrivia(Comment));
}
}
public override SyntaxNode VisitCompilationUnit(CompilationUnitSyntax node)
{
if (node.Usings.Count > 0)
{
var newUsingDirectives = new SyntaxList <UsingDirectiveSyntax>();
var nodesToKeep = node.Usings.Where(directive => directive.Name.ToString() != Constants.Proto.USING_STATEMENT).ToArray();
newUsingDirectives = newUsingDirectives.AddRange(nodesToKeep);
var leadTriv = node.GetLeadingTrivia();
node = node.WithUsings(newUsingDirectives);
node = node.WithLeadingTrivia(leadTriv);
}
return(base.VisitCompilationUnit(node));
}
public static CompilationUnitSyntax AddUsings(CompilationUnitSyntax node, Options options)
{
// Remember leading trivia (e.g. license header comments) so we can restore
// it later. For some reason, manipulating the usings can remove it.
var comment = node.GetLeadingTrivia();
var treeWithTriviaTrimmed = node.WithoutLeadingTrivia();
// add any usings that were required when visiting the tree
var usingsToRemove = treeWithTriviaTrimmed.Usings.FindByName(u => u.Name, "Rhino.Mocks");
var usingsToAdd = CreateUsing("NSubstitute");
var treeWithUsings = AddUsingsToCompilationUnit(treeWithTriviaTrimmed, usingsToRemove, usingsToAdd);
// restore the leading trivia to the new syntax tree.
var treeWithTriviaRestored = treeWithUsings.WithLeadingTrivia(comment);
return(treeWithTriviaRestored);
}
public static async Task <Document> RefactorAsync(
Document document,
CompilationUnitSyntax compilationUnit,
CancellationToken cancellationToken = default(CancellationToken))
{
SyntaxNode root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
CompilationUnitSyntax newNode = compilationUnit
.WithLeadingTrivia(
compilationUnit
.GetLeadingTrivia()
.Insert(0, CSharpFactory.NewLine())
.Insert(0, HeaderTrivia));
root = root.ReplaceNode(compilationUnit, newNode);
return(document.WithSyntaxRoot(root));
}
public static CompilationUnitSyntax AddUsings(CompilationUnitSyntax node, RequiredUsings requiredUsings, Options options)
{
// Remember leading trivia (e.g. license header comments) so we can restore
// it later. For some reason, manipulating the usings can remove it.
var comment = node.GetLeadingTrivia();
var treeWithTriviaTrimmed = options.ConvertAssert
? node.RemoveNUnitUsing().WithoutLeadingTrivia()
: node.WithoutLeadingTrivia();
// add any usings that were required when visiting the tree
var additionalUsings = GenerateAdditionalUsings(node.Usings, requiredUsings, options).ToArray();
var treeWithUsings = AddUsingsToCompilationUnit(treeWithTriviaTrimmed, additionalUsings);
// restore the leading trivia to the new syntax tree.
var treeWithTriviaRestored = treeWithUsings.WithLeadingTrivia(comment);
return(treeWithTriviaRestored);
}
private static void Analyze(SyntaxNodeAnalysisContext context)
{
CompilationUnitSyntax node = (CompilationUnitSyntax)context.Node;
if (Helper.IsGeneratedCode(context) || Helper.IsAssemblyInfo(context) || Helper.HasAutoGeneratedComment(node))
{
return;
}
if (node.FindToken(0).IsKind(SyntaxKind.EndOfFileToken))
{
return;
}
var first = node.GetLeadingTrivia();
if (!first.Any())
{
CreateDiagnostic(context, node.GetLocation());
return;
}
SyntaxTrivia copyrightSyntax = first[0];
if (first[0].IsKind(SyntaxKind.RegionDirectiveTrivia))
{
if (first.Count < 2 || !first[1].IsKind(SyntaxKind.SingleLineCommentTrivia))
{
CreateDiagnostic(context, context.Node.GetLocation());
return;
}
copyrightSyntax = first[1];
}
bool isCorrectStatement = CheckCopyrightStatement(context, copyrightSyntax);
if (!isCorrectStatement)
{
CreateDiagnostic(context, copyrightSyntax.GetLocation());
return;
}
}
public override SyntaxNode VisitCompilationUnit(CompilationUnitSyntax node)
{
node = base.VisitCompilationUnit(node) as CompilationUnitSyntax;
List <ExternAliasDirectiveSyntax> addExterns = new List <ExternAliasDirectiveSyntax>();
List <UsingDirectiveSyntax> addUsings = new List <UsingDirectiveSyntax>();
List <MemberDeclarationSyntax> addMembers = new List <MemberDeclarationSyntax>();
addExterns.AddRange(node.Externs);
foreach (var us in node.Usings)
{
if (us.Name.ToString().IndexOf(m_RootNs) == 0)
{
}
else
{
addUsings.Add(us);
}
}
foreach (var member in node.Members)
{
var ns = member as NamespaceDeclarationSyntax;
if (null != ns)
{
if (ns.Name.ToString().IndexOf(m_RootNs) == 0)
{
ExtractMembersRecursively(addExterns, addUsings, addMembers, ns);
}
else
{
addMembers.Add(member);
}
}
else
{
addMembers.Add(member);
}
}
var newNode = SyntaxFactory.CompilationUnit(SyntaxFactory.List <ExternAliasDirectiveSyntax>(addExterns), SyntaxFactory.List <UsingDirectiveSyntax>(addUsings), node.AttributeLists, SyntaxFactory.List <MemberDeclarationSyntax>(addMembers));
return(newNode.WithLeadingTrivia(node.GetLeadingTrivia()).WithTrailingTrivia(node.GetTrailingTrivia()).WithEndOfFileToken(node.EndOfFileToken));
}
public static bool CanRefactor(CompilationUnitSyntax compilationUnit)
{
foreach (SyntaxTrivia trivia in compilationUnit.GetLeadingTrivia())
{
switch (trivia.Kind())
{
case SyntaxKind.WhitespaceTrivia:
case SyntaxKind.EndOfLineTrivia:
continue;
case SyntaxKind.SingleLineCommentTrivia:
return(!string.Equals(trivia.ToString(), Header, StringComparison.Ordinal));
default:
return(true);
}
}
return(true);
}
/// <summary>
/// Checks for the presence of an "autogenerated" comment in the starting trivia for a file
/// The compiler generates a version of the AssemblyInfo.cs file for certain projects (not named AssemblyInfo.cs), and this is how to pick it up
/// </summary>
/// <param name="node"></param>
/// <returns></returns>
public static bool HasAutoGeneratedComment(CompilationUnitSyntax node)
{
if (node.FindToken(0).IsKind(SyntaxKind.EndOfFileToken))
{
return(false);
}
var first = node.GetLeadingTrivia();
if (first.Count == 0)
{
return(false);
}
string possibleHeader = first.ToFullString();
bool isAutogenerated = possibleHeader.Contains(@"<autogenerated />") || possibleHeader.Contains("<auto-generated");
return(isAutogenerated);
}
public override void VisitCompilationUnit(CompilationUnitSyntax compilationUnit)
{
foreach (var m in compilationUnit.ChildNodes())
{
cx.Try(m, null, () => ((CSharpSyntaxNode)m).Accept(this));
}
// Gather comments:
foreach (SyntaxTrivia trivia in compilationUnit.DescendantTrivia(compilationUnit.Span))
{
CommentLine.Extract(cx, trivia);
}
foreach (var trivia in compilationUnit.GetLeadingTrivia())
{
CommentLine.Extract(cx, trivia);
}
foreach (var trivia in compilationUnit.GetTrailingTrivia())
{
CommentLine.Extract(cx, trivia);
}
}
public override SyntaxNode VisitCompilationUnit(CompilationUnitSyntax node)
{
string comment = string.Format(
"//-----------------------------------------------------------------------\n" +
"// <copyright file=\"{0}\" company=\"{1}\">\n" +
"// {2}\n" +
"// </copyright>\n" +
"//-----------------------------------------------------------------------\n" +
"\n",
Path.GetFileName(node.SyntaxTree.FilePath),
this.settings.CompanyName,
this.settings.Copyright.Replace("\n", "\n// "));
// TODO: figure out how to do this properly.
comment = comment.Replace("\n", Environment.NewLine);
SyntaxTriviaList commentTrivia = Syntax.ParseLeadingTrivia(comment);
var preservedTrivia = node.GetLeadingTrivia().SkipWhile(x =>
x.Kind == SyntaxKind.SingleLineCommentTrivia ||
x.Kind == SyntaxKind.EndOfLineTrivia);
return node.WithLeadingTrivia(commentTrivia.Concat(preservedTrivia));
}
/// <summary>
/// Adds a using statement to the compilation if necessary.
/// </summary>
/// <param name="compilation">The compilation unit to add the using to.</param>
/// <param name="name">The name of the using to add.</param>
/// <returns>The updated compilation unit with the new using.</returns>
public static CompilationUnitSyntax AddUsingIfMissing(CompilationUnitSyntax compilation, NameSyntax name)
{
// TODO improve string comparison (replace)
var stringName = name.ToString();
if (compilation.DescendantNodes().OfType <UsingDirectiveSyntax>().Any(u => Equals(u.Name.ToString(), stringName)))
{
return(compilation);
}
// TODO ensure order?
if (!compilation.ContainsDirectives || compilation.Usings.Count > 0)
{
return(compilation.AddUsings(SyntaxFactory.UsingDirective(name)));
}
// Roslyn bug: AddUsings adds the using before preprocessor settings (aka #define), which is incorrect (compiler error).
return(compilation.WithoutLeadingTrivia().AddUsings(SyntaxFactory.UsingDirective(name).WithLeadingTrivia(compilation.GetLeadingTrivia())));
}