using System.Linq;
using System.Threading.Tasks;
using Microsoft.CodeAnalysis;
using Microsoft.Extensions.Options;
using Shouldly;
using Xunit;

namespace Cfa.Tests.CallGraphBuilderTests;

public sealed class FindCalleesShould
{
    [Fact]
    public async Task FollowMessagesPublishedByARegisteredLambdaOnlyWhenThatLambdaIsVisited()
    {
        // Arrange
        var source =
            MessageSource.Contracts
            + """
                class Receiver : Sample.Grains.EventHandlers.EventReceiver<Sample.Domain.Message<int>>
                {
                    public Receiver(Sample.GrainInterfaces.Events.IEventSender sender)
                    {
                        On<Updated>(evt => sender.Publish(new Other()));
                        On<Other>(Handle);
                    }
                    void Handle(Other evt) { }
                }
                class Example
                {
                    void Start(Sample.GrainInterfaces.Events.IEventSender sender)
                    {
                        sender.Publish(new Updated());
                    }
                }
                """;

        // Act
        var (start, calls) = await source.FindCallees();

        // Assert
        var first = calls[start].ShouldHaveSingleItem();
        first.LinkKind.ShouldBe(LinkKind.Event);
        first.Target.ShouldBeAssignableTo<IMethodSymbol>().MethodKind.ShouldBe(MethodKind.AnonymousFunction);
        var second = calls[first.Target].ShouldHaveSingleItem();
        second.Target.Name.ShouldBe("Handle");
        second.LinkKind.ShouldBe(LinkKind.Event);
    }

    [Fact]
    public async Task FindRegistrationsThroughAMessageTypeAlias()
    {
        // Arrange
        var source =
            "using Notification = Updated;\n"
            + MessageSource.Contracts
            + """
                class Example : Sample.Grains.EventHandlers.EventReceiver<Sample.Domain.Message<int>>
                {
                    public Example() { On<Notification>(Handle); }
                    void Handle(Notification evt) { }
                    void Start(Sample.GrainInterfaces.Events.IEventSender sender) { sender.Publish(new Updated()); }
                }
                """;

        // Act
        var (start, calls) = await source.FindCallees();

        // Assert
        var handler = calls[start].ShouldHaveSingleItem();
        handler.Target.Name.ShouldBe("Handle");
        handler.LinkKind.ShouldBe(LinkKind.Event);
    }

    [Fact]
    public async Task LeaveMessageLinksDisabledWithoutRoutes()
    {
        // Arrange
        var source =
            MessageSource.Contracts
            + """
                class Example : Sample.Grains.EventHandlers.EventReceiver<Sample.Domain.Message<int>>
                {
                    public Example() { On<Updated>(Handle); }
                    void Handle(Updated evt) { }
                    void Start(Sample.GrainInterfaces.Events.IEventSender sender) { sender.Publish(new Updated()); }
                }
                """;

        // Act
        var (start, calls) = await source.FindCallees(new MessageOptions());

        // Assert
        calls[start].ShouldNotContain(call => call.LinkKind == LinkKind.Event);
    }

    [Theory]
    [InlineData("Missing", 0)]
    [InlineData("Publish", 1)]
    public async Task ReportMissingMethodsAndInvalidArgumentIndices(string method, int index)
    {
        // Arrange
        var options = MessageSource.Options;
        options.MessageRoutes[0].Publisher.Method.Name = method;
        options.MessageRoutes[0].Publisher.MessageArgument = index;
        var source = MessageSource.Contracts + "class Example { void Start() { } }";

        // Act
        var scan = () => source.FindCallees(options);

        // Assert
        (await scan.ShouldThrowAsync<OptionsValidationException>()).Message.ShouldContain(method);
    }

    [Fact]
    public async Task UseConfiguredArgumentPositionsWithoutSkippingOtherRegistrationArguments()
    {
        // Arrange
        var source = """
            class Payload { }
            interface Sender { void Send(int key, object message); }
            class Example
            {
                void Register<TContext, TMessage>(int key, System.Action<TMessage> callback) { }
                void Handle(Payload message) { }
                int Key() => 0;
                void Start(Sender sender)
                {
                    Register<object, Payload>(Key(), Handle);
                    sender.Send(message: new Payload(), key: 0);
                }
            }
            """;
        var options = new MessageOptions
        {
            MessageRoutes =
            [
                new()
                {
                    Publisher = new()
                    {
                        Method = new() { Type = "Sender", Name = "Send" },
                        MessageArgument = 1,
                    },
                    Registrations =
                    [
                        new()
                        {
                            Method = new() { Type = "Example", Name = "Register" },
                            MessageTypeArgument = 1,
                            HandlerArgument = 1,
                        },
                    ],
                },
            ],
        };

        // Act
        var (start, calls) = await source.FindCallees(options);

        // Assert
        calls[start].ShouldContain(call => call.Target.Name == "Handle" && call.LinkKind == LinkKind.Event);
        calls[start].ShouldContain(call => call.Target.Name == "Key" && call.LinkKind == LinkKind.Direct);
    }

