private static TextSpan GetUsingsSpan(CompilationUnitSyntax root, NamespaceDeclarationSyntax 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);
				}
			}
		}

 //protected override void VisitInvocationExpression(InvocationExpressionSyntax node)
 //{
    
 //}
 public override void VisitNamespaceDeclaration(NamespaceDeclarationSyntax node)
 {
     foreach (var type in node.DescendantNodes().OfType<ClassDeclarationSyntax>())
     {
         Visit(type);
     }
 }

 public override void VisitNamespaceDeclaration(NamespaceDeclarationSyntax node)
 {
     var semanticModel = Context.Instance.Compilation.GetSemanticModel(node.SyntaxTree);
     var symbol = semanticModel.GetDeclaredSymbol(node);
     var fullName = symbol.GetFullName();
     ProcessNamespace(fullName);
 }

        public override SyntaxNode VisitNamespaceDeclaration(NamespaceDeclarationSyntax node)
        {
            string ns = node.Name.ToFullString();//Extend: seems no need to further break down.
            var template = _template.CreateNamespaceTemplate();
            template.Assign(NamespaceTemplate.NAMESPACE, ns);
            if (!RegisteredNamespace.Contains(ns))
            {
                _output.WriteLine(node.Name, template.GetBeginString());
            }

            foreach (var member in node.Members)
            {
                var info = _semanticModel.GetDeclaredSymbol(member);
                if (info.IsNoCompile())
                    continue;

                this.Visit(member);
            }

            if (!RegisteredNamespace.Contains(ns))
            {
                _output.TrivialWriteLine(template.GetEndString());
                RegisteredNamespace.Add(ns);
            }

            return node;
        }

 private static NamespaceDeclarationSyntax AddParameterClassToNamespaceAndUpdateClassToUseNamespace(NamespaceDeclarationSyntax oldNamespace, ClassDeclarationSyntax oldClass, MethodDeclarationSyntax oldMethod)
 {
     var className = $"NewClass{oldMethod.Identifier.Text}";
     var newParameterClass = CreateParameterClass(className, oldMethod);
     var newNamespace = oldNamespace.ReplaceNode(oldClass, UpdateClassToUseNewParameterClass(className, oldClass, oldMethod))
         .AddMembers(newParameterClass);
     return newNamespace;
 }

        public override SyntaxNode VisitNamespaceDeclaration(NamespaceDeclarationSyntax node)
        {
            if (node.Usings.Any() || node.Externs.Any())
            {
                node = node.WithAdditionalAnnotations(LayoutAnnotations.MultiLineConstructAnnotation);
            }

            return base.VisitNamespaceDeclaration(node);
        }

 internal static NamespaceDeclarationSyntax AddMethodTo(
     NamespaceDeclarationSyntax 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());
 }

        /// <summary>Called when the visitor visits a NamespaceDeclarationSyntax node.</summary>
        public override SyntaxNode VisitNamespaceDeclaration(NamespaceDeclarationSyntax node)
        {
            var u = _namespaces.Select(each => SyntaxFactory.UsingDirective(SyntaxFactory.ParseName($" {each}"))
                .WithLeadingTrivia(_leadingTrivia)
                .WithTrailingTrivia(_trailingTrivia)
            ).ToArray();

            node = node.AddUsings(u);
            node = node.WithUsings(Sort(node.Usings));
            return base.VisitNamespaceDeclaration(node);
        }

 public static NamespaceDeclarationSyntax AddNamedTypeTo(
     ICodeGenerationService service,
     NamespaceDeclarationSyntax 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 MemberDeclarationSyntax[] GenerateClasses(NamespaceDeclarationSyntax @namespace)
        {
            var isInterfaceToClass = @namespace.GetLeadingTrivia().Any(trivia => trivia.ToString().Trim() == "//Meta(interface-to-class)");
            if (!isInterfaceToClass)
                return Array<MemberDeclarationSyntax>.Empty;

            var resultMembers = new List<MemberDeclarationSyntax>();
            foreach (var @interface in @namespace.Members.OfType<InterfaceDeclarationSyntax>())
            {
                resultMembers.Add(ToClass(@interface));
            }
            return resultMembers.ToArray();
        }

 private static NamespaceDeclarationSyntax NewNameSpaceFactory(NamespaceDeclarationSyntax OldNameSpace, ClassDeclarationSyntax OldClass, MethodDeclarationSyntax OldMethod)
 {
     var newNameSpace = OldNameSpace;
     var className = $"NewClass{OldMethod.Identifier.Text}";
     var memberNameSpaceOld = (from member in OldNameSpace.Members
                               where member == OldClass
                               select member).FirstOrDefault();
     newNameSpace = OldNameSpace.ReplaceNode(memberNameSpaceOld, NewClassFactory(className, OldClass, OldMethod));
     var newParameterClass = NewClassParameterFactory(className, NewPropertyClassFactory(OldMethod));
     newNameSpace = newNameSpace
                     .WithMembers(newNameSpace.Members.Add(newParameterClass))
                     .WithAdditionalAnnotations(Formatter.Annotation);
     return newNameSpace;
 }

        public static NamespaceDeclarationSyntax AddNamespaceTo(
            ICodeGenerationService service,
            NamespaceDeclarationSyntax destination,
            INamespaceSymbol @namespace,
            CodeGenerationOptions options,
            IList<bool> availableIndices)
        {
            var declaration = GenerateNamespaceDeclaration(service, @namespace, options);
            if (!(declaration is NamespaceDeclarationSyntax))
            {
                throw new ArgumentException(CSharpWorkspaceResources.NamespaceCanNotBeAddedIn);
            }

            var members = Insert(destination.Members, (NamespaceDeclarationSyntax)declaration, options, availableIndices);
            return destination.WithMembers(members);
        }

            public override SyntaxNode VisitNamespaceDeclaration(NamespaceDeclarationSyntax node)
            {
                var result = (NamespaceDeclarationSyntax)base.VisitNamespaceDeclaration(node);
                if (!_namespacesToImport.TryGetValue(node, out var namespaces))
                {
                    return result;
                }

                if (!result.CanAddUsingDirectives(_cancellationToken))
                {
                    return result;
                }

                var directives = CreateDirectives(namespaces);
                return result.AddUsingDirectives(directives, _placeSystemNamespaceFirst, Formatter.Annotation);
            }

    public override void VisitNamespaceDeclaration(NamespaceDeclarationSyntax node)
    {
      var parts = node.Name.ToString().Split('.');
      cb.AppendIndent();
      foreach (var part in parts)
      {
        cb.Append("namespace ").Append(part).Append(" { ");
      }
      cb.AppendLine();

      base.VisitNamespaceDeclaration(node);

      cb.AppendIndent();
      foreach (var part in parts)
        cb.Append("} /* " + part + "*/ ");
      cb.AppendLine();
    }

        public override SyntaxNode VisitNamespaceDeclaration(NamespaceDeclarationSyntax node)
        {
            var identifierName = SyntaxFactory.IdentifierName(_typeNamespace);
            var newNamespace = SyntaxFactory.NamespaceDeclaration(identifierName);

            var newNode =  node.Update(
                node.NamespaceKeyword,
                newNamespace.Name,
                node.OpenBraceToken,
                node.Externs,
                node.Usings,
                node.Members,
                node.CloseBraceToken,
                node.SemicolonToken);

            return base.VisitNamespaceDeclaration(newNode);
        }

        private IList<INamespaceSymbol> GetExistingNamespaces(
            SemanticModel semanticModel, NamespaceDeclarationSyntax 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();
        }

        private async Task<Solution> FixBadNamespace(Document document, NamespaceDeclarationSyntax namespaceDecl, CancellationToken cancellationToken)
        {
            try
            {
                var newName = GetNamespaceName(document.Project, document.Folders);

                var semanticModel = await document.GetSemanticModelAsync(cancellationToken);
                INamespaceSymbol nsSymbol = semanticModel.GetDeclaredSymbol(namespaceDecl, cancellationToken);
                Solution originalSolution = document.Project.Solution;
                OptionSet optionSet = originalSolution.Workspace.Options;

                var newSolution = await Renamer.RenameSymbolAsync(originalSolution, nsSymbol, newName, optionSet, cancellationToken).ConfigureAwait(false);

                return newSolution;
            }
            catch (OperationCanceledException ocex)
            {
                Debug.WriteLine(ocex.Message);
                return document.Project.Solution;
            }
        }

        private static int GetNamespaceId(SyntaxNode container, NamespaceDeclarationSyntax target, ref int index)
        {
            var compilation = container as CompilationUnitSyntax;
            if (compilation != null)
            {
                return GetNamespaceId(compilation.Members, target, ref index);
            }

            var @namespace = container as NamespaceDeclarationSyntax;
            if (@namespace != null)
            {
                return GetNamespaceId(@namespace.Members, target, ref index);
            }

            return Contract.FailWithReturn<int>("shouldn't reach here");
        }

 private SyntaxNode RegisterNamespaceDeclarationCodeFix(SyntaxNode syntaxRoot, NamespaceDeclarationSyntax node, IndentationOptions indentationOptions)
 {
     return this.ReformatElement(syntaxRoot, node, node.OpenBraceToken, node.CloseBraceToken, indentationOptions);
 }

        /// <summary>
        /// Given a namespace declaration syntax node, get the corresponding namespace symbol for the declaration
        /// assembly.
        /// </summary>
        /// <param name="declarationSyntax">The syntax node that declares a namespace.</param>
        /// <param name="cancellationToken">The cancellation token.</param>
        /// <returns>The namespace symbol that was declared by the namespace declaration.</returns>
        public override INamespaceSymbol GetDeclaredSymbol(NamespaceDeclarationSyntax declarationSyntax, CancellationToken cancellationToken = default(CancellationToken))
        {
            CheckSyntaxNode(declarationSyntax);

            return GetDeclaredNamespace(declarationSyntax);
        }