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); }