    [Theory]
    [InlineData("On<Updated>(Handle);")]
    [InlineData("On<Updated>(evt => Handle(evt));")]
    [InlineData("On<Updated>(async evt => { await System.Threading.Tasks.Task.CompletedTask; Handle(evt); });")]
    public async Task LinkPublishedEventsToTheirRegisteredHandlers(string registration)
    {
        // Arrange
        var source =
            MessageSource.Contracts
            + $$"""
                class Receiver : Sample.Grains.EventHandlers.EventReceiver<Sample.Domain.Message<int>>
                {
                    public Receiver() { {{registration}} On<Other>(Ignore); }
                    void Handle(Updated evt) { Save(); }
                    void Ignore(Other evt) { }
                    void Save() { }
                }
                class Example
                {
                    void Start(Sample.GrainInterfaces.Events.IEventSender publisher)
                    {
                        publisher.Publish<int>(message: new Updated());
                        publisher.Publish<int>(message: new Updated());
                    }
                }
                """;

        // Act
        var (start, calls) = await source.FindCallees();

        // Assert
        var handler = calls[start].ShouldHaveSingleItem();
        handler.LinkKind.ShouldBe(LinkKind.Event);
        handler.Target.ContainingType.Name.ShouldBe("Receiver");
        calls[handler.Target]
            .ShouldHaveSingleItem()
            .Target.Name.ShouldBe(registration.Contains("=>") ? "Handle" : "Save");
    }

    [Theory]
    [InlineData("When<Change>(Handle);")]
    [InlineData("When<Change>((cmd, aggregate) => Handle(cmd, aggregate));")]
    public async Task LinkDispatchedCommandsToTheirRegisteredHandlers(string registration)
    {
        // Arrange
        var source =
            MessageSource.Contracts
            + $$"""
                class Receiver : Sample.Grains.CommandReceiver<object, int, object>
                {
                    public Receiver() { {{registration}} }
                    void Handle(Change command, object aggregate) { Save(); }
                    void Save() { }
                }
                class Example
                {
                    void Start(Sample.GrainInterfaces.Commands.ICommandSender bus) { bus.Dispatch(new Change()); }
                }
                """;

        // Act
        var (start, calls) = await source.FindCallees();

        // Assert
        var handler = calls[start].Where(call => call.LinkKind == LinkKind.Event).ShouldHaveSingleItem();
        calls[handler.Target]
            .ShouldHaveSingleItem()
            .Target.Name.ShouldBe(registration.Contains("=>") ? "Handle" : "Save");
    }

    [Fact]
    public async Task RecognizePublisherImplementationsAsWellAsTheInterface()
    {
        // Arrange
        var source =
            MessageSource.Contracts
            + """
                class Publisher : Sample.GrainInterfaces.Events.IEventSender
                {
                    public void Publish<TId>(Sample.Domain.Message<TId> message) { }
                }
                class Example : Sample.Grains.EventHandlers.EventReceiver<Sample.Domain.Message<int>>
                {
                    public Example() { On<Updated>(Handle); }
                    void Handle(Updated evt) { }
                    void Start(Publisher publisher) { publisher.Publish(new Updated()); }
                }
                """;

        // Act
        var (start, calls) = await source.FindCallees();

        // Assert
        calls[start]
            .Where(call => call.LinkKind == LinkKind.Event)
            .ShouldHaveSingleItem()
            .Target.Name.ShouldBe("Handle");
    }

