// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
 
#nullable disable
 
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.EditAndContinue;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Test.Utilities;
using Microsoft.CodeAnalysis.Text;
using Roslyn.Test.Utilities;
using Xunit;
 
namespace Microsoft.VisualStudio.LanguageServices.CSharp.UnitTests.Debugging;
 
[Trait(Traits.Feature, Traits.Features.DebuggingBreakpoints)]
public class BreakpointSpansTests
{
    #region Helpers 
 
    private static void TestSpan(string markup, ParseOptions options = null)
        => Test(markup, isMissing: false, isLine: false, options: options);
 
    private static void TestMissing(string markup)
        => Test(markup, isMissing: true, isLine: false);
 
    private static void TestLine(string markup)
        => Test(markup, isMissing: false, isLine: true);
 
    private static void Test(string markup, bool isMissing, bool isLine, ParseOptions options = null)
    {
        MarkupTestFile.GetPositionAndSpan(
            markup, out var source, out var position, out TextSpan? expectedSpan);
        var tree = SyntaxFactory.ParseSyntaxTree(source, options);
 
        var hasBreakpoint = BreakpointSpans.TryGetBreakpointSpan(
            tree, position.Value, CancellationToken.None, out var breakpointSpan);
 
        if (isLine)
        {
            Assert.True(hasBreakpoint);
            Assert.True(breakpointSpan.Length == 0);
        }
        else if (isMissing)
        {
            Assert.False(hasBreakpoint);
        }
        else
        {
            Assert.True(hasBreakpoint);
            AssertEx.AreEqual(
                expectedSpan.Value,
                breakpointSpan,
                message: $"Expected: [|{source.Substring(expectedSpan.Value.Start, expectedSpan.Value.Length)}|], Actual: [|{source.Substring(breakpointSpan.Start, breakpointSpan.Length)}|]");
        }
    }
 
    /// <summary>
    /// Verifies all breakpoint spans of the declaration node marked by $$ in <paramref name="markup"/>
    /// and it's breakpoint span envelope (span that contains all breakpoint span of the declaration).
    /// 
    /// Only test declarations that have a single possible body (e.g. <see cref="VariableDeclaratorSyntax"/>,
    /// not <see cref="FieldDeclarationSyntax"/> or <see cref="VariableDeclarationSyntax"/>).
    /// </summary>
    private static void VerifyAllSpansInDeclaration<TDeclaration>(string markup)
        where TDeclaration : SyntaxNode
    {
        MarkupTestFile.GetPositionAndSpans(markup, out var source, out var position, out var expectedSpans);
 
        var tree = SyntaxFactory.ParseSyntaxTree(source);
        var root = tree.GetRoot();
        var declarationNode = root.FindToken(position).Parent.FirstAncestorOrSelf<TDeclaration>();
 
        var actualSpans = GetBreakpointSequence(declarationNode, position).ToArray();
 
        AssertEx.Equal(expectedSpans, actualSpans,
            itemSeparator: "\r\n",
            itemInspector: span => "[|" + source.Substring(span.Start, span.Length) + "|]");
 
        var expectedEnvelope = expectedSpans.IsEmpty ? default : TextSpan.FromBounds(expectedSpans[0].Start, expectedSpans[^1].End);
        Assert.NotNull(declarationNode);
 
        var actualEnvelope = SyntaxUtilities.TryGetDeclarationBody(declarationNode, symbol: null)?.Envelope ?? default;
        Assert.Equal(expectedEnvelope, actualEnvelope);
    }
 
    public static IEnumerable<TextSpan> GetBreakpointSequence(SyntaxNode root, int position)
    {
        TextSpan lastSpan = default;
        var endPosition = root.Span.End;
        for (var p = position; p < endPosition; p++)
        {
            if (BreakpointSpans.TryGetClosestBreakpointSpan(root, p, minLength: 0, out var span) && span.Start > lastSpan.Start)
            {
                lastSpan = span;
                yield return span;
            }
        }
    }
 
    #endregion
 
    [Fact]
    public void GetBreakpointSequence1()
    {
        VerifyAllSpansInDeclaration<MethodDeclarationSyntax>(@"
class C
{
    $$void Goo()
    [|{|]
        [|int d = 5;|]
        [|int a = 1|], [|b = 2|], [|c = 3|];
        for ([|int i = 0|], [|j = 1|], [|k = 2|]; [|i < 10|]; [|i++|], [|j++|], [|k--|])
            [|while (b > 0)|]
            [|{|]
                [|if (c < b)|]
                    try
                    [|{|]
                        [|System.Console.WriteLine(a);|]
                    [|}|]
                    [|catch (Exception e)|]
                    [|{|]
                        [|System.Console.WriteLine(e);|]   
                    [|}|]
                    finally
                    [|{|]
                    [|}|]
                else [|if (b < 10)|]
                    [|System.Console.WriteLine(b);|]
                else
                    [|System.Console.WriteLine(c);|]
            [|}|]
    [|}|]
}");
    }
 
    [Fact]
    public void GetBreakpointSequence2()
    {
        VerifyAllSpansInDeclaration<MethodDeclarationSyntax>(@"
class C
{
    $$void Goo()
    [|{|]
        do
        [|{|]
            label:
               [|i++;|]
            [|var l = new List<int>()
            {
               F(),
               F(),
            };|]
            [|break;|]
            [|continue;|]
        [|}|]
        [|while (a);|]
        [|goto label;|]
    [|}|]
}");
    }
 
    [Fact]
    public void GetBreakpointSequence3()
    {
        VerifyAllSpansInDeclaration<MethodDeclarationSyntax>(@"
class C
{
    $$int Goo()
    [|{|]
        [|switch(a)|]
        {
            case 1:
            case 2:
                [|break;|]
            
            case 3:
                [|goto case 4;|]
        
            case 4: 
                [|throw new Exception();|]
                [|goto default;|]
            
            default:
                [|return 1;|]
        }
        [|return 2;|]
    [|}|]
}");
    }
 
    [Fact]
    public void GetBreakpointSequence4()
    {
        VerifyAllSpansInDeclaration<MethodDeclarationSyntax>(@"
class C
{
    $$IEnumerable<int> Goo()
    [|{|]
        [|yield return 1;|]
        [|foreach|] ([|var f|] [|in|] [|Goo()|])
        [|{|]
            [|using (z)|]
            using ([|var q = null|])
            using ([|var u = null|], [|v = null|])
            [|{|]
                [|while (a)|] [|yield return 2;|]
            [|}|]
        [|}|]
        fixed([|int* a = new int[1]|], [|b = new int[1]|], [|c = new int[1]|]) [|{|][|}|]
        [|yield break;|]
    [|}|]
}");
    }
 
    [Fact]
    public void GetBreakpointSequence5()
    {
        VerifyAllSpansInDeclaration<MethodDeclarationSyntax>(@"
class C
{
    $$IEnumerable<int> Goo()
    [|{|][|while(t)|][|{|][|}|][|}|]
}");
    }
 
    [Fact]
    public void GetBreakpointSequence6()
    {
        VerifyAllSpansInDeclaration<MethodDeclarationSyntax>(@"
class C
{
    $$IEnumerable<int> Goo()
    [|{|]
        checked 
        [|{|]
            const int a = 1;
            const int b = 2;
            unchecked 
            [|{|]
                unsafe
                [|{|]
                    [|lock(l)|]
                    [|{|]
                        [|;|]
                    [|}|]    
                [|}|]    
            [|}|]    
        [|}|]
    [|}|]
}");
    }
 
    [Fact]
    public void GetBreakpointSequence_StaticContructor_NoBody()
    {
        VerifyAllSpansInDeclaration<ConstructorDeclarationSyntax>(@"
class Class
{
    static Clas$$s()
}");
    }
 
    [Fact]
    public void GetBreakpointSequence_Method_NoBody()
    {
        VerifyAllSpansInDeclaration<MethodDeclarationSyntax>(@"
class Class
{
    int F$$unction()
}");
    }
 
    #region Switch Expression
 
    [Fact]
    public void SwitchExpression_All()
    {
        VerifyAllSpansInDeclaration<MethodDeclarationSyntax>(@"
class C
{
    $$IEnumerable<int> Goo()
    [|{|]
        [|_ = M2(
            c
            switch
            {
                (1) _ [|when f|] => [|M(0)|],
                (3) _ [|when f|] => [|M(1)|],
                (1, 2) _ [|when f|] => [|M(0)|],
                (3, 4) _ [|when f|] => [|M(2)|],
                _ => [|M(4)|],
            },
            M(5));|]
    [|}|]
}");
    }
 
    [Fact]
    public void SwitchExpression01()
    {
        TestSpan(
@"class C
{
    void Goo()
    {
$$        [|_ = e switch
        {
            1 when f => 2,
            3 when g => 4,
            _ => 5,
        };|]
    }
}");
    }
 
    [Fact]
    public void SwitchExpression02()
    {
        TestSpan(
@"class C
{
    void Goo()
    {
        [|_ = e switch
        $${
            1 when f => 2,
            3 when g => 4,
            _ => 5,
        };|]
    }
}");
    }
 
    [Fact]
    public void SwitchExpression03()
    {
        TestSpan(
@"class C
{
    void Goo()
    {
        _ = e switch
        {$$
            1 [|when f|] => 2,
            3 when g => 4,
            _ => 5,
        };
    }
}");
    }
 
    [Fact]
    public void SwitchExpression04()
    {
        TestSpan(
@"class C
{
    void Goo()
    {
        _ = e switch
        {
            1 [|when f|] $$=> 2,
            3 when g => 4,
            _ => 5,
        };
    }
}");
    }
 
    [Fact]
    public void SwitchExpression05()
    {
        TestSpan(
@"class C
{
    void Goo()
    {
        _ = e switch
        {
            1 when f =$$> [|2|],
            3 when g => 4,
            _ => 5,
        };
    }
}");
    }
 
    [Fact]
    public void SwitchExpression06()
    {
        TestSpan(
@"class C
{
    void Goo()
    {
        _ = e switch
        {
            1 when f => [|2|],$$
            3 when g => 4,
            _ => 5,
        };
    }
}");
    }
 
    [Fact]
    public void SwitchExpression07()
    {
        TestSpan(
@"class C
{
    void Goo()
    {
        _ = e switch
        {
            1 when f => 2,
$$            3 [|when g|] => 4,
            _ => 5,
        };
    }
}");
    }
 
    [Fact]
    public void SwitchExpression08()
    {
        TestSpan(
@"class C
{
    void Goo()
    {
        _ = e switch
        {
            1 when f => 2,
            3 when g => [|4|],$$
            _ => 5,
        };
    }
}");
    }
 
    [Fact]
    public void SwitchExpression09()
    {
        TestSpan(
@"class C
{
    void Goo()
    {
        _ = e switch
        {
            1 when f => 2,
            3 when g => 4,
$$            _ => [|5|],
        };
    }
}");
    }
 
    [Fact]
    public void SwitchExpression10()
    {
        TestSpan(
@"class C
{
    void Goo()
    {
        _ = e switch
        {
            1 when f => 2,
            3 when g => 4,
            _ => [|5|],$$
        };
    }
}");
    }
 
    [Fact]
    public void SwitchExpression11()
    {
        TestSpan(
@"class C
{
    void Goo()
    {
        _ = e switch
        {
            1 when f => 2,
            3 when g => 4,
            _ => [|5|],
        $$};
    }
}");
    }
 
    [Fact]
    public void SwitchExpression12()
    {
        TestSpan(
@"class C
{
    void Goo()
    {
        [|_ = e switch
        {
            1 when f => 2,
            3 when g => 4,
            _ => 5,
        }$$;|]
    }
}");
    }
 
    #endregion
 
    #region For and ForEach
 
    [Fact]
    public void ForStatementInitializer1a()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
$$    for ([|i = 0|], j = 0; i < 10 && j < 10; i++, j++)
    {
    }
  }
}");
    }
 
    [Fact]
    public void ForStatementInitializer1b()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    f$$or ([|i = 0|], j = 0; i < 10 && j < 10; i++, j++)
    {
    }
  }
}");
    }
 
    [Fact]
    public void ForStatementInitializer1c()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    for ([|i $$= 0|], j = 0; i < 10 && j < 10; i++, j++)
    {
    }
  }
}");
    }
 
    [Fact]
    public void ForStatementInitializer1d()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    for 
$$    (          
[|i = 0|], j = 0; i < 10 && j < 10; i++, j++)
    {
    }
  }
}");
    }
 
    [Fact]
    public void ForStatementInitializer2()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    for (i = 0, [|$$j = 0|]; i < 10 && j < 10; i++, j++)
    {
    }
  }
}");
    }
 
    [Fact]
    public void ForStatementInitializer3()
        => TestSpan("class C { void M() { for([|i = 0$$|]; ; }; }");
 
    [Fact]
    public void ForStatementCondition()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    for (i = 0, j = 0; [|i < 10 && j < $$10|]; i++, j++)
    {
    }
  }
}");
    }
 
    [Fact]
    public void ForStatementIncrementor1()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    for (i = 0, j = 0; i < 10 && j < 10; [|i+$$+|], j++)
    {
    }
  }
}");
    }
 
