public override SyntaxTrivia VisitTrivia(SyntaxTrivia trivia)
        {
            if (trivia.Kind() == SyntaxKind.RegionDirectiveTrivia)
            {
                if (trivia == _region)
                {
                    _nests = 0;
                     return SyntaxFactory.ElasticSpace;
                }
                else if (_nests >= 0)
                {
                    _nests++;
                }
            }
            else if (trivia.Kind() == SyntaxKind.EndRegionDirectiveTrivia)
            {
                if (_nests == 0)
                {
                    _nests = -1;
                    return SyntaxFactory.ElasticSpace;
                }
                else if (_nests >= 0)
                {
                    _nests--;
                }
            }

            return base.VisitTrivia(trivia);
        }

            private bool IsBeginningOrEndOfDocumentComment(SyntaxTrivia trivia)
            {
                var currentParent = trivia.Token.Parent;

                while (currentParent != null)
                {
                    if (currentParent.Kind() == SyntaxKind.SingleLineDocumentationCommentTrivia ||
                        currentParent.Kind() == SyntaxKind.MultiLineDocumentationCommentTrivia)
                    {
                        if (trivia.Span.End == currentParent.SpanStart ||
                            trivia.Span.End == currentParent.Span.End)
                        {
                            return true;
                        }
                        else
                        {
                            return false;
                        }
                    }

                    currentParent = currentParent.Parent;
                }

                return false;
            }

 private void AddClassification(SyntaxTrivia trivia, string type)
 {
     if (trivia.Width() > 0 && _textSpan.OverlapsWith(trivia.Span))
     {
         AddClassification(trivia.Span, type);
     }
 }

 private IEnumerable<OutliningSpan> GetRegions(SyntaxTree syntaxTree, SyntaxTrivia trivia)
 {
     var outliner = new DisabledTextTriviaOutliner();
     var spans = new List<OutliningSpan>();
     outliner.CollectOutliningSpans(syntaxTree, trivia, spans, CancellationToken.None);
     return spans;
 }

 private Task<Document> ReplaceTabWithFourSpacesAsync(Document document, SyntaxNode root, SyntaxTrivia tabTrivia
     , CancellationToken cancellationToken)
 {
     SyntaxTrivia fourSpacesTrivia = SyntaxFactory.Whitespace(new string(' ', 4 * tabTrivia.Span.Length));
     SyntaxNode newRoot = root.ReplaceTrivia(tabTrivia, fourSpacesTrivia);
     return Task.FromResult(document.WithSyntaxRoot(newRoot));
 }

 private static bool IsComment(SyntaxTrivia trivia)
 {
     return trivia.IsKind(SyntaxKind.SingleLineCommentTrivia) ||
         trivia.IsKind(SyntaxKind.MultiLineCommentTrivia) ||
         trivia.IsKind(SyntaxKind.SingleLineDocumentationCommentTrivia) ||
         trivia.IsKind(SyntaxKind.MultiLineDocumentationCommentTrivia);
 }

        private bool NeedsSpaceAdding(SyntaxTrivia trivia)
        {
            if (trivia.Kind != SyntaxKind.SingleLineCommentTrivia)
            {
                return false;
            }

            var text = trivia.ToFullString();

            if (!text.StartsWith("//"))
            {
                return false;
            }

            if (text.StartsWith("///") || text.StartsWith("////"))
            {
                return false;
            }

            if (text.Length >= 3 && text[2] != ' ')
            {
                return true;
            }

            if (text.Length >= 4 && text[2] == ' ' && text[3] == ' ')
            {
                return true;
            }

            return false;
        }

        private static void HandleSingleLineComment(SyntaxTreeAnalysisContext context, SyntaxTrivia singleLineComment)
        {
            int index = 0;

            // PERF: Explicitly cast to IReadOnlyList so we only box once.
            IReadOnlyList<SyntaxTrivia> list = TriviaHelper.GetContainingTriviaList(singleLineComment, out index);
            var firstNonWhiteSpace = TriviaHelper.IndexOfFirstNonWhitespaceTrivia(list);

            // When we encounter a block of single line comments, we only want to raise this diagnostic
            // on the first or last line.  This ensures that whitespace in code commented out using
            // the Comment Selection option in Visual Studio will not raise the diagnostic for every
            // blank line in the code which is commented out.
            bool isFirst = index == firstNonWhiteSpace;
            if (!isFirst)
            {
                // This is -2 because we need to go back past the end of line trivia as well.
                var lastNonWhiteSpace = TriviaHelper.IndexOfTrailingWhitespace(list) - 2;
                if (index != lastNonWhiteSpace)
                {
                    return;
                }
            }

            if (IsNullOrWhiteSpace(singleLineComment.ToString(), 2))
            {
                var diagnostic = Diagnostic.Create(Descriptor, singleLineComment.GetLocation());
                context.ReportDiagnostic(diagnostic);
            }
        }

		public EvaluationResult Evaluate(SyntaxTrivia node)
		{
			var result = EvaluateImpl(node);
			if (result != null)
			{
				var sourceTree = node.GetLocation().SourceTree;
				var filePath = sourceTree.FilePath;
				var typeDefinition = GetNodeType(node.Token.Parent);
				var unitNamespace = GetNamespace(node.Token.Parent);
				if (result.ErrorCount == 0)
				{
					result.ErrorCount = 1;
				}

				result.LinesOfCodeAffected = 0;
				result.Namespace = unitNamespace;
				result.TypeKind = typeDefinition.Item1;
				result.TypeName = typeDefinition.Item2;
				result.Title = Title;
				result.Suggestion = Suggestion;
				result.Quality = Quality;
				result.QualityAttribute = QualityAttribute;
				result.ImpactLevel = ImpactLevel;
				result.FilePath = filePath;
			}

			return result;
		}

 public override void VisitTrivia(SyntaxTrivia trivia)
 {
     if (trivia.Kind != SyntaxKind.DocumentationCommentExteriorTrivia)
     {
         arg.Append(trivia.ToString());
     }
 }

 public override void VisitTrivia(SyntaxTrivia trivia)
 {
     if (TriviaPredicate != null && TriviaAction != null && TriviaPredicate(trivia))
     {
         TriviaAction(trivia);
     }
 }

 public virtual void VisitTrivia(SyntaxTrivia trivia)
 {
     if (this.Depth >= SyntaxWalkerDepth.StructuredTrivia && trivia.HasStructure)
     {
         this.Visit((CSharpSyntaxNode)trivia.GetStructure());
     }
 }

		public override SyntaxTrivia VisitTrivia(SyntaxTrivia trivia)
		{
			var comment = trivia.ToString();
			if (trivia.Kind() == SyntaxKind.MultiLineCommentTrivia)
			{
				if (!comment.StartsWith("/*uncomment"))
				{
					bool shouldCreateTextBlock = trivia.GetParents().Count(p => IsNestingParent(p, trivia)) <= 1;
					if (shouldCreateTextBlock)
						Blocks.Add(ExtractMarkDownFromComment(trivia));
				}
			}
			else if (trivia.Kind() == SyntaxKind.SingleLineCommentTrivia)
			{
				if (comment.StartsWith("//#"))
				{
					var parts = comment.Split(new[] { ' ' }, 2);
					if (parts[0] == "//#video") EmbedVideo(parts[1]);
                    if (parts[0] == "//#include") EmbedCode(parts[1]);
                    if (parts[0] == "//#para") EmbedPara(parts[1]);
                    if (parts[0] == "//#gallery") EmbedGallery(parts[1]);
				}
			}
			return base.VisitTrivia(trivia);
		}

 public override SyntaxTrivia VisitTrivia(SyntaxTrivia trivia)
 {
     if (trivia.Kind() == SyntaxKind.WhitespaceTrivia ||
         trivia.Kind() == SyntaxKind.EndOfLineTrivia)
         return SyntaxTrivia(SyntaxKind.WhitespaceTrivia, string.Empty);
     return base.VisitTrivia(trivia);
 }

        protected override void AppendTodoComments(ImmutableArray<TodoCommentDescriptor> commentDescriptors, SyntacticDocument document, SyntaxTrivia trivia, List<TodoComment> todoList)
        {
            if (PreprocessorHasComment(trivia))
            {
                var message = trivia.ToFullString();

                var index = message.IndexOf(SingleLineCommentPrefix);
                var start = trivia.FullSpan.Start + index;

                AppendTodoCommentInfoFromSingleLine(commentDescriptors, document, message.Substring(index), start, todoList);
                return;
            }

            if (IsSingleLineComment(trivia))
            {
                ProcessMultilineComment(commentDescriptors, document, trivia, postfixLength: 0, todoList: todoList);
                return;
            }

            if (IsMultilineComment(trivia))
            {
                ProcessMultilineComment(commentDescriptors, document, trivia, s_multilineCommentPostfixLength, todoList);
                return;
            }

            throw ExceptionUtilities.Unreachable;
        }

            public override SyntaxTrivia VisitTrivia(SyntaxTrivia trivia)
            {
                if (trivia.Kind() == SyntaxKind.DocumentationCommentExteriorTrivia)
                {
                    if (IsBeginningOrEndOfDocumentComment(trivia))
                    {
                        return base.VisitTrivia(trivia);
                    }
                    else
                    {
                        var triviaText = trivia.ToFullString();

                        var newTriviaText = triviaText.AdjustIndentForXmlDocExteriorTrivia(
                                                _forceIndentation,
                                                _indentation,
                                                _indentationDelta,
                                                _optionSet.GetOption(FormattingOptions.UseTabs, LanguageNames.CSharp),
                                                _optionSet.GetOption(FormattingOptions.TabSize, LanguageNames.CSharp));

                        if (triviaText == newTriviaText)
                        {
                            return base.VisitTrivia(trivia);
                        }

                        var parsedNewTrivia = SyntaxFactory.DocumentationCommentExterior(newTriviaText);

                        return parsedNewTrivia;
                    }
                }

                return base.VisitTrivia(trivia);
            }

 public override void CollectBlockSpans(
     Document document,
     SyntaxTrivia trivia,
     ArrayBuilder<BlockSpan> spans,
     CancellationToken cancellationToken)
 {
     CollectBlockSpans(trivia.SyntaxTree, trivia, spans, cancellationToken);
 }

 public override void CollectOutliningSpans(
     Document document,
     SyntaxTrivia trivia,
     List<OutliningSpan> spans,
     CancellationToken cancellationToken)
 {
     CollectOutliningSpans(trivia.SyntaxTree, trivia, spans, cancellationToken);
 }

 internal static StructuredTriviaSyntax Create(SyntaxTrivia trivia)
 {
     var node = trivia.UnderlyingNode;
     var parent = (CSharpSyntaxNode)trivia.Token.Parent;
     var position = trivia.Position;
     var red = (StructuredTriviaSyntax)node.CreateRed(parent, position);
     red.parent = trivia;
     return red;
 }

        public void Add(SyntaxTrivia[] items, int offset, int length)
        {
            if (nodes == null || count + length > nodes.Length)
            {
                this.Grow(count + length);
            }

            Array.Copy(items, offset, nodes, count, length);
            count += length;
        }