    [Fact]
    public async Task KeepEachPublishersEventTypeSeparate()
    {
        // Arrange
        var source =
            MessageSource.Contracts
            + """
                class Receiver : Sample.Grains.EventHandlers.EventReceiver<Sample.Domain.Message<int>>
                {
                    public Receiver() { On<Updated>(Handle); On<Other>(Ignore); }
                    void Handle(Updated evt) { }
                    void Ignore(Other evt) { }
                }
                class Example
                {
                    void Start(Sample.GrainInterfaces.Events.IEventSender publisher)
                    {
                        publisher.Publish(new Updated());
                        OtherPublisher(publisher);
                    }
                    void OtherPublisher(Sample.GrainInterfaces.Events.IEventSender publisher)
                    {
                        publisher.Publish(new Other());
                    }
                }
                """;

        // Act
        var (start, calls) = await source.FindCallees();

        // Assert
        calls[start]
            .Where(call => call.LinkKind == LinkKind.Event)
            .ShouldHaveSingleItem()
            .Target.Name.ShouldBe("Handle");
        var other = calls[start].Where(call => call.Target.Name == "OtherPublisher").ShouldHaveSingleItem().Target;
        calls[other].ShouldHaveSingleItem().Target.Name.ShouldBe("Ignore");
    }

    [Fact]
    public async Task NotGuessConcreteEventsFromAnErasedParameter()
    {
        // Arrange
        var source =
            MessageSource.Contracts
            + """
                class Receiver : Sample.Grains.EventHandlers.EventReceiver<Sample.Domain.Message<int>>
                {
                    public Receiver() { On<Updated>(Handle); }
                    void Handle(Updated evt) { }
                }
                class Example
                {
                    void Start(
                        Sample.GrainInterfaces.Events.IEventSender publisher,
                        Sample.Domain.Message<int> evt)
                    {
                        publisher.Publish(evt);
                    }
                }
                """;

        // Act
        var (start, calls) = await source.FindCallees();

        // Assert
        calls[start].ShouldBeEmpty();
    }

    [Fact]
    public async Task PreferDirectCallsWhenTheSameHandlerAlsoReceivesAnEvent()
    {
        // Arrange
        var source =
            MessageSource.Contracts
            + """
                class Example : Sample.Grains.EventHandlers.EventReceiver<Sample.Domain.Message<int>>
                {
                    public Example() { On<Updated>(Handle); }
                    void Handle(Updated evt) { }
                    void Start(Sample.GrainInterfaces.Events.IEventSender publisher, Updated evt)
                    {
                        publisher.Publish(evt);
                        Handle(evt);
                    }
                }
                """;

        // Act
        var (start, calls) = await source.FindCallees();

        // Assert
        var handler = calls[start].ShouldHaveSingleItem();
        handler.Target.Name.ShouldBe("Handle");
        handler.LinkKind.ShouldBe(LinkKind.Direct);
    }

    [Fact]
    public async Task IgnoreUnrelatedMethodsNamedPublishAndOn()
    {
        // Arrange
        var source =
            MessageSource.Contracts
            + """
                class Example
                {
                    void On<T>(System.Action<T> handler) { }
                    void Publish(Updated evt) { }
                    void Handle(Updated evt) { }
                    void Register() { On<Updated>(Handle); }
                    void Start() { Publish(new Updated()); }
                }
                """;

        // Act
        var (start, calls) = await source.FindCallees();

        // Assert
        calls[start].ShouldHaveSingleItem().Target.Name.ShouldBe("Publish");
        calls[start].ShouldNotContain(call => call.LinkKind == LinkKind.Event);
    }

    [Fact]
    public async Task NotTreatHandlerRegistrationAsHandlerExecution()
    {
        // Arrange
        var source =
            MessageSource.Contracts
            + """
                class Receiver : Sample.Grains.EventHandlers.EventReceiver<Sample.Domain.Message<int>>
                {
                    public Receiver() { On<Updated>(evt => Save()); On<Other>(Ignore); }
                    void Ignore(Other evt) { }
                    void Save() { }
                }
                class Example { void Start() { _ = new Receiver(); } }
                """;

        // Act
        var (start, calls) = await source.FindCallees();

        // Assert
        var constructor = calls[start].ShouldHaveSingleItem().Target;
        calls[constructor].ShouldNotContain(call => call.Target.Name == "Save" || call.Target.Name == "Ignore");
    }

    [Theory]
    [InlineData("Value")]
    [InlineData("this.Value")]
    public async Task FindExpressionBodiedProperties(string access)
    {
        // Arrange
        var source = $$"""
            class Example
            {
                int Value => 1;
                void Start() { _ = {{access}}; }
            }
            """;

        // Act
        var (start, calls) = await source.FindCallees();

        // Assert
        calls[start].ShouldHaveSingleItem().Target.Name.ShouldBe("Value");
    }