    [Fact]
    public void ForStatementIncrementor2()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    for (i = 0, j = 0; i < 10 && j < 10; i++, [|$$j++|])
    {
    }
  }
}");
    }
 
    [Fact]
    public void ForEachStatementExpression()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    foreach (var v in [|Goo().B$$ar()|])
    {
    }
  }
}");
    }
 
    [Fact]
    public void ForEachDeconstructionStatementExpression()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    foreach (var (x, y) in [|Goo().B$$ar()|])
    {
    }
  }
}");
    }
 
    #endregion
 
    #region Lambdas
 
    [Fact]
    public void SimpleLambdaBody()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    Func<string> f = s => [|G$$oo()|];
  }
}");
    }
 
    [Fact]
    public void ParenthesizedLambdaBody()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    Func<string> f = (s, i) => [|G$$oo()|];
  }
}");
    }
 
    [Fact]
    public void AnonymousMethod1()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    Func<int> f = delegate [|$${|] return 1; };
  }
}");
    }
 
    [Fact]
    public void AnonymousMethod2()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    Func<int> f = delegate { [|$$return 1;|] };
  }
}");
    }
 
    #endregion
 
    #region Queries
 
    [Fact]
    public void FirstFromClauseExpression()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    [|var q = from x in bl$$ah()
            from y in quux().z()
            select y;|]
  }
}");
    }
 
    [Fact]
    public void SecondFromClauseExpression()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    var q = from x in blah()
            from y in [|quux().z$$()|]
            select y;
  }
}");
    }
 
    [Fact]
    public void FromInQueryContinuation1()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    var q = from x in blah()
            from y in quux().z()
            group x by y into g
                from m in [|g.C$$ount()|]
                select m.Blah();
  }
}");
    }
 
    [Fact]
    public void FromInQueryContinuation2()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    var q = from x in blah()
            from y in quux().z()
            group x by y into g
     $$          from m in [|g.Count()|]
                select m.Blah();
  }
}");
    }
 
    [Fact]
    public void JoinClauseLeftExpression()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    var q = from x in blah()
            join a in alpha on [|left().exp$$r()|] equals right().expr()
            select y;
  }
}");
    }
 
    [Fact]
    public void JoinClauseRightExpression()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    var q = from x in blah()
            join a in alpha on left().expr() equals [|righ$$t().expr()|]
            select y;
  }
}");
    }
 
    [Fact]
    public void LetClauseExpression()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    var q = from x in blah()
            join a in alpha on left().expr() equals right.expr()
            let a = [|expr().$$expr()|]
            select y;
  }
}");
    }
 
    [Fact]
    public void WhereClauseExpression()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    var q = from x in blah()
            join a in alpha on left().expr() equals right.expr()
            where [|expr().$$expr()|]
            select y;
  }
}");
    }
 
    [Fact]
    public void WhereClauseKeyword()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    var q = from x in blah()
            whe$$re [|expr().expr()|]
            select y;
  }
}");
    }
 
    [Fact]
    public void SimpleOrdering1()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    var q = from x in blah()
            join a in alpha on left().expr() equals right.expr()
            orderby [|expr().$$expr()|]
            select y;
  }
}");
    }
 
    [Fact]
    public void SimpleOrdering2()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    var q = from x in blah()
            join a in alpha on left().expr() equals right.expr()
            orderby goo, [|expr().$$expr()|]
            select y;
  }
}");
    }
 
    [Fact]
    public void AscendingOrdering1()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    var q = from x in blah()
            join a in alpha on left().expr() equals right.expr()
            orderby [|expr().$$expr()|] ascending
            select y;
  }
}");
    }
 
    [Fact]
    public void AscendingOrdering2()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    var q = from x in blah()
            join a in alpha on left().expr() equals right.expr()
            orderby goo, [|expr().$$expr()|] ascending
            select y;
  }
}");
    }
 
    [Fact]
    public void DescendingOrdering1()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    var q = from x in blah()
            join a in alpha on left().expr() equals right.expr()
            orderby [|expr().$$expr()|] descending
            select y;
  }
}");
    }
 
    [Fact]
    public void DescendingOrdering2()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    var q = from x in blah()
            join a in alpha on left().expr() equals right.expr()
            orderby goo, [|expr().$$expr()|] descending
            select y;
  }
}");
    }
 
    [Fact]
    public void OrderByKeyword()
        => TestSpan("class C { void M() { from string s in null ord$$erby [|s.A|] ascending } }");
 
    [Fact]
    public void AscendingKeyword()
        => TestSpan("class C { void M() { from string s in null orderby [|s.A|] $$ascending } }");
 
    [Fact]
    public void SelectExpression()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    var q = from x in blah()
            join a in alpha on left().expr() equals right.expr()
            orderby goo, expr().expr() descending
            select [|y.$$blah()|];
  }
}");
    }
 
    [Fact]
    public void AnonymousTypeAfterSelect()
    {
        TestSpan(
@"class C
{
    public void ()
    {
        var q =
            from c in categories
            join p in products on c equals p.Category into ps
            select [|new { Category = c, $$Products = ps }|];
    }
}");
    }
 
    [Fact]
    public void GroupExpression()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    var q = from x in blah()
            join a in alpha on left().expr() equals right.expr()
            orderby goo, expr().expr() descending
            group [|bar()$$.goo()|] by blah().zap()
            select y.blah();
  }
}");
    }
 
    [Fact]
    public void GroupByKeyword()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    var q = from x in blah()
            join a in alpha on left().expr() equals right.expr()
            orderby goo, expr().expr() descending
            group [|bar().goo()|] b$$y blah().zap()
            select y.blah();
  }
}");
    }
 
    [Fact]
    public void GroupByExpression()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    var q = from x in blah()
            join a in alpha on left().expr() equals right.expr()
            orderby goo, expr().expr() descending
            group bar().goo() by [|blah()$$.zap()|]
            select y.blah();
  }
}");
    }
 
    [Fact]
    public void InFrontOfFirstFromClause()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    [|var q =
    $$   from x in blah()
        from y in zap()
        let m = quux()
        join a in alpha on left().expr() equals right.expr()
        orderby goo, expr().expr() descending
        group bar().goo() by blah().zap() into g
        select y.blah();|]
  }
}");
    }
 
    [Fact]
    public void InFrontOfSecondFromClause()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    var q =
        from x in blah()
    $$   from y in [|zap()|]
        let m = quux()
        join a in alpha on left().expr() equals right.expr()
        orderby goo, expr().expr() descending
        group bar().goo() by blah().zap() into g
        select y.blah();
  }
}");
    }
 
    [Fact]
    public void InFrontOfLetClause()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    var q =
        from x in blah()
        from y in zap()
    $$   let m = [|quux()|]
        join a in alpha on left().expr() equals right.expr()
        orderby goo, expr().expr() descending
        group bar().goo() by blah().zap() into g
        select y.blah();
  }
}");
    }
 
    [Fact]
    public void InFrontOfJoinClause()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    var q =
        from x in blah()
        from y in zap()
        let m = quux()
    $$   join a in alpha on [|left().expr()|] equals right.expr()
        orderby goo, expr().expr() descending
        group bar().goo() by blah().zap() into g
        select y.blah();
  }
}");
    }
 
    [Fact]
    public void InFrontOfOrderByClause()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    var q =
        from x in blah()
        from y in zap()
        let m = quux()
        join a in alpha on left().expr() equals right.expr()
    $$   orderby [|goo|], expr().expr() descending
        group bar().goo() by blah().zap() into g
        select y.blah();
  }
}");
    }
 
    [Fact]
    public void InFrontOfGroupByClause()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    var q =
        from x in blah()
        from y in zap()
        let m = quux()
        join a in alpha on left().expr() equals right.expr()
        orderby goo, expr().expr() descending
    $$   group [|bar().goo()|] by blah().zap() into g
        select y.blah();
  }");
    }
 
    [Fact]
    public void InFrontOfSelectClause()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    var q =
        from x in blah()
        from y in zap()
        let m = quux()
        join a in alpha on left().expr() equals right.expr()
        orderby goo, expr().expr() descending
        group bar().goo() by blah().zap() into g
    $$   select [|y.blah()|];
  }");
    }
 
    [Fact]
    public void Select1()
    {
        TestSpan(
@"class C
{
  IEnumerable<int> Goo() => from x in new[] { 1 } select [|$$x|];
}
");
    }
 
    [Fact]
    public void Select_NoLambda1()
    {
        TestSpan(
@"class C
{
  IEnumerable<int> Goo() => [|from x in new[] { 1 } where x > 0 select $$x|];
}
");
    }
 
    [Fact]
    public void Select_NoLambda2()
    {
        TestSpan(
@"class C
{
  IEnumerable<int> Goo() => [|from x in new[] { 1 } select x into y orderby y select $$y|];
}
");
    }
 
    [Fact]
    public void GroupBy1()
    {
        TestSpan(
@"class C
{
  IEnumerable<int> Goo() => from x in new[] { 1 } group x by [|$$x|];
}
");
    }
 
    [Fact]
    public void GroupBy_NoLambda1()
    {
        TestSpan(
@"class C
{
  IEnumerable<int> Goo() => [|from x in new[] { 1 } group $$x by x|];
}
");
    }
 
    [Fact]
    public void GroupBy_NoLambda2()
    {
        TestSpan(
@"class C
{
  IEnumerable<int> Goo() => [|from x in new[] { 1 } group $$x by x + 1 into y group y by y.Key + 2|];
}
");
    }
 
    [Fact]
    public void GroupBy_NoLambda3()
    {
        TestSpan(
@"class C
{
  IEnumerable<int> Goo() => [|from x in new[] { 1 } group x by x + 1 into y group $$y by y.Key + 2|];
}
");
    }
 
    #endregion
 
    #region Field and Variable Declarators
 
    [Fact]
    public void FieldDeclarator_WithoutInitializer_All()
    {
        VerifyAllSpansInDeclaration<VariableDeclaratorSyntax>(
@"class C
{
    int $$i, j;
}");
    }
 
    [Fact]
    public void FieldDeclarator_WithoutInitializer1()
    {
        TestMissing(
@"class C
{
    int $$i;
}");
    }
 
    [Fact]
    public void FieldDeclarator_WithoutInitializer2()
    {
        TestMissing(
@"class C
{
    pri$$vate int i;
}");
    }
 
    [Fact]
    public void FieldDeclarator_SingleVariable_Initializer_All1()
    {
        VerifyAllSpansInDeclaration<VariableDeclaratorSyntax>(
@"class C
{
    [Goo]
    private int $$i;
}");
    }
 
    [Fact]
    public void FieldDeclarator_SingleVariable_Initializer_All2()
    {
        VerifyAllSpansInDeclaration<VariableDeclaratorSyntax>(
@"class C
{
    [Goo]
    [|int $$i = 0;|]
}");
    }
    [Fact]
    public void FieldDeclarator_SingleVariable_Initializer_All3()
    {
        VerifyAllSpansInDeclaration<VariableDeclaratorSyntax>(
@"class C
{
    [Goo]
    [|private int $$i = 0;|]
}");
    }
 
    [Fact]
    public void FieldDeclarator_MultiVariable_Initializer_All1()
    {
        VerifyAllSpansInDeclaration<VariableDeclaratorSyntax>(
@"class C
{
    [Goo]
    [|private int $$i = 0|], j = 2;
}");
    }
 
    [Fact]
    public void FieldDeclarator_MultiVariable_Initializer_All2()
    {
        VerifyAllSpansInDeclaration<VariableDeclaratorSyntax>(
@"class C
{
    [Goo]
    [|int $$i = 0|], j = 2;
}");
    }
 
    [Fact]
    public void FieldDeclarator_MultiVariable_Initializer_All3()
    {
        VerifyAllSpansInDeclaration<VariableDeclaratorSyntax>(
@"class C
{
    [Goo]
    private int i = 0, [|$$j = 0|];
}");
    }
 
    [Fact]
    public void FieldDeclarator_Initializer1()
    {
        TestSpan(
@"class C
{
    [|int $$i = 1;|]
}");
    }
 
    [Fact]
    public void FieldDeclarator_Initializer2()
    {
        TestSpan(
@"class C
{
    [|private int $$i = 1;|]
}");
    }
 
    [Fact]
    public void FieldDeclarator_Initializer3()
    {
        TestSpan(
@"class C
{
    [Goo]
    [|private int $$i = 0;|]
}");
    }
 
    [Fact]
    public void FieldDeclarator_Initializer4()
    {
        TestSpan(
@"class C
{
    [|pri$$vate int i = 1;|]
}");
    }
 
    [Fact]
    public void FieldDeclarator_Initializer5()
    {
        TestSpan(
@"class C
{
$$    [|private int i = 3;|]
}");
    }
 
    [Fact]
    public void ConstVariableDeclarator0()
        => TestMissing("class C { void Goo() { const int a = $$1; } }");
 
    [Fact]
    public void ConstVariableDeclarator1()
        => TestMissing("class C { void Goo() { const $$int a = 1; } }");
 
    [Fact]
    public void ConstVariableDeclarator2()
        => TestMissing("class C { void Goo() { $$const int a = 1; } }");
 
    [Fact]
    public void ConstFieldVariableDeclarator_All()
    {
        VerifyAllSpansInDeclaration<VariableDeclaratorSyntax>(
@"class C
{
    [Goo]
    private const int i = 0, j, $$k = 0;
}");
    }
 
    [Fact]
    public void ConstFieldVariableDeclarator0()
        => TestMissing("class C { const int a = $$1; }");
 
    [Fact]
    public void ConstFieldVariableDeclarator1()
        => TestMissing("class C { const $$int a = 1; }");
 
    [Fact]
    public void ConstFieldVariableDeclarator2()
        => TestMissing("class C { $$const int a = 1; }");
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/538777")]
    public void VariableDeclarator0()
        => TestMissing("class C { void Goo() { int$$ } }");
 
    [Fact]
    public void VariableDeclarator1()
    {
        TestMissing(
@"class C
{
  void Goo()
  {
    int $$i;
  }
}");
    }
 
    [Fact]
    public void VariableDeclarator2a()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    [|int $$i = 0;|]
  }
}");
    }
 
    [Fact]
    public void VariableDeclarator2b()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
  $$  [|int i = 0;|]
  }
}");
    }
 
    [Fact]
    public void VariableDeclarator2c()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    [|$$int i = 0;|]
  }
}");
    }
 
    [Fact]
    public void VariableDeclarator3a()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    int i = 0, [|$$j = 3|];
  }
}");
    }
 
    [Fact]
    public void VariableDeclarator3b()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    [|int i = 0|], $$j;
  }
}");
    }
 
    [Fact]
    public void VariableDeclarator3c()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    int $$i, [|j = 0|];
  }
}");
    }
 
    [Fact]
    public void VariableDeclarator4()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    int i = 0, [|j = $$1|];
  }
}");
    }
 
    [Fact]
    public void VariableDeclarator5()
    {
        TestSpan(
@"class C
{
  [|int $$i = 0;|]
}");
    }
 
    [Fact]
    public void VariableDeclarator6()
    {
        TestSpan(
@"class C
{
  [|int i = 0|], $$j;
}");
    }
 
    [Fact]
    public void VariableDeclarator7()
    {
        TestSpan(
@"class C
{
  private int i = 0, [|j = $$1|];
}");
    }
 
    [Fact]
    public void VariableDeclarator8()
    {
        TestSpan(
@"class C
{
  [|priv$$ate int i = 0|], j = 1;
}");
    }
 
    [Fact]
    public void VariableDeclarator9()
    {
        TestSpan(
@"class C
{
$$  [|private int i = 0|], j = 1;
}");
    }
 
    [Fact]
    public void VariableDeclarator10()
        => TestSpan("class C { void M() { [|int i = 0$$;|] } }");
 
    [Fact]
    public void VariableDeclarator_Separators0()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
$$    [|int i = 0|], j = 1, k = 2;
  }
}");
    }
 
    [Fact]
    public void VariableDeclarator_Separators1()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    [|int i = 0|]$$, j = 1, k = 2;
  }
}");
    }
 
    [Fact]
    public void VariableDeclarator_Separators2()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    int i = 0, [|j = 1|]$$, k = 2;
  }
}");
    }
 
    [Fact]
    public void VariableDeclarator_Separators3()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    int i = 0, j = 1,$$ [|k = 2|];
  }
}");
    }
 
    [Fact]
    public void VariableDeclarator_Separators4()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    int i = 0, j = 1, [|k = 2|]$$;
  }
}");
    }
 
    [Fact]
    public void VariableDeclarator_Separators5()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    [|int i = 0|], j = 1, k = 2;$$
  }
}");
    }
 
    [Fact]
    public void VariableDeclarator_Separators6()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    int i = 1, j, $$k, [|l = 2|];
  }
}");
    }
 
    [Fact]
    public void VariableDeclarator_Separators7()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    int i$$, j, k, [|l = 2|];
  }
}");
    }
 
    [Fact]
    public void VariableDeclarator_Separators8()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    [|int i = 2|], j, k, l$$;
  }
}");
    }
 
    [Fact]
    public void VariableDeclarator_Separators9()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    int i, j, [|k = 1|], m, l = 2;$$
  }
}");
    }
 
    [Fact]
    public void EventFieldDeclarator1()
    {
        TestSpan(
@"class C
{
$$    [|public event EventHandler MyEvent = delegate { };|]
}");
    }
 
    [Fact]
    public void EventFieldDeclarator2()
    {
        TestSpan(
@"class C
{
    [|pub$$lic event EventHandler MyEvent = delegate { };|]
}");
    }
 
    [Fact]
    public void EventFieldDeclarator3()
    {
        TestSpan(
@"class C
{
    [|public ev$$ent EventHandler MyEvent = delegate { };|]
}");
    }
 
    [Fact]
    public void EventFieldDeclarator4()
    {
        TestSpan(
@"class C
{
    [|public event EventHan$$dler MyEvent = delegate { };|]
}");
    }
 
    [Fact]
    public void EventFieldDeclarator5()
    {
        TestSpan(
@"class C
{
    [|public event EventHandler MyE$$vent = delegate { };|]
}");
    }
 
    [Fact]
    public void EventFieldDeclarator6()
    {
        TestSpan(
@"class C
{
    [|public event EventHandler MyEvent $$= delegate { };|]
}");
    }
 
    [Fact]
    public void EventFieldDeclarator7()
    {
        TestSpan(
@"class C
{
    [|public event EventHandler MyEvent = del$$egate { };|]
}");
    }
 
    [Fact]
    public void EventFieldDeclarator8()
    {
        TestSpan(
@"class C
{
    public event EventHandler MyEvent = delegate [|{|] $$ };
}");
    }
 
    #endregion
 
    [Fact]
    public void EventAccessorAdd()
        => TestSpan("class C { eve$$nt Action Goo { add [|{|] } remove { } } }");
 
    [Fact]
    public void EventAccessorAdd2()
        => TestSpan("class C { event Action Goo { ad$$d [|{|] } remove { } } }");
 
    [Fact]
    public void EventAccessorRemove()
        => TestSpan("class C { event Action Goo { add { } $$remove [|{|] } } }");
 
    [Fact]
    public void ElseClauseWithBlock()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    if (bar)
    {
    }
    el$$se
    [|{|]
    }
  }
}");
    }
 
    [Fact]
    public void ElseClauseWithStatement()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    if (bar)
    {
    }
    el$$se
      [|Goo();|]
  }
}");
    }
 
    [Fact]
    public void ElseIf()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    if (bar)
    {
    }
    el$$se [|if (baz)|]
      Goo();
  }
}");
    }
 
    [Fact]
    public void EmptyCatch()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    try
    {
    }
    [|cat$$ch|]
    {
    }
  }
}");
    }
 
    [Fact]
    public void CatchWithType()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    try
    {
    }
    [|cat$$ch(Exception)|]
    {
    }
  }
}");
    }
 
    [Fact]
    public void CatchWithTypeInType()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    try
    {
    }
    [|catch(Exce$$ption)|]
    {
    }
  }
}");
    }
 
    [Fact]
    public void CatchWithTypeAndNameInType()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    try
    {
    }
    [|catch(Exce$$ption e)|]
    {
    }
  }
}");
    }
 
    [Fact]
    public void CatchWithTypeAndNameInName()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    try
    {
    }
    [|catch(Exception $$e)|]
    {
    }
  }
}");
    }
 
    [Fact]
    public void Filter1()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    try
    {
    }
    $$catch(Exception e) [|when (e.Message != null)|]
    {
    }
  }
}");
    }
 
    [Fact]
    public void Filter3()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    try
    {
    }
    catch(Exception e)$$ [|when (e.Message != null)|]
    {
    }
  }
}");
    }
 
    [Fact]
    public void Filter4()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    try
    {
    }
    catch(Exception e) [|when$$ (e.Message != null)|]
    {
    }
  }
}");
    }
 
    [Fact]
    public void Filter5()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    try
    {
    }
    catch(Exception e) [|when (e.Message != null)|]      $$
    {
    }
  }
}");
    }
 
    [Fact]
    public void SimpleFinally()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    try
    {
    }
    final$$ly
    [|{|]
    }
  }
}");
    }
 
    [Fact]
    public void FinallyWithCatch()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    try
    {
    }
    catch
    {
    }
    final$$ly
    [|{|]
    }
  }
}");
    }
 
    [Fact]
    public void SwitchLabelWithBlock()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    switch (goo)
    {
        case $$1:
            [|{|]
            }
    }
  }
}");
    }
 
    [Fact]
    public void SwitchLabelWithStatement()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    switch (goo)
    {
        cas$$e 1:
            [|goo();|]
    }
  }
}");
    }
 
    [Fact]
    public void SwitchLabelWithStatement2()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    switch (goo)
    {
        cas$$e 1:
            [|goo();|]
            bar();
    }
  }
}");
    }
 
    [Fact]
    public void SwitchLabelWithoutStatement()
        => TestSpan("class C { void M() { [|switch |]{ case 1$$: } } }");
 
    [Fact]
    public void MultipleLabelsOnFirstLabel()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    switch (goo)
    {
        cas$$e 1:
        case 2:
            [|goo();|]
 
        case 3:
        default:
            bar();
    }
  }
}");
    }
 
    [Fact]
    public void MultipleLabelsOnSecondLabel()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    switch (goo)
    {
        case 1:
        cas$$e 2:
            [|goo();|]
 
        case 3:
        default:
            bar();
    }
  }
}");
    }
 
    [Fact]
    public void MultipleLabelsOnLabelWithDefault()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    switch (goo)
    {
        case 1:
        case 2:
            goo();
 
        cas$$e 3:
        default:
            [|bar();|]
    }
  }
}");
    }
 
    [Fact]
    public void MultipleLabelsOnDefault()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    switch (goo)
    {
        case 1:
        case 2:
            goo();
 
        case 3:
        default:$$
            [|bar();|]
    }
  }
}");
    }
 
    [Fact]
    public void BlockBeforeStartToken()
    {
        TestSpan(
@"class C
{
  void Goo()
  [|$${|]
    
  }
}");
    }
 
    [Fact]
    public void BlockBeforeStartToken2()
    {
        TestSpan(
@"class C
{
  void Goo()
  $$ [|{|]
    
  }
}");
    }
 
    [Fact]
    public void BlockAfterStartToken()
    {
        TestSpan(
@"class C
{
  void Goo()
  [|{$$|]
    
  }
}");
    }
 
    [Fact]
    public void BlockAfterStartToken2()
    {
        TestSpan(
@"class C
{
  void Goo()
  [|{|] $$
    
  }
}");
    }
 
    [Fact]
    public void BlockBeforeEndToken1()
    {
        TestSpan(
@"class C
{
  void Goo()
  { 
  $$[|}|]
}");
    }
 
    [Fact]
    public void BlockBeforeEndToken2()
    {
        TestSpan(
@"class C
{
  void Goo()
  { 
  $$ [|}|]
}");
    }
 
    [Fact]
    public void BlockAfterEndToken1()
    {
        TestSpan(
@"class C
{
  void Goo()
  { 
  [|}|]$$
}");
    }
 
    [Fact]
    public void BlockAfterEndToken2()
    {
        TestSpan(
@"class C
{
  void Goo()
  { 
  [|}|] $$
}");
    }
 
    [Fact]
    public void SingleDeclarationOnType()
    {
        TestMissing(
@"class C
{
  void Goo()
  {
    i$$nt i;
  }
}");
    }
 
    [Fact]
    public void MultipleDeclarationsOnType()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    [|i$$nt i = 0|], j = 1;
  }
}");
    }
 
    [Fact]
    public void Label()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    go$$o:
        [|bar();|]
  }
}");
    }
 
    [Fact]
    public void WhileInWhile()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    [|w$$hile (expr)|]
    {
    }
  }
}");
    }
 
    [Fact]
    public void WhileInExpr()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    [|while (ex$$pr)|]
    {
    }
  }
}");
    }
 
    [Fact]
    public void OnWhileBlock()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    while (expr)
  $$ [|{|]
    }
  }
}");
    }
 
    [Fact]
    public void OnDoKeyword()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    d$$o
    [|{|]
    }
    while(expr);
  }
}");
    }
 
    [Fact]
    public void OnDoBlock()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    do
  $$ [|{|]
    }
    while(expr);
  }
}");
    }
 
    [Fact]
    public void OnDoWhile()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    do
    {
    }
    [|wh$$ile(expr);|]
  }
}");
    }
 
    [Fact]
    public void OnDoWhile_MissingSemicolon()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    do
    {
    }
    [|wh$$ile(expr)|]
  }
}");
    }
 
    [Fact]
    public void OnDoExpression()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    do
    {
    }
    [|while(ex$$pr);|]
  }
}");
    }
 
    [Fact]
    public void OnForWithDeclaration1()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    f$$or ([|int i = 0|], j = 1; i < 10 && j < 10; i++, j++)
    {
    }
  }
}");
    }
 
    [Fact]
    public void OnForWithDeclaration2()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    f$$or ([|int i = 0|]; i < 10 && j < 10; i++, j++)
    {
    }
  }
}");
    }
 
    [Fact]
    public void OnForWithCondition()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    f$$or (; [|i < 10 && j < 10|]; i++, j++)
    {
    }
  }
}");
    }
 
    [Fact]
    public void OnForWithIncrementor1()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    f$$or (; ; [|i++|], j++)
    {
    }
  }
}");
    }
 
    [Fact]
    public void OnForWithIncrementor2()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    f$$or (; ; [|i++|])
    {
    }
  }
}");
    }
 
    [Fact]
    public void OnEmptyFor()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    f$$or (; ; )
    [|{|]
    }
  }
}");
    }
 
    [Fact]
    public void OnForEachKeyword1()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
