/// <summary>
/// Add a using directive.
/// </summary>
/// <param name="compilationUnit">The <see cref="CompilationUnitSyntax"/>.</param>
/// <param name="usingDirective">The <see cref="UsingDirectiveSyntax"/>.</param>
/// <param name="semanticModel">The <see cref="SemanticModel"/>.</param>
/// <returns>The updated <see cref="CompilationUnitSyntax"/>.</returns>
public static CompilationUnitSyntax AddUsing(this CompilationUnitSyntax compilationUnit, UsingDirectiveSyntax usingDirective, SemanticModel semanticModel)
{
if (compilationUnit is null)
{
throw new System.ArgumentNullException(nameof(compilationUnit));
}
if (semanticModel is null)
{
throw new System.ArgumentNullException(nameof(semanticModel));
}
if (usingDirective is null)
{
throw new System.ArgumentNullException(nameof(usingDirective));
}
if (compilationUnit.Members.TrySingleOfType <MemberDeclarationSyntax, NamespaceDeclarationSyntax>(out NamespaceDeclarationSyntax? ns) &&
UsingDirectiveComparer.IsSameOrContained(ns, usingDirective))
{
return(compilationUnit);
}
using (var walker = UsingDirectiveWalker.Borrow(compilationUnit))
{
if (walker.UsingDirectives.Count == 0)
{
if (walker.NamespaceDeclarations.TryFirst(out var namespaceDeclaration))
{
if (CodeStyle.UsingDirectivesInsideNamespace(semanticModel) != CodeStyleResult.No)
{
return(compilationUnit.ReplaceNode(namespaceDeclaration, namespaceDeclaration.WithUsings(SyntaxFactory.SingletonList(usingDirective))));
}
return(compilationUnit.ReplaceNode(compilationUnit, compilationUnit.WithUsings(SyntaxFactory.SingletonList(usingDirective))));
}
return(compilationUnit);
}
UsingDirectiveSyntax?previous = null;
foreach (var directive in walker.UsingDirectives)
{
var compare = UsingDirectiveComparer.Compare(directive, usingDirective);
if (compare == 0)
{
return(compilationUnit);
}
if (compare > 0)
{
return(compilationUnit.InsertNodesBefore(directive, new[] { usingDirective.WithTrailingElasticLineFeed() }));
}
previous = directive;
}
return(compilationUnit.InsertNodesAfter(previous, new[] { usingDirective.WithTrailingElasticLineFeed() }));
}
}
public static void Borrow()
{
var tree = CSharpSyntaxTree.ParseText(@"
namespace N
{
using System;
using static NUnit.Framework.Assert;
public class C
{
public C()
{
AreEqual(1, 1);
}
}
}");
var expected = new[] { "using System;", "using static NUnit.Framework.Assert;" };
using (var walker = UsingDirectiveWalker.Borrow(tree))
{
CollectionAssert.AreEqual(expected, walker.UsingDirectives.Select(x => x.ToString()));
}
using (var walker = UsingDirectiveWalker.Borrow(tree.GetRoot(CancellationToken.None)))
{
CollectionAssert.AreEqual(expected, walker.UsingDirectives.Select(x => x.ToString()));
}
}
private static SyntaxNode AddUsing(CompilationUnitSyntax root, SemanticModel semanticModel, UsingDirectiveSyntax usingDirective)
{
if (root == null)
{
return(null);
}
using (var walker = UsingDirectiveWalker.Borrow(root))
{
if (walker.UsingDirectives.Count == 0)
{
if (walker.NamespaceDeclarations.TryFirst(out var namespaceDeclaration))
{
if (CodeStyle.UsingDirectivesInsideNamespace(semanticModel))
{
return(root.ReplaceNode(namespaceDeclaration, namespaceDeclaration.WithUsings(SyntaxFactory.SingletonList(usingDirective))));
}
return(root.ReplaceNode(root, root.WithUsings(SyntaxFactory.SingletonList(usingDirective))));
}
return(root);
}
UsingDirectiveSyntax previous = null;
foreach (var directive in walker.UsingDirectives)
{
var compare = UsingDirectiveComparer.Compare(directive, usingDirective);
if (compare == 0)
{
return(root);
}
if (compare > 0)
{
return(root.InsertNodesBefore(directive, new[] { usingDirective }));
}
previous = directive;
}
return(root.InsertNodesAfter(previous, new[] { usingDirective }));
}
}
/// <summary>
/// Figuring out if the code uses using directives inside namespaces.
/// </summary>
/// <param name="semanticModel">The <see cref="SemanticModel"/></param>
/// <returns>True if the code is found to prefix field names with underscore.</returns>
internal static bool UsingDirectivesInsideNamespace(SemanticModel semanticModel)
{
using (var walker = UsingDirectiveWalker.Borrow())
{
switch (UsingDirectivesInsideNamespace(semanticModel.SyntaxTree, walker))
{
case Result.Unknown:
case Result.Maybe:
break;
case Result.Yes:
return(true);
case Result.No:
return(false);
default:
throw new ArgumentOutOfRangeException();
}
foreach (var tree in semanticModel.Compilation.SyntaxTrees)
{
switch (UsingDirectivesInsideNamespace(tree, walker))
{
case Result.Unknown:
case Result.Maybe:
break;
case Result.Yes:
return(true);
case Result.No:
return(false);
default:
throw new ArgumentOutOfRangeException();
}
}
}
return(true);
}