    [Fact]
    public async Task FollowMethodCallsInsideProperties()
    {
        // Arrange
        const string source = """
            class Example
            {
                int Value => GetValue();
                int GetValue() => 1;
                void Start() { _ = Value; }
            }
            """;

        // Act
        var (start, calls) = await source.FindCallees();

        // Assert
        var property = calls[start].ShouldHaveSingleItem();
        property.Target.Name.ShouldBe("Value");
        calls[property.Target].ShouldHaveSingleItem().Target.Name.ShouldBe("GetValue");
    }

    [Theory]
    [InlineData("int Value { get { return 1; } }", "_ = Value;")]
    [InlineData("int Value { get => 1; }", "_ = Value;")]
    [InlineData("int Value { set { } }", "Value = 1;")]
    public async Task FindPropertiesWithAccessorBodies(string declaration, string access)
    {
        // Arrange
        var source = $$"""
            class Example
            {
                {{declaration}}
                void Start() { {{access}} }
            }
            """;

        // Act
        var (start, calls) = await source.FindCallees();

        // Assert
        calls[start].ShouldHaveSingleItem().Target.Name.ShouldBe("Value");
    }

    [Theory]
    [InlineData("set { Save(value); }", "Value = 1;")]
    [InlineData("set { Save(value); }", "this.Value = 1;")]
    [InlineData("set => Save(value);", "Value = 1;")]
    [InlineData("set => Save(value);", "this.Value = 1;")]
    public async Task FollowAssignedPropertiesAndMethodCallsInsideTheirSetters(string setter, string assignment)
    {
        // Arrange
        var source = $$"""
            class Example
            {
                int Value { {{setter}} }
                void Save(int value) { }
                void Start() { {{assignment}} }
            }
            """;

        // Act
        var (start, calls) = await source.FindCallees();

        // Assert
        var property = calls[start].ShouldHaveSingleItem();
        property.Target.Name.ShouldBe("Value");
        calls[property.Target].ShouldHaveSingleItem().Target.Name.ShouldBe("Save");
    }

    [Theory]
    [InlineData("_ = this.Value;")]
    [InlineData("this.Value = 2;")]
    public async Task IgnoreAutoPropertiesEvenWhenTheyHaveInitializers(string access)
    {
        // Arrange
        var source = $$"""
            class Example
            {
                int Value { get; set; } = 1;
                void Start() { {{access}} }
            }
            """;

        // Act
        var (start, calls) = await source.FindCallees();

        // Assert
        calls[start].ShouldBeEmpty();
    }

    [Theory]
    [InlineData("int this[int index] => Read();", "_ = this[0];", "Read")]
    [InlineData("int this[int index] => Read();", "_ = this?[0];", "Read")]
    [InlineData("int this[int index] { get { return Read(); } }", "_ = this[0];", "Read")]
    [InlineData("int this[int index] { get => Read(); }", "_ = this[0];", "Read")]
    [InlineData("int this[int index] { set { Save(value); } }", "this[0] = 1;", "Save")]
    [InlineData("int this[int index] { set => Save(value); }", "this[0] = 1;", "Save")]
    public async Task FollowIndexersWithBodies(string declaration, string access, string method)
    {
        // Arrange
        var source = $$"""
            class Example
            {
                {{declaration}}
                int Read() => 1;
                void Save(int value) { }
                void Start() { {{access}} }
            }
            """;

        // Act
        var (start, calls) = await source.FindCallees();

        // Assert
        var indexer = calls[start].ShouldHaveSingleItem();
        indexer.Target.ShouldBeAssignableTo<IPropertySymbol>().IsIndexer.ShouldBeTrue();
        calls[indexer.Target].ShouldHaveSingleItem().Target.Name.ShouldBe(method);
    }

    [Fact]
    public async Task IgnoreIndexersWithoutBodies()
    {
        // Arrange
        const string source = """
            abstract class Example
            {
                public abstract int this[int index] { get; set; }
                void Start() { _ = this[0]; this[0] = 1; }
            }
            """;

        // Act
        var (start, calls) = await source.FindCallees();

        // Assert
        calls[start].ShouldBeEmpty();
    }