$$    [|foreach|] (var v in expr().blah())
    {
    }
  }
}");
    }
 
    [Fact]
    public void OnForEachKeyword2()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    [|fo$$reach|] (var v in expr().blah())
    {
    }
  }
}");
    }
 
    [Fact]
    public void OnForEachKeyword3()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    [|foreach|]    $$    
(var v in expr().blah())
    {
    }
  }
}");
    }
 
    [Fact]
    public void OnForEachKeyword4()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    [|foreach|]        
$$         (var v in expr().blah())
    {
    }
  }
}");
    }
 
    [Fact]
    public void OnForEachKeyword5()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    [|foreach|] $$(var v in expr().blah())
    {
    }
  }
}");
    }
 
    [Fact]
    public void OnForEachType1()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    foreach (   $$   
[|var v|] in expr().blah())
    {
    }
  }
}");
    }
 
    [Fact]
    public void OnForEachType2()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    foreach ([|v$$ar v|] in expr().blah())
    {
    }
  }
}");
    }
 
    [Fact]
    public void OnForEachIdentifier()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    foreach ([|var v$$v|] in expr().blah())
    {
    }
  }
}");
    }
 
    [Fact]
    public void OnForEachIn1()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    foreach (var v [|i$$n|] expr().blah())
    {
    }
  }
}");
    }
 
    [Fact]
    public void OnForEachIn2()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    foreach (var v 
$$         [|in|] expr().blah())
    {
    }
  }
}");
    }
 
    [Fact]
    public void OnForEachIn3()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    foreach (var v 
         [|in|] $$
expr().blah())
    {
    }
  }
}");
    }
 
    [Fact]
    public void OnForEachExpr1()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    foreach (var v in [|expr($$).blah()|])
    {
    }
  }
}");
    }
 
    [Fact]
    public void OnForEachExpr2()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    foreach (var v in [|expr().blah()|]   
     $$    )
    {
    }
  }
}");
    }
 
    [Fact]
    public void OnForEachExpr3()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    foreach (var v in 
   $$ [|expr().blah()|]   
     )
    {
    }
  }
}");
    }
 
    [Fact]
    public void OnForEachStatement()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    [|foreach|](var v in expr().blah())    $$ 
    {
    }
  }
}");
    }
 
    [Fact]
    public void OnForEachBlock1()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    foreach (var v in expr().blah())
  $$ [|{|]
    }
  }
}");
    }
 
    [Fact]
    public void OnForEachDeconstructionKeyword1()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
