public override void VisitUsingDirective(UsingDirectiveSyntax node)
 {
     //if (node.Name.ToString() != "System" && !node.Name.ToString().StartsWith("System."))
     //{
         this.Usings.Add(node);
     //}
 }

 protected override void VisitUsingDirective(UsingDirectiveSyntax node)
 {
     if (node.Name.GetText() != "System" &&
         !node.Name.GetText().StartsWith("System."))
     {
         Usings.Add(node);
     }
 }

		public static CompilationUnitSyntax AddUsingDirective(
			this CompilationUnitSyntax root,
			UsingDirectiveSyntax usingDirective,
			SyntaxNode contextNode,
			bool placeSystemNamespaceFirst,
			params SyntaxAnnotation[] annotations)
		{
			return root.AddUsingDirectives(new[] { usingDirective }, contextNode, placeSystemNamespaceFirst, annotations);
		}

 public override void VisitUsingDirective(UsingDirectiveSyntax node)
 {
     if (node.IsInSystemWindows() && !uiClass)
     {
         uiClass = true;
         Result.generalAsyncResults.NumUIClasses++;
     }
     base.VisitUsingDirective(node);
 }

        // Hay un visit por cada tipo de nodo. Es bastante útil.
        public override void VisitUsingDirective(UsingDirectiveSyntax node)
        {
            // Propiedad últil de los nodos: CSharpKind (en este caso sería siempre UsingDirective)

            /*Note the Name property of type NameSyntax; this stores the name of the namespace being imported.*/
            if (node.Name.ToString() != "System" &&
                !node.Name.ToString().StartsWith("System."))
            {
                this.Usings.Add(node);
            }
        }

        private static SyntaxToken? GetFirstIdentifierInUsingDirective(UsingDirectiveSyntax usingDirective)
        {
            foreach (var identifier in usingDirective.DescendantNodes())
            {
                IdentifierNameSyntax identifierName = identifier as IdentifierNameSyntax;

                if (identifierName != null && ExcludeGlobalKeyword(identifierName))
                {
                    return identifierName.Identifier;
                }
            }

            return null;
        }

            public override SyntaxNode VisitUsingDirective(UsingDirectiveSyntax node)
            {
                if (node == null) { throw new ArgumentNullException(nameof(node)); }

                if (node.UsingKeyword.TrailingTrivia.FullSpan.IsEmpty)
                {
                    node = node.WithUsingKeyword(node.UsingKeyword.WithTrailingTrivia(SyntaxFactory.Space));
                }

                if (node.SemicolonToken.TrailingTrivia.FullSpan.IsEmpty)
                {
                    node = node.WithSemicolonToken(node.SemicolonToken.WithTrailingTrivia(this.newLineTrivia));
                }

                return node;
            }

 //Note:It must exist, to shortcut visit the using [XXX], otherwise it will visit XXX
 public override SyntaxNode VisitUsingDirective(UsingDirectiveSyntax node)
 {
     if (node.Alias != null)
     {
         this.AppendCompileIssue(node, IssueType.Error, IssueId.UsingAliasNotSupport);
     }
     else
     {
         if (_template.SupportUsing)
         {
             var template = _template.CreateUsingTemplate();
             _output.Write(node, template.GetBeginString());
             this.Visit(node.Name);
             _output.TrivialWriteLine(template.GetEndString());
         }
     }
     return node;
 }

    public override void VisitUsingDirective(UsingDirectiveSyntax node)
    {

      // these could theoretically be acquired by indexing the GAC or something
      var namespaces = new List<String>
      {
        "System",
        "System.Collections",
        "System.Collections.Generic",
        "System.Text",
        "System.Linq"
      };
      string whatAreWeUsing = node.Name.ToString();
      if (!namespaces.Contains(whatAreWeUsing))
      {
        var parts = whatAreWeUsing.Split('.');
        cb.AppendIndent().Append("using namespace ").Append(string.Join("::", parts)).AppendLine(";");
      }
    }

        private static UsingDirectiveSyntax RemoveLeadingAndTrailingCompilerDirectives(UsingDirectiveSyntax usingSyntax)
        {
            UsingDirectiveSyntax usingDirectiveToUse = usingSyntax;
            if (usingDirectiveToUse.HasLeadingTrivia)
            {
                if (usingDirectiveToUse.HasLeadingTrivia)
                {
                    var newLeadingTrivia = RemoveCompilerDirectives(usingDirectiveToUse.GetLeadingTrivia());
                    usingDirectiveToUse = usingDirectiveToUse.WithLeadingTrivia(newLeadingTrivia);
                }
                if (usingDirectiveToUse.HasTrailingTrivia)
                {
                    var newTrailingTrivia = RemoveCompilerDirectives(usingDirectiveToUse.GetTrailingTrivia());
                    usingDirectiveToUse = usingDirectiveToUse.WithTrailingTrivia(newTrailingTrivia);
                }
            }

            return usingDirectiveToUse;
        }

        private IEnumerable<ClassifiedSpan> ClassifyUsingDirectiveSyntax(
            UsingDirectiveSyntax usingDirective,
            SemanticModel semanticModel,
            CancellationToken cancellationToken)
        {
            // For using aliases, we bind the target on the right of the equals and use that
            // binding to classify the alias.
            if (usingDirective.Alias != null)
            {
                var info = semanticModel.GetTypeInfo(usingDirective.Name, cancellationToken);
                if (info.Type != null)
                {
                    var classification = GetClassificationForType(info.Type);
                    if (classification != null)
                    {
                        var token = usingDirective.Alias.Name;
                        return SpecializedCollections.SingletonEnumerable(new ClassifiedSpan(token.Span, classification));
                    }
                }
            }

            return null;
        }

		public override SyntaxNode VisitUsingDirective(UsingDirectiveSyntax node)
		{
			return null;
		}

 private static bool UsingsMatch(UsingDirectiveSyntax usingDirective1, UsingDirectiveSyntax usingDirective2)
 {
     return usingDirective1.Name.ToString() == usingDirective2.Name.ToString() && GetAliasName(usingDirective1) == GetAliasName(usingDirective2);
 }

            public override SyntaxNode VisitUsingDirective(UsingDirectiveSyntax node)
            {
                // The strip list is used to remove using directives that will be moved.
                if (this.stripList.Contains(node))
                {
                    var nextToken = node.SemicolonToken.GetNextToken();

                    if (!nextToken.IsKind(SyntaxKind.None))
                    {
                        var index = TriviaHelper.IndexOfFirstNonBlankLineTrivia(nextToken.LeadingTrivia);
                        if (index != 0)
                        {
                            this.tokensToStrip.AddLast(nextToken);
                        }
                    }

                    return null;
                }

                // The replacement map is used to replace using declarations in place in sorted order (inside directive trivia)
                UsingDirectiveSyntax replacementNode;
                if (this.replaceMap.TryGetValue(node, out replacementNode))
                {
                    return replacementNode;
                }

                return base.VisitUsingDirective(node);
            }

            private void AddUsingDirective(Dictionary<DirectiveSpan, List<UsingDirectiveSyntax>> container, UsingDirectiveSyntax usingDirective, DirectiveSpan owningSpan)
            {
                List<UsingDirectiveSyntax> usingList;

                if (!container.TryGetValue(owningSpan, out usingList))
                {
                    usingList = new List<UsingDirectiveSyntax>();
                    container.Add(owningSpan, usingList);
                }

                usingList.Add(usingDirective);
            }

            private bool IsSeparatedSystemUsing(UsingDirectiveSyntax syntax)
            {
                if (!this.separateSystemDirectives)
                {
                    return false;
                }

                return syntax.Alias == null
                    && syntax.IsSystemUsingDirective()
                    && !syntax.HasNamespaceAliasQualifier()
                    && syntax.StaticKeyword.IsKind(SyntaxKind.None);
            }

 private static string GetAliasName(UsingDirectiveSyntax usingDirective)
 {
     return (usingDirective.Alias == null || usingDirective.Alias.Name == null) ? null : usingDirective.Alias.Name.ToString();
 }

 private static int CompareSpanStart(UsingDirectiveSyntax left, UsingDirectiveSyntax right)
 {
     return left.SpanStart - right.SpanStart;
 }

 public override void VisitUsingDirective(UsingDirectiveSyntax node)
 {
     CheckForInvalid(node);
     base.VisitUsingDirective(node);
 }

 public NamespaceOrTypeAndUsingDirective(NamespaceOrTypeSymbol namespaceOrType, UsingDirectiveSyntax usingDirective)
 {
     this.NamespaceOrType = namespaceOrType;
     this.UsingDirective = usingDirective;
 }