    [Theory]
    [InlineData("void Run();", "public void Run() => Helper();", "service.Run();")]
    [InlineData("void Run();", "void IService.Run() => Helper();", "service.Run();")]
    [InlineData("int Value { get; }", "public int Value => Helper();", "_ = service.Value;")]
    [InlineData("int Value { get; }", "int IService.Value => Helper();", "_ = service.Value;")]
    [InlineData("int this[int index] { get; }", "public int this[int index] => Helper();", "_ = service[0];")]
    public async Task FollowSourceImplementationsOfInterfaces(string contract, string implementation, string access)
    {
        // Arrange
        var source = $$"""
            interface IService { {{contract}} }
            class Example : IService
            {
                {{implementation}}
                int Helper() => 1;
                void Start(IService service) { {{access}} }
            }
            """;

        // Act
        var (start, calls) = await source.FindCallees();

        // Assert
        var call = calls[start].ShouldHaveSingleItem();
        call.Target.ContainingType.Name.ShouldBe("Example");
        calls[call.Target].ShouldHaveSingleItem().Target.Name.ShouldBe("Helper");
    }

    [Fact]
    public async Task NotListTheAbstractMemberOnlyTheImplementation()
    {
        // Arrange
        const string source = """
            interface IService { void Run(); }
            class Example : IService
            {
                public void Run() { }
                void Start(IService service) { service.Run(); }
            }
            """;

        // Act
        var (start, calls) = await source.FindCallees();

        // Assert
        var call = calls[start].ShouldHaveSingleItem();
        call.Target.ContainingType.Name.ShouldBe("Example");
    }

    [Fact]
    public async Task FollowImplementationsOfInterfacesFromMetadata()
    {
        // Arrange
        const string source = """
            class Example : System.IDisposable
            {
                public void Dispose() => Cleanup();
                void Cleanup() { }
                void Start(System.IDisposable service) { service.Dispose(); }
            }
            """;

        // Act
        var (start, calls) = await source.FindCallees();

        // Assert
        var call = calls[start].ShouldHaveSingleItem();
        call.Target.Name.ShouldBe("Dispose");
        call.LinkKind.ShouldBe(LinkKind.Abstract);
        calls[call.Target].ShouldHaveSingleItem().Target.Name.ShouldBe("Cleanup");
    }

    [Theory]
    [InlineData("service.Run(); Run();")]
    [InlineData("Run(); service.Run();")]
    public async Task PreferDirectCallsOverInterfaceLinks(string body)
    {
        // Arrange
        var source = $$"""
            interface IService { void Run(); }
            class Example : IService
            {
                public void Run() { }
                void Start(IService service) { {{body}} }
            }
            """;

        // Act
        var (start, calls) = await source.FindCallees();

        // Assert
        var call = calls[start].ShouldHaveSingleItem();
        call.LinkKind.ShouldBe(LinkKind.Direct);
    }

    [Fact]
    public async Task IgnoreInterfaceImplementationsWithoutPropertyBodies()
    {
        // Arrange
        const string source = """
            interface IService { int Value { get; } }
            class Example : IService
            {
                public int Value { get; set; }
                void Start(IService service) { _ = service.Value; }
            }
            """;

        // Act
        var (start, calls) = await source.FindCallees();

        // Assert
        calls[start].ShouldBeEmpty();
    }

    [Theory]
    [InlineData("public abstract void Run();", "public override void Run() => Helper();", "service.Run();")]
    [InlineData("public abstract int Value { get; }", "public override int Value => Helper();", "_ = service.Value;")]
    [InlineData(
        "public abstract int this[int index] { get; }",
        "public override int this[int index] => Helper();",
        "_ = service[0];"
    )]
    public async Task FollowOverridesOfAbstractMembers(string contract, string implementation, string access)
    {
        // Arrange
        var source = $$"""
            abstract class Service { {{contract}} }
            class Example : Service
            {
                {{implementation}}
                int Helper() => 1;
                void Start(Service service) { {{access}} }
            }
            """;

        // Act
        var (start, calls) = await source.FindCallees();

        // Assert
        var call = calls[start].ShouldHaveSingleItem();
        call.Target.ContainingType.Name.ShouldBe("Example");
        calls[call.Target].ShouldHaveSingleItem().Target.Name.ShouldBe("Helper");
    }

    [Fact]
    public async Task FollowOverridesThroughIntermediateAbstractClasses()
    {
        // Arrange
        const string source = """
            abstract class Service { public abstract void Run(); }
            abstract class Middle : Service { public abstract override void Run(); }
            class Example : Middle
            {
                public override void Run() { }
                void Start(Service service) { service.Run(); }
            }
            """;

        // Act
        var (start, calls) = await source.FindCallees();

        // Assert
        var call = calls[start].ShouldHaveSingleItem();
        call.Target.ContainingType.Name.ShouldBe("Example");
    }

