Strong mode generics - how to apply correctly

[zoechi]

The code below produces a few errors I don't know how to fix.

UnmodifiableListView<int> _ioServiceBytesRecursive;

_ioServiceBytesRecursive = toUnmodifiableListView /*<int>*/ (json['io_service_bytes_recursive'] as Iterable);
//  WARNING: toUnmodifiableListView<int>(json['io_service_bytes_recursive'] as Iterable) (UnmodifiableListView<dynamic>) will need runtime check to cast to type UnmodifiableListView<int> ([bwu_docker] lib/src/shared/data_structures.dart:138)
...

UnmodifiableListView /*<T>*/ toUnmodifiableListView /*<T>*/ (Iterable list) {
  if (list == null) {
    return null;
  }
  if (list.length == 0) {
    return new UnmodifiableListView<dynamic /*=T*/ >(<dynamic /*=T*/ >[]);
  }

  return new UnmodifiableListView<dynamic /*=T*/ >(
      list.map /*<T>*/ ((dynamic e) {
    if (e is Map) {
      return toUnmodifiableMapView(e) as dynamic /*=T*/; 
// ERROR: Type check failed: toUnmodifiableMapView(e) as T (T) is not of type T ([bwu_docker] lib/src/shared/json_util.dart:143)
// WARNING: The return type 'T (/home/myuser/dart/bwu_docker/lib/src/shared/json_util.dart)' is not a 'T (/usr/local/apps/dart/dart-sdk/lib/core/iterable.dart)', as defined by the method '' ([bwu_docker] lib/src/shared/json_util.dart:143)

    } else if (e is List) {
      return toUnmodifiableListView (e) as dynamic /*=T*/;
// WARNING: The return type 'T (/home/myuser/dart/bwu_docker/lib/src/shared/json_util.dart)' is not a 'T (/usr/local/apps/dart/dart-sdk/lib/core/iterable.dart)', as defined by the method '' ([bwu_docker] lib/src/shared/json_util.dart:145)
// ERROR: Type check failed: toUnmodifiableListView(e) as T (T) is not of type T ([bwu_docker] lib/src/shared/json_util.dart:145)

    } else {
      return e as dynamic /*=T*/;
// WARNING: The return type 'T (/home/myuser/dart/bwu_docker/lib/src/shared/json_util.dart)' is not a 'T (/usr/local/apps/dart/dart-sdk/lib/core/iterable.dart)', as defined by the method '' ([bwu_docker] lib/src/shared/json_util.dart:147)
// ERROR: Type check failed: e as T (T) is not of type T ([bwu_docker] lib/src/shared/json_util.dart:147)
    }
  }));
}

Am I doing something wrong or is this not yet supported?

Related to

• Analyzer complains about error in comment #24985
• Lots of new strong-mode hints related to generic functions #25040 (Lots of new strong-mode hints related to generic functions #25040 (comment))

[leafpetersen]

Explicitly instantiation of generic parameters doesn't work yet. @jmesserly is hard at work getting this in place. I believe that if you make the cast in the first line be to Iterable<int>, then upwards inference will infer the parameter type for you (amusingly we support inference before we support explicit instantiation).

I'm looking into the errors within the body of toUnmodifiableListView. Just one informational comment: by typing e explicitly as dynamic you are disabling inference for it. If you want it to be typed, you should either leave the type off of it, or else use dynamic/*=T*/ e.

[leafpetersen]

Ok, the issue in the body of the method is the same - no explicit instantiation yet. The error message is confusing because the type parameter to the method (T) is named the same as the type parameter to the map method. If you change your type parameter to S, you'll see a clearer warning. The error message is bad, we need to fix - I think we should be giving it in terms of dynamic, rather than in terms of an uninstantiated type variable.

You can fix this in the short term by pulling the closure argument out into a local function with an explicit return type: this will allow inference to fill in the type on list.map for you.

Also, disregard my comment above about the closure parameter - I misunderstood the types on first read, and presumably you want that to be explicitly dynamic.

[leafpetersen]

Short reproduction case of the issues to be fixed (besides supporting explicit instantiation):

void foo() {
  List list = null;

  // [warning] e (dynamic) will need runtime check to cast to type T
  list.map((e) => e);

  // [hint] The argument type '(dynamic) → T' cannot be assigned to the parameter type '(dynamic) → int'
  list.map((e) => 3);
}

The first one suggests that we are either not fully resolving, or are resolving too late, after we instantiate list.map with dynamic and are not getting rid of all uses of the type parameter.

The second is just a hint, and suggests that there is propagated type information that is not getting updated correctly when we infer a resolved type.

[jmesserly]

Ah ha. Think I know what's going on here. Upward inference runs too late, so downward inference (as well as the existing propagatedType inference for lambdas) sees the uninstantiated generic type on the generic method.

My explicit instantiation fix will include a fix for this. Early on, the unknown generic types will be "dynamic".

[jmesserly]

https://codereview.chromium.org/1504483002/