CancelableOperation.isCompleted is True Before Future Completes

[todbachman-wf]

CancelableOperation.isCompleted returns true immediately after constructing the operation even if the future it was constructed with hasn't resolved. This was unexpected to me, and I assume this is not the intended behavior. Below is a little unit test that demonstrates the problem. The expectation on the final line of the test fails, though I would expect it to succeed.

import 'dart:async';

import 'package:async/async.dart';
import 'package:test/test.dart';

void main() {
  group('CancelableOperation', () {
    test('isComplete should be false before completed', () {
      var completer = Completer<void>();
      var operation = CancelableOperation.fromFuture(completer.future);
      expect(operation.isCompleted, isFalse);
    });
  });
}

[natebosch]

This is a little interesting, we're in a way inheriting this behavior from Completer, check out the following:

var outer = Completer<void>();
print(outer.completed); // false, as expected
var inner = Completer<void>();
outer.complete(inner);
print(outer.completed); // true, surprising but documented

I don't know if we have a great solution here, in a way we'd want the fromFuture constructor to have different behavior than the CancellableCompleter.operation, but I'm not sure if that is a great idea.

cc @lrhn - do you have any thoughts on the right semantics?

[lrhn]

The completed boolean flag is related to the Completer, not the Future that it completes. It's only there so you can check whether it's safe to call complete. It becomes true the moment you call complete which is always earlier than when the future actually notifies any listeners.

I'm guessing the CancellableCompleter should have similar behavior, because the flag is there for the same reason. You could argue that it should be named canComplete instead, but it isn't.

There is deliberately no way to tell if a future has been completed with a value or error except asynchronously asking for that value or error (then/catchError/whenComplete or await).
That discourages any attempt to have a synchronous side-channel on inherently asynchronous results (if a Future<Null> or Future<void> has been completed, and you know it's not going to be an error, you don't really need to ask for the value).