    [Theory]
    [InlineData("service.Run(); Run();")]
    [InlineData("Run(); service.Run();")]
    public async Task PreferDirectCallsOverAbstractDispatch(string body)
    {
        // Arrange
        var source = $$"""
            abstract class Service { public abstract void Run(); }
            class Example : Service
            {
                public override void Run() { }
                void Start(Service service) { {{body}} }
            }
            """;

        // Act
        var (start, calls) = await source.FindCallees();

        // Assert
        var call = calls[start].ShouldHaveSingleItem();
        call.LinkKind.ShouldBe(LinkKind.Direct);
    }

    [Fact]
    public async Task FollowVirtualMemberImplementations()
    {
        // Arrange
        const string source = """
            class Service { public virtual void Run() { } }
            class Example : Service
            {
                public override void Run() { }
                void Start(Service service) { service.Run(); }
            }
            """;

        // Act
        var (start, calls) = await source.FindCallees();

        // Assert
        calls[start]
            .ShouldContain(call => call.Target.ContainingType.Name == "Service" || call.LinkKind == LinkKind.Direct);
        calls[start]
            .ShouldContain(call => call.Target.ContainingType.Name == "Example" || call.LinkKind == LinkKind.Abstract);
    }

    [Fact]
    public async Task NotFollowVirtualMemberImplementation_WhenOverrideIsCalledDirectly()
    {
        // Arrange
        const string source = """
            class Service { public virtual void Run() { } }
            class Example : Service
            {
                public override void Run() { }
                void Start() { Run(); }
            }
            """;

        // Act
        var (start, calls) = await source.FindCallees();

        // Assert
        var call = calls[start].ShouldHaveSingleItem();
        call.Target.ContainingType.Name.ShouldBe("Example");
        call.LinkKind.ShouldBe(LinkKind.Direct);
    }

    [Theory]
    [InlineData("new Service()")]
    [InlineData("new()")]
    public async Task FollowConstructorsAndTheirMethodCalls(string creation)
    {
        // Arrange
        var source = $$"""
            class Service
            {
                public Service() { Initialize(); }
                void Initialize() { }
            }
            class Example
            {
                void Start() { Service service = {{creation}}; }
            }
            """;

        // Act
        var (start, calls) = await source.FindCallees();

        // Assert
        var constructor = calls[start].ShouldHaveSingleItem();
        constructor.Target.ShouldBeAssignableTo<IMethodSymbol>().MethodKind.ShouldBe(MethodKind.Constructor);
        constructor.LinkKind.ShouldBe(LinkKind.Direct);
        calls[constructor.Target].ShouldHaveSingleItem().Target.Name.ShouldBe("Initialize");
    }

    [Theory]
    [InlineData("this")]
    [InlineData("base")]
    public async Task FollowChainedConstructors(string initializer)
    {
        // Arrange
        var source = $$"""
            class Parent
            {
                public Parent() { }
                public Parent(int value) { }
            }
            class Service : Parent
            {
                public Service() : {{initializer}}(1) { }
                public Service(int value) { }
            }
            class Example
            {
                void Start() { _ = new Service(); }
            }
            """;

        // Act
        var (start, calls) = await source.FindCallees();

        // Assert
        var constructor = calls[start].ShouldHaveSingleItem();
        var chained = calls[constructor.Target].ShouldHaveSingleItem();
        var method = chained.Target.ShouldBeAssignableTo<IMethodSymbol>();
        method.MethodKind.ShouldBe(MethodKind.Constructor);
        method.Parameters.ShouldHaveSingleItem().Type.SpecialType.ShouldBe(SpecialType.System_Int32);
        method.ContainingType.Name.ShouldBe(initializer is "this" ? "Service" : "Parent");
        chained.LinkKind.ShouldBe(LinkKind.Direct);
    }

    [Fact]
    public async Task IgnoreConstructorsWithoutSourceDeclarations()
    {
        // Arrange
        const string source = """
            class Service { }
            class Example
            {
                void Start() { _ = new Service(); _ = new object(); }
            }
            """;

        // Act
        var (start, calls) = await source.FindCallees();

        // Assert
        calls[start].ShouldBeEmpty();
    }
}