File operations hang forever after opening unrelated named pipe about sdk HOT 3 OPEN

import 'dart:async';
import 'dart:io';

final Stopwatch sw = Stopwatch();
void log(String text) {
  var e = sw.elapsedMilliseconds;
  print("(${"$e".padLeft(3)}): $text");
}

// Args[0] is number of temporary files.
// 45+: One undeleted file
//   - 60: No undeleted files
// 78+: Two undeleted files
//   - 89, 108: Stalls in `list`
// 109+: Three undeleted files
//   - 121, 124: Stalls in `list`
// 140+: Four undeleted files
//   - 152, 153: Stalls in `list`
// 172+: Five undeleted files
//   - 184, 185: Stalls in `list`
// 204+: Six undeleted files
void main(List<String> args) async {
  // Safety wrapper around real main, to catch uncaught errors
  // and exit if stalled.
  var exitCode = await runZonedGuarded(() => _main(args), (e, s) {
    log("Uncaught error: $e\n$s");
  }, zoneValues: {#_ez: "Own error zone"})!
      .timeout(Duration(milliseconds: 500), onTimeout: () {
    log("Stalled, exiting");
    throw exit(0);
  });
  exit(exitCode);
}

Future<int> _main(List<String> args) async {
  var exitCode = 0;
  var fileCount = 45;
  if (args.isNotEmpty) fileCount = int.tryParse(args.first) ?? fileCount;

  sw.start();

  log("Creating named pipe or file");
  final (pipeDir, fifo) = await createNamedPipe();
  log("Listen to named pipe or file");

  final openRead = fifo.openRead().listen((v) {
    log("FIFO EVENT: $v");
  }, onError: (e, s) {
    log("FIFO ERROR: $e");
  }, onDone: () {
    log("FIFO DONE");
  });
  final openWrite = await fifo.openWrite(mode: FileMode.write);

  final dir = await createTmpFiles(fileCount);

  try {
    await deleteFiles(dir, fileCount);
  } on ParallelWaitError<List<void>, List<Object?>> catch (e) {
    exitCode = 1;
    log('Timeout while deleting files: ${e.errors.nonNulls.length}');
    var errors = e.errors;
    for (var i = 0; i < errors.length; i++) {
      var error = errors[i];
      if (error != null) print("     : Caught error #$i: ${error}");
    }
    for (var entity in dir.listSync()) {
      log("Surviving file: ${entity.path}");
    }
  } catch (e) {
    exitCode = 1;
    log("Unexpected error: $e");
  } finally {
    log("Deleting temporary file directory");
    try {
      await dir.delete(recursive: true);
      log("Deleted directory");
      if (dir.existsSync()) print("   Not successfully?");
    } catch (e) {
      log("Unexpected error: $e");
    }
  }
  log("Cancelling subscription");

  openWrite.close();
  await (openRead.cancel());
  log("Subscription cancelled");
  await pipeDir.delete(recursive: true);
  log("Pipe directory deleted");
  return exitCode;
}

Future<(Directory, File)> createNamedPipe() async {
  final dir = await Directory.systemTemp.createTemp();
  var fifo = File('${dir.path}/fifo');
  await Process.run('mkfifo', [fifo.path]);
  print("CREATED FIFO: ${fifo.path}");
  return (dir, fifo);
}

Future<Directory> createTmpFiles(int count) async {
  log("Creating temporary files");
  final dir = await Directory.systemTemp.createTemp();
  log("Created temporary file directory: ${dir.path}");
  for (var i = 0; i < count; i++) {
    var file = File('${dir.path}/file${"$i".padLeft(4, "0")}');
    await file.create();
    log("Created file: ${file.path}");
  }
  log("Created temporary files");
  return dir;
}

Future<void> deleteFiles(Directory dir, int fileCount,
    [int timeout = 200]) async {
  var t0 = sw.elapsedMilliseconds;
  log("Deleting temporary files");
  List<Future<void>> futures = [];
  var dur = Duration(milliseconds: timeout);
  log("Listing temporary files");
  int i = 0;
  int completed = 0;
  await for (var entity in dir.list()) {
    if (entity is File) {
      var index = i++;
      log("Deleting #$index: ${entity.path}");
      var e0 = sw.elapsedMilliseconds - t0;
      if (e0 > timeout) log("Still listing files after $e0 ms");
      futures.add(
        entity.delete().then((v) {
          completed++;
          var e1 = sw.elapsedMilliseconds - t0;
          log("Deleted #$index: ${entity.path}${e1 > timeout ? " too late($e1)" : ""}");
          return v;
        }).timeout(dur, onTimeout: () {
          var e2 = sw.elapsedMilliseconds - t0;
          log("Timeout deleting file #$index of $fileCount: ${entity.path} after $e2 ms");
          var zone = Zone.current[#_ez] ??
              (identical(Zone.current, Zone.root) ? "Root" : "Unknown");
          throw TimeoutException(
              "in $zone: Deleting file #$index of $fileCount: ${entity.path}");
        })
          ..ignore(),
      );
    }
  }
  log("All deletes initiated, $completed of $i already complete.");
  await futures.wait;
  log("Done deleting temporary files");
}