public override void VisitUsingDirective(UsingDirectiveSyntax node)
{
if (node.ChildNodes().Any(x => x is NameEqualsSyntax))
{
var nameNode = node.ChildNodes().FirstOrDefault(x => x is NameEqualsSyntax);
var alternate = nameNode.ChildNodes().FirstOrDefault().ToString();
var ns = node.ChildNodes().LastOrDefault().ToString();
UsingNamespaces.Add(new NamespaceInfo
{
Namespace = ns,
Alternate = alternate,
});
}
else
{
var ns = node.ChildNodes().FirstOrDefault().ToString();
UsingNamespaces.Add(new NamespaceInfo
{
Namespace = ns,
Alternate = string.Empty,
});
}
base.VisitUsingDirective(node);
}
private bool IsSystemUsing(UsingDirectiveSyntax node)
{
var singleIdentifier = node.ChildNodes().OfType <IdentifierNameSyntax>().FirstOrDefault();
if (singleIdentifier != null &&
string.Equals(UsingsVisitor.SystemUsing, singleIdentifier.ToString()))
{
return(true);
}
var qualifier = node.ChildNodes().OfType <QualifiedNameSyntax>().FirstOrDefault();
var duplicate = qualifier;
if (qualifier == null)
{
return(false);
}
while (qualifier != null)
{
duplicate = qualifier.ChildNodes().OfType <QualifiedNameSyntax>().FirstOrDefault();
if (duplicate == null)
{
return(string.Equals(UsingsVisitor.SystemUsing, qualifier.Left.ToString()));
}
qualifier = duplicate;
}
return(false);
}
private List <string> _GetNamespaces()
{
List <string> nameList = new List <string>();
List <IdentifierNameSyntax> identifiers = new List <IdentifierNameSyntax>();
foreach (var child in _syntax.ChildNodes())
{
if (child.Kind() == SyntaxKind.IdentifierName)
{
identifiers.Add((IdentifierNameSyntax)child);
}
}
foreach (var indentifier in identifiers)
{
nameList.Add(indentifier.Identifier.ToString());
}
if (nameList.Count == 0)
{
Console.WriteLine("Compilation error: no namespaces in using");
Environment.Exit(-1);
}
return(nameList);
}
private static UsingDirectiveSyntax GetNewUsingDirectiveSyntax(
UsingDirectiveSyntax oldUsingDirective,
string newName)
{
var isGlobalOrExternal = oldUsingDirective.DescendantNodes().OfType <AliasQualifiedNameSyntax>().Any() ||
oldUsingDirective.DescendantNodes().OfType <ExternAliasDirectiveSyntax>().Any();
if (newName == null || isGlobalOrExternal)
{
return(oldUsingDirective);
}
var newUsingDirective = SyntaxFactory.UsingDirective(SyntaxFactory.ParseName(newName))
.WithUsingKeyword(oldUsingDirective.UsingKeyword)
.WithSemicolonToken(oldUsingDirective.SemicolonToken);
var nameEquals = oldUsingDirective
.ChildNodes()
.OfType <NameEqualsSyntax>()
.FirstOrDefault();
if (nameEquals != null)
{
newUsingDirective = newUsingDirective.WithAlias(nameEquals);
}
return(newUsingDirective);
}
public override void VisitUsingDirective(UsingDirectiveSyntax node)
{
if (!isCandidate)
{
base.VisitUsingDirective(node);
}
if (IsGlobalOrExternal(node))
{
this.GlobalOrExternalUsings.Add(node);
}
else if (node
.ChildNodes()
.OfType <NameEqualsSyntax>()
.Any())
{
this.UsingsWithAlias.Add(node);
}
else if (this.IsSystemUsing(node))
{
this.SystemUsings.Add(node);
}
else
{
this.Usings.Add(node);
}
}
private ISymbol GetNamespaceSymbol(UsingDirectiveSyntax usingDirective, SemanticModel semanticModel)
{
// Scenario 1 Single IdentifierName
IdentifierNameSyntax identifierName = usingDirective
.ChildNodes()
.OfType <IdentifierNameSyntax>()
.FirstOrDefault();
if (identifierName != null)
{
return(semanticModel.GetSymbolInfo(identifierName).Symbol);
}
SyntaxNode qName = usingDirective.ChildNodes().OfType <QualifiedNameSyntax>().FirstOrDefault();
qName = qName ?? usingDirective.ChildNodes().OfType <AliasQualifiedNameSyntax>().First();
return(semanticModel.GetSymbolInfo(qName).Symbol);
}
