public static PackageDeclarationSyntax AddUsingDirectives(
this PackageDeclarationSyntax namespaceDeclaration,
IList <UsingDirectiveSyntax> usingDirectives,
bool placeSystemNamespaceFirst,
params SyntaxAnnotation[] annotations)
{
if (!usingDirectives.Any())
{
return(namespaceDeclaration);
}
var specialCaseSystem = placeSystemNamespaceFirst;
var comparer = specialCaseSystem
? UsingsAndExternAliasesDirectiveComparer.SystemFirstInstance
: UsingsAndExternAliasesDirectiveComparer.NormalInstance;
var usings = new List <UsingDirectiveSyntax>();
usings.AddRange(namespaceDeclaration.Usings);
usings.AddRange(usingDirectives);
if (namespaceDeclaration.Usings.IsSorted(comparer))
{
usings.Sort(comparer);
}
usings = usings.Select(u => u.WithAdditionalAnnotations(annotations)).ToList();
var newNamespace = namespaceDeclaration.WithUsings(usings.ToSyntaxList());
return(newNamespace);
}
private static TextSpan GetUsingsSpan(CompilationUnitSyntax root, PackageDeclarationSyntax namespaceDeclaration)
{
if (namespaceDeclaration != null)
{
var usings = namespaceDeclaration.Usings;
var start = usings.First().SpanStart;
var end = usings.Last().Span.End;
return(TextSpan.FromBounds(start, end));
}
else
{
var rootUsings = root.Usings;
if (rootUsings.Any())
{
var start = rootUsings.First().SpanStart;
var end = rootUsings.Last().Span.End;
return(TextSpan.FromBounds(start, end));
}
else
{
var start = 0;
var end = root.Members.Any()
? root.Members.First().GetFirstToken().Span.End
: root.Span.End;
return(TextSpan.FromBounds(start, end));
}
}
}
internal static PackageDeclarationSyntax AddMethodTo(
PackageDeclarationSyntax destination,
IMethodSymbol method,
CodeGenerationOptions options,
IList <bool> availableIndices)
{
var declaration = GenerateMethodDeclaration(method, CodeGenerationDestination.Namespace, options);
var members = Insert(destination.Members, declaration, options, availableIndices, after: LastMethod);
return(destination.WithMembers(members.ToSyntaxList()));
}
public static PackageDeclarationSyntax AddNamedTypeTo(
ICodeGenerationService service,
PackageDeclarationSyntax destination,
INamedTypeSymbol namedType,
CodeGenerationOptions options,
IList <bool> availableIndices)
{
var declaration = GenerateNamedTypeDeclaration(service, namedType, CodeGenerationDestination.Namespace, options);
var members = Insert(destination.Members, declaration, options, availableIndices);
return(ConditionallyAddFormattingAnnotationTo(
destination.WithMembers(members),
members));
}
public static PackageDeclarationSyntax AddNamespaceTo(
ICodeGenerationService service,
PackageDeclarationSyntax destination,
INamespaceSymbol @namespace,
CodeGenerationOptions options,
IList <bool> availableIndices)
{
var declaration = GenerateNamespaceDeclaration(service, @namespace, options);
if (!(declaration is PackageDeclarationSyntax))
{
throw new ArgumentException(CSharpWorkspaceResources.NamespaceCanNotBeAddedIn);
}
var members = Insert(destination.Members, (PackageDeclarationSyntax)declaration, options, availableIndices);
return(destination.WithMembers(members));
}
public override SyntaxNode VisitPackageDeclaration(PackageDeclarationSyntax node)
{
var result = (PackageDeclarationSyntax)base.VisitPackageDeclaration(node);
IList <INamespaceSymbol> namespaces;
if (!namespacesToImport.TryGetValue(node, out namespaces))
{
return(result);
}
if (!result.CanAddUsingDirectives(cancellationToken))
{
return(result);
}
var directives = CreateDirectives(namespaces);
return(result.AddUsingDirectives(directives, placeSystemNamespaceFirst, Formatter.Annotation));
}
private IList <INamespaceSymbol> GetExistingNamespaces(
SemanticModel semanticModel, PackageDeclarationSyntax namespaceDeclaration, CancellationToken cancellationToken)
{
var q = from u in namespaceDeclaration.Usings
let symbol = semanticModel.GetSymbolInfo(u.Name, cancellationToken).Symbol as INamespaceSymbol
where symbol != null && !symbol.IsGlobalNamespace
select symbol;
var usingImports = q.ToList();
var namespaceSymbol = semanticModel.GetDeclaredSymbol(namespaceDeclaration, cancellationToken) as INamespaceSymbol;
var namespaceImports = GetContainingNamespacesAndThis(namespaceSymbol).ToList();
var outerNamespaces = this.GetExistingNamespaces(semanticModel, namespaceDeclaration.Parent, cancellationToken);
return(outerNamespaces.Concat(namespaceImports).Concat(usingImports)
.Distinct()
.OrderBy(INamespaceSymbolExtensions.CompareNamespaces)
.ToList());
}
