Issues with void

[peter-ahe-google]

As I'm working on dart-lang/sdk#30470, I've found some issues in dartdoc that I'd like to get updated into the SDK:

diff --git a/lib/src/io_utils.dart b/lib/src/io_utils.dart
index 5b2c3455..fb8fdf93 100644
--- a/lib/src/io_utils.dart
+++ b/lib/src/io_utils.dart
@@ -88,7 +88,7 @@ class MultiFutureTracker<T> {
   }
 
   /// Wait until fewer or equal to this many Futures are outstanding.
-  void _waitUntil(int max) async {
+  Future<void> _waitUntil(int max) async {
     while (_queue.length > max) {
       await Future.any(_queue);
     }
diff --git a/lib/src/model.dart b/lib/src/model.dart
index 530a9d6b..33c274ed 100644
--- a/lib/src/model.dart
+++ b/lib/src/model.dart
@@ -5747,7 +5747,9 @@ class PackageBuilder {
       }
     } while (!lastPass.containsAll(current));
 
-    await logAnalysisErrors(originalSources);
+    // TODO(jcollins): Determine if await is necessary, if so, change the
+    // return type of [logAnalysisErrors] to `Future<void>`.
+    await (logAnalysisErrors(originalSources) as dynamic);
     return libraries.toList();
   }
 

[jcollins-g]

@peter-ahe-google :

1. does an async method with declared return type foo no longer automatically imply that the return type is Future<foo> ? Or, is void special in some way here?
2. Dartdoc is doing something really evil here by accident, overriding a synchronous function with an asynchronous one in a subclass. Is it your intention (immediately or longer term) to no longer allow that? I'm totally OK with doing that, just wondering.

[jcollins-g]

we can move to P1 or possibly even P0 if this is blocking something for Dart 2 stable.

[peter-ahe-google]

Re 1. I don't think an async function has ever had its return type wrapped in Future. There is something like that for local functions.

For example:

final f = () async { return 1; };
b() async { return 1; }

main() {
  final localF = () async { return 1; };
  localB() async { return 1; }
}

Compiles to:

library;
import self as self;
import "dart:async" as asy;
import "dart:core" as core;

static final field () → asy::Future<core::int> f = () → asy::Future<core::int> async {
  return 1;
};
static method b() → dynamic async {
  return 1;
}
static method main() → dynamic {
  final () → asy::Future<core::int> localF = () → asy::Future<core::int> async {
    return 1;
  };
  function localB() → asy::Future<core::int> async {
    return 1;
  }
}

Notice how localB and top-level b have different types.

Re 2. I think the "evil" stuff will continue to work (but @leafpetersen would be a better judge of that). "void" is supertype of all types (but with a metric ton of exceptions). It can be argued that this is type safe, as it is always safe to override "I don't return anything" with "I return something". The problem is that async is that it kinda means: "don't ignore what I return" and void means: "ignore what I return".

[peter-ahe-google]

P2 is fine, this is no longer blocking Dart 2 stable. However, you won't get any new void errors in these two files as my work around is to ignore all void errors in them (with hard-coded paths). I agree this is a code health issue.

[jcollins-g]

This is broken in dev.69.1. I had thought it wasn't actually going to break at runtime, but since it does, elevating priority.