$$    [|foreach|] (var (x, y) in expr().blah())
    {
    }
  }
}");
    }
 
    [Fact]
    public void OnForEachDeconstructionKeyword2()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    [|fo$$reach|] (var (x, y) in expr().blah())
    {
    }
  }
}");
    }
 
    [Fact]
    public void OnForEachDeconstructionKeyword3()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    [|foreach|]    $$    
(var (x, y) in expr().blah())
    {
    }
  }
}");
    }
 
    [Fact]
    public void OnForEachDeconstructionKeyword4()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    [|foreach|]        
$$         (var (x, y) in expr().blah())
    {
    }
  }
}");
    }
 
    [Fact]
    public void OnForEachDeconstructionKeyword5()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    [|foreach|] $$(var (x, y) in expr().blah())
    {
    }
  }
}");
    }
 
    [Fact]
    public void OnForEachDeconstructionType1()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    foreach (   $$   
[|var (x, y)|] in expr().blah())
    {
    }
  }
}");
    }
 
    [Fact]
    public void OnForEachDeconstructionType2()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    foreach ([|v$$ar (x, y)|] in expr().blah())
    {
    }
  }
}");
    }
 
    [Fact]
    public void OnForEachDeconstructionIdentifier()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    foreach ([|var (v$$v, y)|] in expr().blah())
    {
    }
  }
}");
    }
 
    [Fact]
    public void OnForEachDeconstructionIn1()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    foreach (var (x, y) [|i$$n|] expr().blah())
    {
    }
  }
}");
    }
 
    [Fact]
    public void OnForEachDeconstructionIn2()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    foreach (var (x, y) 
$$         [|in|] expr().blah())
    {
    }
  }
}");
    }
 
    [Fact]
    public void OnForEachDeconstructionIn3()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    foreach (var (x, y) 
         [|in|] $$
expr().blah())
    {
    }
  }
}");
    }
 
    [Fact]
    public void OnForEachDeconstructionExpr1()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    foreach (var (x, y) in [|expr($$).blah()|])
    {
    }
  }
}");
    }
 
    [Fact]
    public void OnForEachDeconstructionExpr2()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    foreach (var (x, y) in [|expr().blah()|]   
     $$    )
    {
    }
  }
}");
    }
 
    [Fact]
    public void OnForEachDeconstructionExpr3()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    foreach (var (x, y) in 
   $$ [|expr().blah()|]   
     )
    {
    }
  }
}");
    }
 
    [Fact]
    public void OnForEachDeconstructionStatement()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    [|foreach|](var (x, y) in expr().blah())    $$ 
    {
    }
  }
}");
    }
 
    [Fact]
    public void OnForEachDeconstructionBlock1()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    foreach (var (x, y) in expr().blah())
  $$ [|{|]
    }
  }
}");
    }
 
    [Fact]
    public void OnUsingWithDecl1()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    us$$ing ([|var v = goo()|])
    {
    }
  }
}");
    }
 
    [Fact]
    public void OnUsingWithDecl2()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    us$$ing ([|var v = goo()|], x = bar())
    {
    }
  }
}");
    }
 
    [Fact]
    public void OnUsingWithDeclType()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    using ([|v$$ar v = goo()|])
    {
    }
  }
}");
    }
 
    [Fact]
    public void OnUsingWithDeclIdentifier1()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    using ([|var v$$v = goo()|])
    {
    }
  }
}");
    }
 
    [Fact]
    public void OnUsingWithDeclIdentifier2()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    using ([|var vv = goo()|])     $$
    {
    }
  }
}");
    }
 
    [Fact]
    public void OnUsingWithDeclIdentifier3()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
