private IEnumerable Resolve()

in plugin-dotnet-agent/src/main/csharp/TeamCity.Dotnet.TestSuppressor/TeamCity.Dotnet.TestSuppressor/Domain/Targeting/TargetResolver.cs [31:97]
54 lines of code
11 McCabe index (conditional complexity)

    private IEnumerable<IFileInfo> Resolve(string target, ICollection<string> resolvedTargets)
    {
        _logger.LogInformation("Resolving target: {Target}", target);
        
        var originalTargetPathResult = _fileSystem.TryGetFileSystemInfo(target);
        if (originalTargetPathResult.IsError)
        {
            _logger.LogError(originalTargetPathResult.ErrorValue, "Target not available: {Target}", target);
            throw new FileNotFoundException($"Target '{target}' not available");
        }

        var originalTargetPath = originalTargetPathResult.Value;

        var supposedTargetType = SpeculateTargetType(originalTargetPath);

        // if target is an assembly, we can process once and return it right away
        if (supposedTargetType == TargetType.Assembly)
        {
            foreach (var (resolvedAssembly, _) in AssemblyStrategy.Resolve(originalTargetPath.FullName))
            {
                MarkTargetAsResolved(resolvedTargets, resolvedAssembly);
                yield return (IFileInfo) resolvedAssembly;
            }
            yield break;
        }

        // if target is not an assembly, resolve all targets in the hierarchy using BFS
        var queue = new Queue<(IFileSystemInfo, TargetType)>();
        
        queue.Enqueue((originalTargetPath, supposedTargetType));
        while (queue.Count != 0)
        {
            var (currentTarget, targetType) = queue.Dequeue();
            if (IsAlreadyResolved(resolvedTargets, currentTarget))
            {
                continue;
            }
            
            if (!_strategies.TryGetValue(targetType, out var strategy))
            {
                _logger.LogError("No target resolution strategy for target type: {TargetType}", targetType);
                continue;
            }

            foreach (var (resolvedTargetFile, resolvedTargetType) in strategy.Resolve(currentTarget.FullName))
            {
                if (resolvedTargetType == TargetType.Assembly)
                {
                    if (IsAlreadyResolved(resolvedTargets, resolvedTargetFile))
                    {
                        continue;
                    }
                    
                    foreach (var (resolvedAssembly, _) in AssemblyStrategy.Resolve(resolvedTargetFile.FullName))
                    {
                        MarkTargetAsResolved(resolvedTargets, resolvedAssembly);
                        yield return (IFileInfo) resolvedAssembly;
                    }
                    continue;
                }
                
                queue.Enqueue((resolvedTargetFile, resolvedTargetType));
            }
            
            MarkTargetAsResolved(resolvedTargets, currentTarget);
        }
    }