Why does this code lead to a deadlock?

Question

The following code is meant to copy files asynchronously but it causes deadlock in my app. It uses a task combinator helper method called 'Interleaved(..)' found here to return tasks in the order they complete.

public static async Task<List<StorageFile>> CopyFiles_CAUSES_DEADLOCK(IEnumerable<StorageFile> sourceFiles, IProgress<int> progress, StorageFolder destinationFolder)
{
    List<StorageFile> copiedFiles = new List<StorageFile>();
    List<Task<StorageFile>> copyTasks = new List<Task<StorageFile>>();

    foreach (var file in sourceFiles)
    {
        // Create the copy tasks and add to list
        var copyTask = file.CopyAsync(destinationFolder, Guid.NewGuid().ToString()).AsTask();
        copyTasks.Add(copyTask);
    }

    // Serve up each task as it completes
    foreach (var bucket in Interleaved(copyTasks))
    {
        var copyTask = await bucket;
        var copiedFile = await copyTask;
        copiedFiles.Add(copiedFile);
        progress.Report((int)((double)copiedFiles.Count / sourceFiles.Count() * 100.0));
    }

    return copiedFiles;
}

I originally created a simpler 'CopyFiles(...)' which processes the tasks in the order they were supplied (as opposed to completed) and this works fine, but I can't figure out why this one deadlocks frequently. Particularly, when there are many files to process.

Here is the simpler 'CopyFiles' code that works:

public static async Task<List<StorageFile>> CopyFiles_RUNS_OK(IEnumerable<StorageFile> sourceFiles, IProgress<int> progress, StorageFolder destinationFolder)
{
    List<StorageFile> copiedFiles = new List<StorageFile>();
    int sourceFilesCount = sourceFiles.Count();

    List<Task<StorageFile>> tasks = new List<Task<StorageFile>>();
    foreach (var file in sourceFiles)
    {
        // Create the copy tasks and add to list
        var copiedFile = await file.CopyAsync(destinationFolder, Guid.NewGuid().ToString()).AsTask();
        copiedFiles.Add(copiedFile);
        progress.Report((int)((double)copiedFiles.Count / sourceFilesCount *100.0));
    }

    return copiedFiles;
}

EDIT:

In an attempt to find out what's going on I've changed the implementation of CopyFiles(...) to use TPL Dataflow. I am aware that this code will return items in the order they were supplied, which is not what I want, but it removes the Interleaved dependency as a start. Anyway, despite this the app still hangs. It seems as if it's not returning from the file.CopyAsync(..) call. There is of course the possibility I'm just doing something wrong here.

public static async Task<List<StorageFile>> CopyFiles_CAUSES_HANGING_ALSO(IEnumerable<StorageFile> sourceFiles, IProgress<int> progress, StorageFolder destinationFolder)
{
    int sourceFilesCount = sourceFiles.Count();
    List<StorageFile> copiedFiles = new List<StorageFile>();

    // Store for input files.
    BufferBlock<StorageFile> inputFiles = new BufferBlock<StorageFile>();
    // 
    Func<StorageFile, Task<StorageFile>> copyFunc = sf => sf.CopyAsync(destinationFolder, Guid.NewGuid().ToString()).AsTask();
    TransformBlock<StorageFile, Task<StorageFile>> copyFilesBlock = new TransformBlock<StorageFile, Task<StorageFile>>(copyFunc);

    inputFiles.LinkTo(copyFilesBlock, new DataflowLinkOptions() { PropagateCompletion = true });

    foreach (var file in sourceFiles)
    {
        inputFiles.Post(file);
    }
    inputFiles.Complete();

    while (await copyFilesBlock.OutputAvailableAsync())
    {
        Task<StorageFile> file = await copyFilesBlock.ReceiveAsync();
        copiedFiles.Add(await file);
        progress.Report((int)((double)copiedFiles.Count / sourceFilesCount * 100.0));
    }
    copyFilesBlock.Completion.Wait();

    return copiedFiles;
}

Many thanks in advance for any help.