$$    using ([|var vv = goo()|])     
    {
    }
  }
}");
    }
 
    [Fact]
    public void OnUsingWithDeclExpression()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    using ([|var vv = go$$o()|])
    {
    }
  }
}");
    }
 
    [Fact]
    public void OnUsingWithExpression1()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    [|usi$$ng (goo().bar())|]
    {
    }
  }
}");
    }
 
    [Fact]
    public void OnUsingWithExpression2()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    [|using (goo$$().bar())|]
    {
    }
  }
}");
    }
 
    [Fact]
    public void OnFixed1()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    fi$$xed ([|int* i = &j|])
    {
    }
  }
}");
    }
 
    [Fact]
    public void OnFixed2()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    fi$$xed ([|int* i = &j|], k = &m)
    {
    }
  }
}");
    }
 
    [Fact]
    public void OnFixed3()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    fixed ([|i$$nt* i = &j|])
    {
    }
  }
}");
    }
 
    [Fact]
    public void OnFixed4()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    fixed ([|int* $$i = &j|])
    {
    }
  }
}");
    }
 
    [Fact]
    public void OnFixed5()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    fixed ([|int* i $$= &j|])
    {
    }
  }
}");
    }
 
    [Fact]
    public void OnFixed6()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    fixed ([|int* i = &$$j|])
    {
    }
  }
}");
    }
 
    [Fact]
    public void OnChecked1()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    che$$cked
    [|{|]
    }
  }
}");
    }
 
    [Fact]
    public void OnUnchecked1()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    unche$$cked
    [|{|]
    }
  }
}");
    }
 
    [Fact]
    public void OnUnsafe1()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    uns$$afe
    [|{|]
    }
  }
}");
    }
 
    [Fact]
    public void OnLock1()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    [|lo$$ck (expr)|]
    {
    }
  }
}");
    }
 
    [Fact]
    public void OnLock2()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    [|lock (ex$$pr)|]
    {
    }
  }
}");
    }
 
    [Fact]
    public void OnIf1()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    [|i$$f (goo().bar())|]
    {
    }
  }
}");
    }
 
    [Fact]
    public void OnIf2()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    [|if (go$$o().bar())|]
    {
    }
  }
}");
    }
 
    [Fact]
    public void OnIfBlock()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    if (goo().bar())
   $$ [|{|]
    }
  }
}");
    }
 
    [Fact]
    public void OnSwitch1()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    [|swi$$tch (expr)|]
    {
        default:
            goo();
    }
  }
}");
    }
 
    [Fact]
    public void OnSwitch2()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    [|switch (ex$$pr)|]
    {
        default:
            goo();
    }
  }
}");
    }
 
    [Fact]
    public void OnSwitch3()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    [|switch (expr)|]
  $$ {
        default:
            goo();
    }
  }
}");
    }
 
    [Fact]
    public void OnSwitch4()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    [|switch (expr)|]
    {
        default:
            goo();
  $$ }
  }
}");
    }
 
    [Fact]
    public void OnTry1()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    t$$ry
    [|{|]
    }
    finally
    {
    }
  }
}");
    }
 
    [Fact]
    public void OnTry2()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    try
  $$ [|{|]
    }
    finally
    {
    }
  }
}");
    }
 
    [Fact]
    public void OnGotoStatement1()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    [|g$$oto goo;|]
  }
}");
    }
 
    [Fact]
    public void OnGotoStatement2()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    [|goto go$$o;|]
  }
}");
    }
 
    [Fact]
    public void OnGotoCaseStatement1()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    switch (expr)
    {
        case 1:
            [|go$$to case 2;|]
    }
  }
}");
    }
 
    [Fact]
    public void OnGotoCaseStatement2()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    switch (expr)
    {
        case 1:
            [|goto ca$$se 2;|]
    }
  }
}");
    }
 
    [Fact]
    public void OnGotoCaseStatement3()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    switch (expr)
    {
        case 1:
            [|goto case $$2;|]
    }
  }
}");
    }
 
    [Fact]
    public void OnGotoDefault1()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    switch (expr)
    {
        case 1:
            [|go$$to default;|]
    }
  }
}");
    }
 
    [Fact]
    public void OnGotoDefault2()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    switch (expr)
    {
        case 1:
            [|goto defau$$lt;|]
    }
  }
}");
    }
 
    [Fact]
    public void OnBreak1()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    while (true)
    {
        [|bre$$ak;|]
    }
  }
}");
    }
 
    [Fact]
    public void OnContinue1()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    while (true)
    {
        [|cont$$inue;|]
    }
  }
}");
    }
 
    [Fact]
    public void OnReturn1()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    [|retu$$rn;|]
  }
}");
    }
 
    [Fact]
    public void OnReturn2()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    [|retu$$rn expr();|]
  }
}");
    }
 
    [Fact]
    public void OnReturn3()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    [|return expr$$().bar();|]
  }
}");
    }
 
    [Fact]
    public void OnYieldReturn1()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    [|yi$$eld return goo().bar();|]
  }
}");
    }
 
    [Fact]
    public void OnYieldReturn2()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    [|yield re$$turn goo().bar();|]
  }
}");
    }
 
    [Fact]
    public void OnYieldReturn3()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    [|yield return goo()$$.bar();|]
  }
}");
    }
 
    [Fact]
    public void OnYieldBreak1()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    [|yi$$eld break;|]
  }
}");
    }
 
    [Fact]
    public void OnYieldBreak2()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    [|yield brea$$k;|]
  }
}");
    }
 
    [Fact]
    public void OnThrow1()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    [|th$$row;|]
  }
}");
    }
 
    [Fact]
    public void OnThrow2()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    [|thr$$ow new Goo();|]
  }
}");
    }
 
    [Fact]
    public void OnThrow3()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    [|throw ne$$w Goo();|]
  }
}");
    }
 
    [Fact]
    public void OnThrow4()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    [|throw new Go$$o();|]
  }
}");
    }
 
    [Fact]
    public void OnExpressionStatement1()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    [|goo().$$bar();|]
  }
}");
    }
 
    [Fact]
    public void OnEmptyStatement1()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    [|$$;|]
  }
}");
    }
 
    [Fact]
    public void OnEmptyStatement2()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    while (true)
    {
   $$ [|;|]
    }
  }
}");
    }
 
    [Fact]
    public void OnPropertyAccessor1()
    {
        TestSpan(
@"class C
{
  int Goo
  {
    g$$et
    [|{|]
    }
  }
}");
    }
 
    [Fact]
    public void OnPropertyAccessor2()
    {
        TestSpan(
@"class C
{
  int Goo
  {
    [|g$$et;|]
  }
}");
    }
 
    [Fact]
    public void OnPropertyAccessor3()
    {
        TestSpan(
@"class C
{
  int Goo
  {
    get
    {
    }
 
    s$$et
    [|{|]
    }
  }
}");
    }
 
    [Fact]
    public void OnPropertyAccessor4()
    {
        TestSpan(
@"class C
{
  int Goo
  {
    [|s$$et;|]
  }
}");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/48504")]
    public void OnPropertyAccessor5()
    {
        TestSpan(
@"class C
{
  int Goo
  {
    [|in$$it;|]
  }
}");
    }
 
    [Fact]
    public void OnProperty1()
    {
        TestSpan(
@"class C
{
  int G$$oo
  {
    get
    [|{|]
    }
    
    set
    {
    }
  }
}");
    }
 
    [Fact]
    public void OnProperty2()
    {
        TestSpan(
@"class C
{
  int G$$oo
  {
    [|get;|]
    set {} 
  }
}");
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/932711")]
    public void OnPropertyWithInitializer()
    {
        TestSpan(
@"class C
{
    public int Id { get; set; } = [|int.Pa$$rse(""42"")|];
}");
 
        TestSpan(
@"class C
{
    public int$$ Id { [|get;|] set; } = int.Parse(""42"");
}");
 
        TestSpan(
@"class C
{
    public int Id { get; [|set;|] $$} = int.Parse(""42"");
}");
 
        TestSpan(
@"class C
{
    public int Id { get; [|set;|] }$$ = int.Parse(""42"");
}");
 
        TestSpan(
@"class C
{
    public int Id { get; set; } =$$ [|int.Parse(""42"")|];
}");
    }
 
    [Fact]
    public void OnPropertyExpressionBody1()
    {
        TestSpan(
@"class C
{
    public int Id => [|12$$3|];
}");
    }
 
    [Fact]
    public void OnPropertyExpressionBody2()
    {
        TestSpan(
@"class C
{
    public int Id $$=> [|123|];
}");
    }
 
    [Fact]
    public void OnPropertyExpressionBody3()
    {
        TestSpan(
@"class C
{
    $$public int Id => [|123|];
}");
    }
 
    [Fact]
    public void OnPropertyExpressionBody4()
    {
        TestSpan(
@"class C
{
    public int Id => [|123|];   $$
}");
    }
 
    [Fact]
    public void OnIndexerExpressionBody1()
    {
        TestSpan(
@"class C
{
    public int this[int a] => [|12$$3|];
}");
    }
 
    [Fact]
    public void OnIndexer1()
    {
        TestSpan(
@"class C
{
  int this[int$$ a]
  {
    get
    [|{|]
    }
    
    set
    {
    }
  }
}");
    }
 
    [Fact]
    public void OnIndexer2()
    {
        TestSpan(
@"class C
{
  int this[int$$ a]
  {
    [|get;|]
    set { }
  }
}");
    }
 
    [Fact]
    public void OnIndexerExpressionBody2()
    {
        TestSpan(
@"class C
{
    public int this[int a] $$=> [|123|];
}");
    }
 
    [Fact]
    public void OnIndexerExpressionBody3()
    {
        TestSpan(
@"class C
{
    $$public int this[int a] => [|123|];
}");
    }
 
    [Fact]
    public void OnIndexerExpressionBody4()
    {
        TestSpan(
@"class C
{
    public int this[int a] => [|123|];   $$
}");
    }
 
    [Fact]
    public void OnIndexerExpressionBody5()
    {
        TestSpan(
@"class C
{
    public int this[int $$a] => [|123|];   
}");
    }
 
    [Fact]
    public void OnMethod1()
    {
        TestSpan(
@"class C
{
    v$$oid Goo()
    [|{|]
    }
}");
    }
 
    [Fact]
    public void OnMethod2()
    {
        TestSpan(
@"class C
{
    void G$$oo()
    [|{|]
    }
}");
    }
 
    [Fact]
    public void OnMethod3()
    {
        TestSpan(
@"class C
{
    void Goo(in$$t i)
    [|{|]
    }
}");
    }
 
    [Fact]
    public void OnMethod4()
    {
        TestSpan(
@"class C
{
    void Goo(int $$i)
    [|{|]
    }
}");
    }
 
    [Fact]
    public void OnMethod5()
    {
        TestSpan(
@"class C
{
    void Goo(int i = g$$oo)
    [|{|]
    }
}");
    }
 
    [Fact]
    public void OnMethodWithExpressionBody1()
    {
        TestSpan(
@"class C
{
    v$$oid Goo() => [|123|];
}");
    }
 
    [Fact]
    public void OnMethodWithExpressionBody2()
    {
        TestSpan(
@"class C
{
    void Goo() =>$$ [|123|];
}");
    }
 
    [Fact]
    public void OnMethodWithExpressionBody3()
    {
        TestSpan(
@"class C
{
    void Goo() => [|123|]; $$
}");
    }
 
    [Fact]
    public void OnMethodWithExpressionBody4()
    {
        TestSpan(
@"class C
{
    void Goo() => [|12$$3|]; 
}");
    }
 
    [Fact]
    public void MissingOnMethod()
    {
        TestMissing(
@"class C
{
    void Goo($$);
}");
    }
 
    #region Constructors
 
    [Fact]
    public void InstanceConstructor_NoInitializer_BlockBody_All()
    {
        VerifyAllSpansInDeclaration<ConstructorDeclarationSyntax>(
@"class C
{
    [Attribute1, Attribute2][Attribute3][|$$public C()|] [|{|] [|}|]
}");
    }
 
    [Fact]
    public void InstanceConstructor_NoInitializer_BlockBody()
    {
        // a sequence point for base constructor call
        TestSpan(
@"class C
{
    [|pub$$lic C()|]
    {
    }
}");
    }
 
    [Fact]
    public void InstanceConstructor_NoBody()
    {
        TestSpan(
@"class Class
{
    [|Cla$$ss()|]
}");
    }
 
    [Fact]
    public void InstanceConstructor_NoInitializer_ExpressionBody_All()
    {
        VerifyAllSpansInDeclaration<ConstructorDeclarationSyntax>(
@"class C
{
    [Attribute1, Attribute2][Attribute3][|$$public C()|] => [|x = 1|];
}");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/14438")]
    public void InstanceConstructor_NoInitializer_ExpressionBody1()
    {
        // a sequence point for base constructor call
        TestSpan(
@"class C
{
    [|pub$$lic C()|] => F();
}");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/14438")]
    public void InstanceConstructor_NoInitializer_ExpressionBody2()
    {
        // a sequence point for base constructor call
        TestSpan(
@"class C
{
    [|public C()|] $$=> x = 1);
}");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/14438")]
    public void InstanceConstructor_NoInitializer_ExpressionBody3()
    {
        // a sequence point for base constructor call
        TestSpan(
@"class C
{
    public C() =$$> [|x = 1|];
}");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/14438")]
    public void InstanceConstructor_NoInitializer_ExpressionBody4()
    {
        // a sequence point for base constructor call
        TestSpan(
@"class C
{
    public C() => [|$$x = 1|];
}");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/14438")]
    public void InstanceConstructor_NoInitializer_ExpressionBody5()
    {
        TestSpan(
@"class C
{
    public C() => [|x =$$ 1|];
}");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/14438")]
    public void InstanceConstructor_NoInitializer_ExpressionBody6()
    {
        TestSpan(
@"class C
{
    public C() => [|x = 1|]$$;
}");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/14438")]
    public void InstanceConstructor_NoInitializer_ExpressionBody7()
    {
        TestSpan(
@"class C
{
    public C() => [|x = 1|];$$
}");
    }
 
    [Fact]
    public void InstanceConstructor_NoInitializer_Attributes()
    {
        TestSpan(
@"class C
{
    [Attribute1,$$ Attribute2]
    [Attribute3]
    [|public 
 
        C()|]
    {
    }
}");
    }
 
    [Theory, CombinatorialData]
    public void InstanceConstructor_Primary_ImplicitBaseInitializer_OutsideOfIdentifierAndNonEmptyParameters(
        [CombinatorialValues("class", "struct", "record", "record struct")] string keyword,
        [CombinatorialValues(
            "$$[A]class [|C()|];",
            "$$class [|C()|];",
            "class$$ [|C()|];",
            "class [|C($$)|];",
            "$$class [|C(int a)|];",
            "$$class [|C(int a, int b)|];",
            "class [|C(int a, int b)|]$$;",
            "class [|C(int a, int b)|]$$ { }",
            "class [|C(int a, int b)|]$$ : B { }",
            "class [|C(int a, int b)|] : B$$ { }",
            "class [|C(int a, int b)|] : B, $$I { }",
            "class [|C<T>(int a, int b)|]$$ where T : notnull;",
            "class [|C<T>(int a, int b)|] where $$T : notnull;",
            "class [|C<T>(int a, int b)|] where T : notnull$$;",
            "class [|C<T>(int a, int b)|] where T : notnull$$ { }")] string source)
    {
        TestSpan(source.Replace("class", keyword));
    }
 
    [Theory, CombinatorialData]
    public void InstanceConstructor_Primary_ImplicitBaseInitializer_OnIdentifierOrNonEmptyParameters_NonRecord(
        [CombinatorialValues("class", "struct")] string keyword,
        [CombinatorialValues(
            "class [|$$C(int a, int b)|];",
            "class [|C$$(int a, int b)|];",
            "class [|C$$<T>(int a, int b)|];",
            "class [|C<$$T>(int a, int b)|];",
            "class [|C<$$[A]T>(int a, int b)|];",
            "class [|C<T>$$(int a, int b)|];",
            "class [|C<T>($$int a, int b)|];",
            "class [|C<T>($$[A]int a, int b)|];",
            "class [|C<T>(int a, int b$$)|];")] string source)
    {
        TestSpan(source.Replace("class", keyword));
    }
 
    [Theory, CombinatorialData]
    public void InstanceConstructor_Primary_ImplicitBaseInitializer_OnIdentifierOrNonEmptyParameters_Record(
        [CombinatorialValues("record", "record struct")] string keyword,
        [CombinatorialValues(
            "record [|$$C|](int a, int b);",          // copy-ctor
            "record [|C$$|](int a, int b);",          // copy-ctor
            "record [|C$$<T>|](int a, int b);",       // copy-ctor
            "record [|C<$$T>|](int a, int b);",       // copy-ctor
            "record [|C<$$[A]T>|](int a, int b);",    // copy-ctor
            "record [|C<T>$$|](int a, int b);",       // copy-ctor
            "record C<T>([|$$int a|], int b);",       // property getter and setter
            "record C<T>($$[A][|int a|], int b);",    // property getter and setter
            "record C<T>($$   [A][|int a|], int b);", // property getter and setter
            "record C<T>(int a, [|int b$$|]);",       // property getter and setter
            "record C<T>(int a,  $$ [|int b|]);",     // property getter and setter
            "record C<T>(int a, [|params int[] b|]  $$);",     // property getter and setter
            "record C<T>(int a, [|int b|] = default$$);")] string source) // property getter and setter
    {
        TestSpan(source.Replace("record", keyword));
    }
 
    [Theory, CombinatorialData]
    public void InstanceConstructor_Primary_ImplicitBaseInitializer_NoBreakpoint(
        [CombinatorialValues("class", "struct", "record", "record struct")] string keyword,
        [CombinatorialValues(
            "$$[A]class C;",
            "$$class C;",
            "class C$$;",
            "class C;$$",
            "class C(int a, int b);$$",
            "class C(int a, int b) : B;$$",
            "class C(int a, int b) : B { }$$")] string source)
    {
        TestMissing(source.Replace("class", keyword));
    }
 
    [Theory, CombinatorialData]
    public void InstanceConstructor_Primary_ExplicitBaseInitializer_OutsideOfIdentifierAndNonEmptyParameters(
        [CombinatorialValues("class", "struct", "record", "record struct")] string keyword,
        [CombinatorialValues(
            "$$[A]class C() : [|B()|];",
            "$$class C() : [|B()|];",
            "$$class C(int a) : [|B()|];",
            "$$class C(int a, int b) : [|B()|];",
            "class C(int a, int b)$$ : [|B()|];",
            "class C(int a, int b) :$$ [|B()|];",
            "class C(int a, int b) : [|$$B()|];",
            "class C(int a, int b) : [|B($$)|];",
            "class C(int a, int b) : [|B()$$|];",
            "class C(int a, int b) : [|B()|] $$;",
            "class C(int a, int b) : [|B()|] $$ {}",
            "class C(int a, int b) : [|B()|], $$I {}",
            "class C(int a, int b) : [|B()|], I$$ {}",
            "class C<T>(int a, int b) : [|B()|] $$ where T : notnull;",
            "class C<T>(int a, int b) : [|B()|], $$I where T : notnull { }",
            "class C<T>(int a, int b) : [|B()|], I$$ where T : notnull { }",
            "class C<T>(int a, int b) : [|B()|]  where $$T : notnull;",
            "class C<T>(int a, int b) : [|B()|]  where T : notnull$$;",
            "class C<T>(int a, int b) : [|B()|]  where T : notnull$$ { }")] string source)
    {
        TestSpan(source.Replace("class", keyword));
    }
 
    [Theory, CombinatorialData]
    public void InstanceConstructor_Primary_ExplicitBaseInitializer_OnIdentifierOrNonEmptyParameters_NonRecord(
        [CombinatorialValues("class", "struct")] string keyword,
        [CombinatorialValues(
            "class $$C(int a, int b) : [|B()|];",
            "class C$$(int a, int b) : [|B()|];",
            "class C<$$[A]T>(int a, int b) : [|B()|];",
            "class C<T>$$(int a, int b) : [|B()|];",
            "class C<T>($$int a, int b) : [|B()|];",
            "class C<T>(int a, $$int b) : [|B()|];",
            "class C<T>(int a, int b =$$ 1) : [|B()|];")] string source)
    {
        TestSpan(source.Replace("class", keyword));
    }
 
    [Theory, CombinatorialData]
    public void InstanceConstructor_Primary_ExplicitBaseInitializer_OnIdentifierOrNonEmptyParameters_Record(
        [CombinatorialValues("record", "record struct")] string keyword,
        [CombinatorialValues(
            "record [|$$C|](int a, int b) : B();",        // copy-constructor
            "record [|C$$|](int a, int b) : B();",        // copy-constructor
            "record [|C<$$[A]T>|](int a, int b) : B();",  // copy-constructor
            "record [|C<T>$$|](int a, int b) : B();",     // copy-constructor
            "record C<T>([|$$int a|], int b) : B();",     // property getter and setter
            "record C<T>(int a, [|$$int b|]) : B();",     // property getter and setter
            "record C<T>(int a, [|$$int b|] = 1) : B();")] string source) // property getter and setter
    {
        TestSpan(source.Replace("record", keyword));
    }
 
    [Theory, CombinatorialData]
    public void InstanceConstructor_Primary_ExplicitBaseInitializer_NoBreakpoint(
        [CombinatorialValues("class", "struct", "record", "record struct")] string keyword,
        [CombinatorialValues(
            "class C(int a, int b) : B() {$$ }",
            "class C(int a, int b) : B();$$",
            "class C(int a, int b) : B() { }$$",
            "class C(int a, int b) : B {$$ }",
            "class C(int a, int b) : B(), I { }$$")] string source)
    {
        TestMissing(source.Replace("class", keyword));
    }
 
    [Fact]
    public void InstanceConstructor_BaseInitializer_BlockBody_All()
    {
        VerifyAllSpansInDeclaration<ConstructorDeclarationSyntax>(
@"class C
{
    [Attribute1, Attribute2][Attribute3]$$public C() : [|base(42)|] [|{|][|}|]
}");
    }
 
    [Fact]
    public void InstanceConstructor_BaseInitializer_BlockBody()
    {
        // a sequence point for base constructor call
        TestSpan(
@"class C
{
    pub$$lic C()
        : [|base(42)|]
    {
    }
}");
    }
 
    [Fact]
    public void InstanceConstructor_BaseInitializer_ExpressionBody_All()
    {
        VerifyAllSpansInDeclaration<ConstructorDeclarationSyntax>(
@"class C
{
    [Attribute1, Attribute2][Attribute3]$$public C() : [|base(42)|] => [|x = 1|];
}");
    }
 
    [Fact]
    public void InstanceConstructor_BaseInitializer_ExpressionBody1()
    {
        // a sequence point for base constructor call
        TestSpan(
@"class C
{
    pub$$lic C() : [|base(42)|] => F();
    
}");
    }
 
    [Fact]
    public void InstanceConstructor_BaseInitializer_ExpressionBody2()
    {
        // a sequence point for base constructor call
        TestSpan(
@"class C
{
    public C() : [|base(42)|] $$=> F();
    
}");
    }
 
    [Fact]
    public void InstanceConstructor_BaseInitializer_ExpressionBody3()
    {
        // a sequence point for base constructor call
        TestSpan(
@"class C
{
    public C() : base(42) =$$> [|F()|];
    
}");
    }
 
    [Fact]
    public void InstanceConstructor_BaseInitializer_ExpressionBody4()
    {
        // a sequence point for base constructor call
        TestSpan(
@"class C
{
    public C() : base(42) => [|$$F()|];
    
}");
    }
 
    [Fact]
    public void InstanceConstructor_ThisInitializer()
    {
        // a sequence point for this constructor call
        TestSpan(
@"class C
{
    pub$$lic C()
        : [|this(42)|]
    {
    }
}");
    }
 
    [Fact]
    public void StaticConstructor_BlockBody_All()
    {
        VerifyAllSpansInDeclaration<ConstructorDeclarationSyntax>(
@"class C
{
    [Attribute1, Attribute2][Attribute3]$$static public C() [|{|] [|}|]
}");
    }
 
    [Fact]
    public void StaticConstructor_BlockBody()
    {
        TestSpan(
@"class C
{
    $$static C()
    [|{|]
    }
}");
    }
 
    [Fact]
    public void StaticConstructor_ExpressionBody_All()
    {
        VerifyAllSpansInDeclaration<ConstructorDeclarationSyntax>(
@"class C
{
    [Attribute1, Attribute2][Attribute3]$$static public C() => [|x = 1|];
}");
    }
 
    [Fact]
    public void StaticConstructor_ExpressionBody()
    {
        TestSpan(
@"class C
{
    static C() => [|$$F()|];
}");
    }
 
    [Fact]
    public void StaticConstructor_NoBody()
    {
        TestMissing(
@"class Class
{
    static Cla$$ss()
}");
    }
 
    [Fact]
    public void InstanceConstructorInitializer()
    {
        // a sequence point for this constructor call
        TestSpan(
@"class Derived : Base
{
    public Derived()
        : [|this($$42)|]
    {
    }
}");
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/543968")]
    public void ConstructorInitializer()
    {
        // a sequence point for base constructor call
        TestSpan(
@"class Derived : Base
{
    public Derived()
        : [|base($$42)|]
    {
    }
}
");
    }
 
    [Fact]
    public void OnStaticConstructor()
    {
        TestSpan(
@"class C
{
    st$$atic C()
    [|{|]
    }
}");
    }
 
    #endregion
 
    [Fact]
    public void OnDestructor()
    {
        TestSpan(
@"class C
{
    ~C$$()
    [|{|]
    }
}");
    }
 
    [Fact]
    public void OnOperator()
    {
        TestSpan(
@"class C
{
    public static int op$$erator+(C c1, C c2)
    [|{|]
    }
}");
    }
 
    [Fact]
    public void OnOperatorWithExpressionBody1()
    {
        TestSpan(
@"class C
{
    public static int op$$erator+(C c1, C c2) => [|c1|];
}");
    }
 
    [Fact]
    public void OnOperatorWithExpressionBody2()
    {
        TestSpan(
@"class C
{
    public static int operator+(C c1, C c2) =>$$ [|c1|];
}");
    }
 
    [Fact]
    public void OnOperatorWithExpressionBody3()
    {
        TestSpan(
@"class C
{
    public static int operator+(C c1, C c2) => [|c1|]; $$
}");
    }
 
    [Fact]
    public void OnOperatorWithExpressionBody4()
    {
        TestSpan(
@"class C
{
    public static int operator+(C c1, C c2) => [|c$$1|];
}");
    }
 
    [Fact]
    public void OnConversionOperator()
    {
        TestSpan(
@"class C
{
    public static op$$erator DateTime(C c1)
    [|{|]
    }
}");
    }
 
    [Fact]
    public void OnConversionOperatorWithExpressionBody1()
    {
        TestSpan(
@"class C
{
    public static op$$erator DateTime(C c1) => [|DataTime.Now|];
}");
    }
 
    [Fact]
    public void OnConversionOperatorWithExpressionBody2()
    {
        TestSpan(
@"class C
{
    public static operator DateTime(C c1) =>$$ [|DataTime.Now|];
}");
    }
 
    [Fact]
    public void OnConversionOperatorWithExpressionBody3()
    {
        TestSpan(
@"class C
{
    public static operator DateTime(C c1) => [|DataTime.Now|];$$
}");
    }
 
    [Fact]
    public void OnConversionOperatorWithExpressionBody4()
    {
        TestSpan(
@"class C
{
    public static operator DateTime(C c1) => [|DataTime$$.Now|];
}");
    }
 
    [Fact, WorkItem(3557, "DevDiv_Projects/Roslyn")]
    public void InFrontOfAttribute()
    {
        TestSpan(
@"class C
{
$$ [method: Obsolete]
  void Goo()
  [|{|]
  }
}");
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/538058")]
    public void InInactivePPRegion()
    {
        TestLine(
@"
 
#if blahblah
$$gooby
#endif");
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/538777")]
    public void WithIncompleteDeclaration()
    {
        TestMissing(
@"
clas C
{
    void Goo()
    {
$$        int
    }
}");
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/937290")]
    public void OnGetter()
    {
        TestSpan(
@"class C
{
    public int $$Id { [|get;|] set; }
}");
 
        TestSpan(
@"class C
{
    public int Id { [|g$$et;|] set; }
}");
 
        TestSpan(
@"class C
{
    public int Id { g$$et [|{|] return 42; } set {} }
}");
 
        TestSpan(
@"class C
{
    public int$$ Id { get [|{|] return 42; } set {} }
}");
    }
 
    [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/937290")]
    public void OnSetter()
    {
        TestSpan(
@"class C
{
    public int Id { get; [|se$$t;|] }
}");
 
        TestSpan(
@"class C
{
    public int Id { get; [|set;|] $$ }
}");
 
        TestSpan(
@"class C
{
    public int $$Id { [|set;|] get; }
}");
 
        TestSpan(
@"class C
{
    public int Id { get { return 42; } s$$et [|{|] } }
}");
 
        TestSpan(
@"class C
{
    public int Id { get { return 42; } set { [|}|] $$}
}");
    }
 
    [Fact]
    public void WhenClause_1()
    {
        TestSpan(
@"class C
{
  string s;
  bool b;
  void Goo()
  {
    switch (s)
    {
$$      case string s [|when b|]:
        break;
    }
  }
}");
    }
 
    [Fact]
    public void WhenClause_2()
    {
        TestSpan(
@"class C
{
  string s;
  bool b;
  void Goo()
  {
    switch (s)
    {
      case string s [|whe$$n b|]:
        break;
    }
  }
}");
    }
 
    [Fact]
    public void WhenClause_3()
    {
        TestSpan(
@"class C
{
  string s;
  bool b;
  void Goo()
  {
    switch (s)
    {
      case string s [|when b|]:$$
        break;
    }
  }
}");
    }
 
    [Fact]
    public void PatternSwitchCase_1()
    {
        TestSpan(
@"class C
{
  string s;
  bool b;
  void Goo()
  {
    switch (s)
    {
$$      case string s:
      default:
        [|break;|]
    }
  }
}");
    }
 
    [Fact]
    public void PatternSwitchCase_2()
    {
        TestSpan(
@"class C
{
  string s;
  bool b;
  void Goo()
  {
    switch (s)
    {
      $$case string s:
      default:
        [|break;|]
    }
  }
}");
    }
 
    [Fact]
    public void PatternSwitchCase_3()
    {
        TestSpan(
@"class C
{
  string s;
  bool b;
  void Goo()
  {
    switch (s)
    {
      case string s:$$
      default:
        [|break;|]
    }
  }
}");
    }
 
    [Fact]
    public void DeconstructionDeclarationStatement_1()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
$$    [|var (x, y) = (1, 2);|]
  }
}");
    }
 
    [Fact]
    public void DeconstructionDeclarationStatement_2()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    [|var (x, y) = $$(1, 2);|]
  }
}");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/14438")]
    public void OnAccessorExpressionBody1()
    {
        TestSpan(
@"class C
{
    public int Id { get => [|12$$3|]; }
}");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/14438")]
    public void OnAccessorExpressionBody2()
    {
        TestSpan(
@"class C
{
    public int Id { get $$=> [|123|]; }
}");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/14438")]
    public void OnAccessorExpressionBody3()
    {
        TestSpan(
@"class C
{
    $$public int Id { get => [|123|]; }
}");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/14438")]
    public void OnAccessorExpressionBody4()
    {
        TestSpan(
@"class C
{
    public int Id { get => [|123|];   $$ }
}");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/14438")]
    public void OnAccessorExpressionBody5()
    {
        TestSpan(
@"class C
{
$$    public event Action Goo { add => [|123|]; remove => 456; }
}");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/14438")]
    public void OnAccessorExpressionBody6()
    {
        TestSpan(
@"class C
{
    public event Action Goo { add => [|123|];$$ remove => 456; }
}");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/14438")]
    public void OnAccessorExpressionBody7()
    {
        TestSpan(
@"class C
{
    public event Action Goo { add => 123; $$remove => [|456|]; }
}");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/14438")]
    public void OnAccessorExpressionBody8()
    {
        TestSpan(
@"class C
{
    public event Action Goo { add => 123; remove => [|456|]; }$$
}");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/14438")]
    public void OnDtorExpressionBody1()
    {
        TestSpan(
@"class C
{
$$    public ~C() => [|x = 1|];
}");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/14438")]
    public void OnDtorExpressionBody2()
    {
        TestSpan(
@"class C
{
    public ~C() => $$[|x = 1|];
}");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/14438")]
    public void OnDtorExpressionBody3()
    {
        TestSpan(
@"class C
{
    public ~C() => [|x =$$ 1|];
}");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/14438")]
    public void OnDtorExpressionBody4()
    {
        TestSpan(
@"class C
{
    public ~C() => [|x = 1|]$$;
}");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/14438")]
    public void OnDtorExpressionBody5()
    {
        TestSpan(
@"class C
{
    public ~C() => [|x = 1|];$$
}");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/14437")]
    public void OnLocalFunctionDecl_1()
    {
        TestSpan(
@"class C
{
    static void M()
    {
$$        int Local(object[] a)
        [|{|]
            return a.Length;
        }
    }
}");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/14437")]
    public void OnLocalFunctionDecl_2()
    {
        TestSpan(
@"class C
{
    static void M()
    {
        int Local(object[] a)$$
        [|{|]
            return a.Length;
        }
    }
}");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/14437")]
    public void OnLocalFunctionDecl_3()
    {
        TestSpan(
@"class C
{
    static void M()
    {
        int Local(object[] a)
$$        [|{|]
            return a.Length;
        }
    }
}");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/14437")]
    public void OnLocalFunctionDecl_4()
    {
        TestSpan(
@"class C
{
    static void M()
    {
$$        int Local(object[] a) => [|a.Length|];
    }
}");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/14437")]
    public void OnLocalFunctionDecl_5()
    {
        TestSpan(
@"class C
{
    static void M()
    {
        int Local(object$$[] a) => [|a.Length|];
    }
}");
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/14437")]
    public void OnLocalFunctionDecl_6()
    {
        TestSpan(
@"class C
{
    static void M()
    {
        int Local(object[] a) => [|a.Length|];$$
    }
}");
    }
 
    [Fact, WorkItem("https://developercommunity.visualstudio.com/content/problem/98990/cant-set-breakpoint.html")]
    public void IncompleteExpressionStatement()
    {
        TestSpan(
@"class C
{
  void Goo()
  {
    [|$$aaa|]
  }
}");
    }
 
    #region Top Level Statements
 
    [Fact]
    public void TopLevelStatements()
    {
        VerifyAllSpansInDeclaration<CompilationUnitSyntax>(@"
$$[|int d = 5;|]
[|int a = 1|], [|b = 2|], [|c = 3|];
for ([|int i = 0|], [|j = 1|], [|k = 2|]; [|i < 10|]; [|i++|], [|j++|], [|k--|])
    [|while (b > 0)|]
    [|{|]
        [|if (c < b)|]
            try
            [|{|]
                [|System.Console.WriteLine(a);|]
            [|}|]
            [|catch (Exception e)|]
            [|{|]
                [|System.Console.WriteLine(e);|]   
            [|}|]
            finally
            [|{|]
            [|}|]
        else [|if (b < 10)|]
            [|System.Console.WriteLine(b);|]
        else
            [|System.Console.WriteLine(c);|]
    [|}|]
");
    }
 
    #endregion
}