示例#1
0
        private IFormattingResult FormatIndividually(
            SyntaxNode node, OptionSet options, IEnumerable <AbstractFormattingRule> rules, IList <TextSpan> spansToFormat, CancellationToken cancellationToken)
        {
            List <AbstractFormattingResult> results = null;

            foreach (var pair in node.ConvertToTokenPairs(spansToFormat))
            {
                if (node.IsInvalidTokenRange(pair.Item1, pair.Item2))
                {
                    continue;
                }

                results ??= new List <AbstractFormattingResult>();
                results.Add(Format(node, options, rules, pair.Item1, pair.Item2, cancellationToken));
            }

            // quick simple case check
            if (results == null)
            {
                return(CreateAggregatedFormattingResult(node, SpecializedCollections.EmptyList <AbstractFormattingResult>()));
            }

            if (results.Count == 1)
            {
                return(results[0]);
            }

            // more expensive case
            return(CreateAggregatedFormattingResult(node, results));
        }
        private IFormattingResult FormatIndividually(
            SyntaxNode node, OptionSet options, IEnumerable<IFormattingRule> rules, IList<TextSpan> spansToFormat, CancellationToken cancellationToken)
        {
            List<AbstractFormattingResult> results = null;
            foreach (var pair in node.ConvertToTokenPairs(spansToFormat))
            {
                if (node.IsInvalidTokenRange(pair.Item1, pair.Item2))
                {
                    continue;
                }

                results = results ?? new List<AbstractFormattingResult>();
                results.Add(Format(node, options, rules, pair.Item1, pair.Item2, cancellationToken));
            }

            // quick simple case check
            if (results == null)
            {
                return CreateAggregatedFormattingResult(node, SpecializedCollections.EmptyList<AbstractFormattingResult>());
            }

            if (results.Count == 1)
            {
                return results[0];
            }

            // more expensive case
            return CreateAggregatedFormattingResult(node, results);
        }
示例#3
0
        public IFormattingResult GetFormattingResult(SyntaxNode node, IEnumerable <TextSpan>?spans, SyntaxFormattingOptions options, IEnumerable <AbstractFormattingRule>?rules, CancellationToken cancellationToken)
        {
            IReadOnlyList <TextSpan> spansToFormat;

            if (spans == null)
            {
                spansToFormat = node.FullSpan.IsEmpty ?
                                SpecializedCollections.EmptyReadOnlyList <TextSpan>() :
                                SpecializedCollections.SingletonReadOnlyList(node.FullSpan);
            }
            else
            {
                spansToFormat = new NormalizedTextSpanCollection(spans.Where(s_notEmpty));
            }

            if (spansToFormat.Count == 0)
            {
                return(CreateAggregatedFormattingResult(node, SpecializedCollections.EmptyList <AbstractFormattingResult>()));
            }

            rules ??= GetDefaultFormattingRules();

            List <AbstractFormattingResult>?results = null;

            foreach (var(startToken, endToken) in node.ConvertToTokenPairs(spansToFormat))
            {
                if (node.IsInvalidTokenRange(startToken, endToken))
                {
                    continue;
                }

                results ??= new List <AbstractFormattingResult>();
                results.Add(Format(node, options, rules, startToken, endToken, cancellationToken));
            }

            // quick simple case check
            if (results == null)
            {
                return(CreateAggregatedFormattingResult(node, SpecializedCollections.EmptyList <AbstractFormattingResult>()));
            }

            if (results.Count == 1)
            {
                return(results[0]);
            }

            // more expensive case
            return(CreateAggregatedFormattingResult(node, results));
        }