private List <SuppressOperation>?GetInitialSuppressOperations(
                SyntaxToken token,
                SuppressOption mask
                )
            {
                var startNode     = token.Parent;
                var startPosition = token.SpanStart;

                // starting from given token, move up to root until the first meaningful
                // operation has found
                var list = new List <SuppressOperation>();

                bool predicate(SuppressOperation o)
                {
                    if (o == null)
                    {
                        return(true);
                    }

                    if (!o.TextSpan.Contains(startPosition))
                    {
                        return(true);
                    }

                    if (
                        o.ContainsElasticTrivia(_tokenStream) &&
                        !o.Option.IsOn(SuppressOption.IgnoreElasticWrapping)
                        )
                    {
                        return(true);
                    }

                    if (!o.Option.IsMaskOn(mask))
                    {
                        return(true);
                    }

                    return(false);
                }

                var currentIndentationNode = startNode;

                while (currentIndentationNode != null)
                {
                    _formattingRules.AddSuppressOperations(list, currentIndentationNode);

                    list.RemoveAll(predicate);
                    if (list.Count > 0)
                    {
                        return(list);
                    }

                    currentIndentationNode = currentIndentationNode.Parent;
                }

                return(null);
            }
            private List <SuppressOperation>?GetInitialSuppressOperations(
                SyntaxToken startToken,
                SyntaxToken endToken,
                SuppressOption mask
                )
            {
                var startList = this.GetInitialSuppressOperations(startToken, mask);
                var endList   = this.GetInitialSuppressOperations(endToken, mask);

                return(startList.Combine(endList));
            }
示例#3
0
        internal SuppressOperation(SyntaxToken startToken, SyntaxToken endToken, TextSpan textSpan, SuppressOption option)
        {
            Contract.ThrowIfTrue(textSpan.Start < 0 || textSpan.Length < 0);
            Contract.ThrowIfTrue(startToken.RawKind == 0);
            Contract.ThrowIfTrue(endToken.RawKind == 0);

            this.TextSpan = textSpan;
            this.Option = option;

            this.StartToken = startToken;
            this.EndToken = endToken;
        }
示例#4
0
 protected static void AddSuppressAllOperationIfOnMultipleLine(
     List <SuppressOperation> list,
     SyntaxToken startToken,
     SyntaxToken endToken,
     SuppressOption extraOption = SuppressOption.None
     ) =>
 AddSuppressOperation(
     list,
     startToken,
     endToken,
     SuppressOption.NoSpacingIfOnMultipleLine | SuppressOption.NoWrapping | extraOption
     );
示例#5
0
 protected static void AddSuppressWrappingIfOnSingleLineOperation(
     List <SuppressOperation> list,
     SyntaxToken startToken,
     SyntaxToken endToken,
     SuppressOption extraOption = SuppressOption.None
     ) =>
 AddSuppressOperation(
     list,
     startToken,
     endToken,
     SuppressOption.NoWrappingIfOnSingleLine | extraOption
     );
示例#6
0
        protected static void AddSuppressOperation(
            List <SuppressOperation> list,
            SyntaxToken startToken,
            SyntaxToken endToken,
            SuppressOption option
            )
        {
            if (startToken.Kind() == SyntaxKind.None || endToken.Kind() == SyntaxKind.None)
            {
                return;
            }

            list.Add(FormattingOperations.CreateSuppressOperation(startToken, endToken, option));
        }
示例#7
0
        internal SuppressOperation(
            SyntaxToken startToken,
            SyntaxToken endToken,
            TextSpan textSpan,
            SuppressOption option
            )
        {
            Contract.ThrowIfTrue(textSpan.Start < 0 || textSpan.Length < 0);
            Contract.ThrowIfTrue(startToken.RawKind == 0);
            Contract.ThrowIfTrue(endToken.RawKind == 0);

            this.TextSpan = textSpan;
            this.Option   = option;

            this.StartToken = startToken;
            this.EndToken   = endToken;
        }
