static CompilationUnitSyntax RemovePrivateMethods(CompilationUnitSyntax root)
        {
            List<SyntaxNode> removes = new List<SyntaxNode>();

            var classes = root.DescendantNodes().OfType<ClassDeclarationSyntax>();

            foreach (var @class in classes)
            {
                var methods = @class.Members.OfType<MethodDeclarationSyntax>();
                foreach (var method in methods)
                {
                    SyntaxTokenList modifiers = method.Modifiers;
                    bool result = false;
                    foreach (SyntaxToken m in modifiers)
                    {
                        if (m.Text.Equals("private"))
                        {
                            result = true;
                            removes.Add(method);
                            break;
                        }
                    }
                        
                }
            }

            root = root.RemoveNodes(removes,SyntaxRemoveOptions.KeepDirectives);

            return root;
        }

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

 private async Task<Document> ImplementNotifyPropertyChangedAsync(Document document, CompilationUnitSyntax root, SemanticModel model, IEnumerable<ExpandablePropertyInfo> properties, CancellationToken cancellationToken)
 {
     document = document.WithSyntaxRoot(CodeGeneration.ImplementINotifyPropertyChanged(root, model, properties, document.Project.Solution.Workspace));
     document = await Simplifier.ReduceAsync(document, Simplifier.Annotation, cancellationToken: cancellationToken).ConfigureAwait(false);
     document = await Formatter.FormatAsync(document, Formatter.Annotation, cancellationToken: cancellationToken).ConfigureAwait(false);
     return document;
 }

        private static SyntaxElement[] ParseFileContent(CompilationUnitSyntax root, SemanticCache semanticCache)
        {
            var walker = new FileSyntaxWalker(semanticCache);
            walker.Visit(root);

            return walker.ResultsAccumulator.GetResults();
        }

        static CompilationUnitSyntax AddRequiredUsings(CompilationUnitSyntax root)
        {
            NameSyntax name = SyntaxFactory.IdentifierName(" System");
            if (root.Usings.Contains(SyntaxFactory.UsingDirective(name)) == false)
                return root.AddUsings(SyntaxFactory.UsingDirective(name));

            return root;
        }

			public override void VisitCompilationUnit (CompilationUnitSyntax node)
			{
				var startNode = node.DescendantNodesAndSelf (n => region.Start <= n.SpanStart).FirstOrDefault ();
				if (startNode == node || startNode == null) {
					base.VisitCompilationUnit (node);
				} else {
					this.Visit (startNode);
				}
			}

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

            return base.VisitCompilationUnit(node);
        }

 internal static CompilationUnitSyntax AddMethodTo(
     CompilationUnitSyntax destination,
     IMethodSymbol method,
     CodeGenerationOptions options,
     IList<bool> availableIndices)
 {
     var declaration = GenerateMethodDeclaration(method, CodeGenerationDestination.CompilationUnit, options);
     var members = Insert(destination.Members, declaration, options, availableIndices, after: LastMethod);
     return destination.WithMembers(members.ToSyntaxList());
 }

 public override void VisitCompilationUnit(CompilationUnitSyntax node)
 {
     foreach (MemberDeclarationSyntax member in node.Members)
     {
         if (member.Kind() == SyntaxKind.GlobalStatement)
         {
             Visit(member);
         }
     }
 }

        private IList<INamespaceSymbol> GetExistingNamespaces(
            SemanticModel semanticModel, CompilationUnitSyntax compilationUnit, CancellationToken cancellationToken)
        {
            var q = from u in compilationUnit.Usings
                    let symbol = semanticModel.GetSymbolInfo(u.Name, cancellationToken).Symbol as INamespaceSymbol
                    where symbol != null && !symbol.IsGlobalNamespace
                    select symbol;

            return q.ToList();
        }

        private IEnumerable<string> GetImport(CompilationUnitSyntax root)
        {
            List<string> result = new List<string>();

            foreach (var import in root.Usings)
            {
                result.Add(import.Name.ToFullString());
            }

            return result;
        }

 public static CompilationUnitSyntax AddNamedTypeTo(
     ICodeGenerationService service,
     CompilationUnitSyntax destination,
     INamedTypeSymbol namedType,
     CodeGenerationOptions options,
     IList<bool> availableIndices)
 {
     var declaration = GenerateNamedTypeDeclaration(service, namedType, CodeGenerationDestination.CompilationUnit, options);
     var members = Insert(destination.Members, declaration, options, availableIndices);
     return destination.WithMembers(members);
 }

    private IEnumerable<Microsoft.CodeAnalysis.CodeActions.CodeIssue> GetIssuesInternal(IEnumerable<ClousotOutput> results, CompilationUnitSyntax compilationUnitDeclaration)
    {
      IEnumerator<ClousotOutput> enumerator;

      try
      {
        enumerator = results.GetEnumerator();
      }
      catch
      {
        yield break;
      }

      bool hasNext;

      try
      {
        hasNext = enumerator.MoveNext();
      }
      catch
      {
        yield break;
      }

      while (hasNext)
      {
        var result = enumerator.Current;
        
        //foreach (var result in results )
        {
          var msg = result.Message;
          var span = result.Span;
          var action = result.action;
          if (span.IsEmpty)
          {
            msg = "Unknown location: " + msg;
            span = compilationUnitDeclaration.GetFirstToken().Span;
          }
          if (action == null)
            yield return new Microsoft.CodeAnalysis.CodeActions.CodeIssue(Microsoft.CodeAnalysis.CodeActions.CodeIssueKind.Warning, span, msg);
          else
            yield return new Microsoft.CodeAnalysis.CodeActions.CodeIssue(Microsoft.CodeAnalysis.CodeActions.CodeIssueKind.Warning, span, msg, action);
        }
        try
        {
          hasNext = enumerator.MoveNext();
        }
        catch
        {
          yield break;
        }
      }
    }

        internal static CompilationUnitSyntax AddPropertyTo(
            CompilationUnitSyntax destination,
            IPropertySymbol property,
            CodeGenerationOptions options,
            IList<bool> availableIndices)
        {
            var declaration = GeneratePropertyOrIndexer(property, CodeGenerationDestination.CompilationUnit, options);

            var members = Insert(destination.Members, declaration, options,
                availableIndices, after: LastPropertyOrField, before: FirstMember);
            return destination.WithMembers(members);
        }

        public static bool ShouldUseSmartTokenFormatterInsteadOfIndenter(
            IEnumerable<IFormattingRule> formattingRules,
            CompilationUnitSyntax root,
            TextLine line,
            OptionSet optionSet,
            CancellationToken cancellationToken)
        {
            Contract.ThrowIfNull(formattingRules);
            Contract.ThrowIfNull(root);

            if (!optionSet.GetOption(FeatureOnOffOptions.AutoFormattingOnReturn, LanguageNames.CSharp))
            {
                return false;
            }

            if (optionSet.GetOption(FormattingOptions.SmartIndent, LanguageNames.CSharp) != FormattingOptions.IndentStyle.Smart)
            {
                return false;
            }

            var firstNonWhitespacePosition = line.GetFirstNonWhitespacePosition();
            if (!firstNonWhitespacePosition.HasValue)
            {
                return false;
            }

            var token = root.FindToken(firstNonWhitespacePosition.Value);
            if (token.IsKind(SyntaxKind.None) ||
                token.SpanStart != firstNonWhitespacePosition)
            {
                return false;
            }

            // first see whether there is a line operation for current token
            var previousToken = token.GetPreviousToken(includeZeroWidth: true);

            // only use smart token formatter when we have two visible tokens.
            if (previousToken.Kind() == SyntaxKind.None || previousToken.IsMissing)
            {
                return false;
            }

            var lineOperation = FormattingOperations.GetAdjustNewLinesOperation(formattingRules, previousToken, token, optionSet);
            if (lineOperation == null || lineOperation.Option == AdjustNewLinesOption.ForceLinesIfOnSingleLine)
            {
                // no indentation operation, nothing to do for smart token formatter
                return false;
            }

            // We're pressing enter between two tokens, have the formatter figure out hte appropriate
            // indentation.
            return true;
        }

 private static ImmutableArray<LabelSymbol> GetLabels(SynthesizedInteractiveInitializerMethod scriptInitializer, CompilationUnitSyntax syntax)
 {
     var builder = ArrayBuilder<LabelSymbol>.GetInstance();
     foreach (var member in syntax.Members)
     {
         if (member.Kind() != SyntaxKind.GlobalStatement)
         {
             continue;
         }
         LocalScopeBinder.BuildLabels(scriptInitializer, ((GlobalStatementSyntax)member).Statement, ref builder);
     }
     return builder.ToImmutableAndFree();
 }

		private void AddFormattingSpans(
			CompilationUnitSyntax compilationUnit,
			List<TextSpan> spans,
			CancellationToken cancellationToken)
		{
			cancellationToken.ThrowIfCancellationRequested();
			spans.Add(TextSpan.FromBounds(0, GetEndPosition(compilationUnit, compilationUnit.Members)));

			foreach (var @namespace in compilationUnit.Members.OfType<NamespaceDeclarationSyntax>())
			{
				AddFormattingSpans(@namespace, spans, cancellationToken);
			}
		}

 public Model.ParsingResults ParseSource(string filename)
 {
     try
     {
         mTree = CSharpSyntaxTree.ParseFile(filename);
         mRoot = (CompilationUnitSyntax)mTree.GetRoot();
     }
     catch
     {
         throw;
     }
     return Model.ParsingResults.Success;
 }

 public override SyntaxNode VisitCompilationUnit(CompilationUnitSyntax node)
 {
     var value = (CompilationUnitSyntax)base.VisitCompilationUnit(node);
     if (_notPartialClass)
     {
         var usings = _globalModelCompilationUnit.Usings.Where(u => !value.Usings.Any(u2 => u2.Name.ToString() == u.Name.ToString())).ToList();
         if (usings.Count != 0)
         {
             value = value.WithUsings(SyntaxFactory.List<UsingDirectiveSyntax>(value.Usings.Union(usings).OrderBy(u => u.Name.ToString())));
         }
     }
     return value;
 }

		private static Task<Document> FixGuidExportMetadata(Document document, CompilationUnitSyntax root, ClassDeclarationSyntax classDeclaration, string guid)
		{
			var newSyntax = classDeclaration;
			
			newSyntax = newSyntax.ReplaceNode(
				newSyntax.GetAttributes("ExportMetadata").First(x => x.ArgumentList.Arguments[0].ToString() == "\"Guid\""),
				SyntaxFactory.Attribute(SyntaxFactory.ParseName("ExportMetadata"),
					SyntaxFactory.ParseAttributeArgumentList($"(\"Guid\", \"{guid}\")")));

			var newRoot = root.ReplaceNode(classDeclaration, newSyntax);
			var newDocument = document.WithSyntaxRoot(newRoot);
			return Task.FromResult(newDocument);
		}