示例#8
0
 /// <summary>
 /// create suppress region around the given text span
 /// </summary>
 private static SuppressOperation CreateSuppressOperation(SyntaxToken startToken, SyntaxToken endToken, TextSpan textSpan, SuppressOption option)
 {
     return(new SuppressOperation(startToken, endToken, textSpan, option));
 }
            private List<SuppressOperation> GetInitialSuppressOperations(SyntaxToken token, SuppressOption mask)
            {
                var startNode = token.Parent;
                var startPosition = token.SpanStart;

                // starting from given token, move up to root until the first meaningful
                // operation has found
                var list = new List<SuppressOperation>();

                Predicate<SuppressOperation> predicate = o =>
                {
                    if (o == null)
                    {
                        return true;
                    }

                    if (o.ContainsElasticTrivia(this.tokenStream) && !o.Option.IsOn(SuppressOption.IgnoreElastic))
                    {
                        return true;
                    }

                    if (!o.TextSpan.Contains(startPosition))
                    {
                        return true;
                    }

                    if (!o.Option.IsMaskOn(mask))
                    {
                        return true;
                    }

                    return false;
                };

                var currentIndentationNode = startNode;
                while (currentIndentationNode != null)
                {
                    this.formattingRules.AddSuppressOperations(list, currentIndentationNode);

                    list.RemoveAll(predicate);
                    if (list.Count > 0)
                    {
                        return list;
                    }

                    currentIndentationNode = currentIndentationNode.Parent;
                }

                return null;
            }
示例#10
0
 protected void AddSuppressWrappingIfOnSingleLineOperation(List<SuppressOperation> list, SyntaxToken startToken, SyntaxToken endToken, SuppressOption extraOption = SuppressOption.None)
 {
     AddSuppressOperation(list, startToken, endToken, SuppressOption.NoWrappingIfOnSingleLine | extraOption);
 }
示例#11
0
 /// <summary>
 /// create suppress region around start and end token
 /// </summary>
 public static SuppressOperation CreateSuppressOperation(SyntaxToken startToken, SyntaxToken endToken, SuppressOption option)
 {
     return(CreateSuppressOperation(startToken, endToken, TextSpan.FromBounds(startToken.SpanStart, endToken.Span.End), option));
 }
示例#12
0
 public static SuppressOption RemoveFlag(this SuppressOption option, SuppressOption flag)
 {
     return(option & ~flag);
 }
示例#13
0
 public static bool IsOn(this SuppressOption option, SuppressOption flag)
 {
     return((option & flag) == flag);
 }
 public static bool IsOn(this SuppressOption option, SuppressOption flag)
 => (option & flag) == flag;
示例#15
0
 public static bool IsMaskOn(this SuppressOption option, SuppressOption mask)
 {
     return((option & mask) != 0x0);
 }
 public static bool IsMaskOn(this SuppressOption option, SuppressOption mask)
 => (option & mask) != 0x0;
 public static SuppressOption RemoveFlag(this SuppressOption option, SuppressOption flag)
 => option & ~flag;
示例#18
0
 protected void AddSuppressAllOperationIfOnMultipleLine(List<SuppressOperation> list, SyntaxToken startToken, SyntaxToken endToken, SuppressOption extraOption = SuppressOption.None)
 {
     AddSuppressOperation(list, startToken, endToken, SuppressOption.NoSpacingIfOnMultipleLine | SuppressOption.NoWrapping | extraOption);
 }
            private List<SuppressOperation> GetInitialSuppressOperations(SyntaxToken startToken, SyntaxToken endToken, SuppressOption mask)
            {
                var startList = this.GetInitialSuppressOperations(startToken, mask);
                var endList = this.GetInitialSuppressOperations(endToken, mask);

                return startList.Combine(endList);
            }
 /// <summary>
 /// create suppress region around the given text span
 /// </summary>
 private static SuppressOperation CreateSuppressOperation(SyntaxToken startToken, SyntaxToken endToken, TextSpan textSpan, SuppressOption option)
 {
     return new SuppressOperation(startToken, endToken, textSpan, option);
 }
 /// <summary>
 /// create suppress region around start and end token
 /// </summary>
 public static SuppressOperation CreateSuppressOperation(SyntaxToken startToken, SyntaxToken endToken, SuppressOption option)
 {
     return CreateSuppressOperation(startToken, endToken, TextSpan.FromBounds(startToken.SpanStart, endToken.Span.End), option);
 }
示例#22
0
        protected void AddSuppressOperation(List<SuppressOperation> list, SyntaxToken startToken, SyntaxToken endToken, SuppressOption option)
        {
            if (startToken.CSharpKind() == SyntaxKind.None || endToken.CSharpKind() == SyntaxKind.None)
            {
                return;
            }

            list.Add(FormattingOperations.CreateSuppressOperation(startToken, endToken, option));
        }