Deprecate TypeSafeWrappers?

[matanlurey]

... given that Dart 2 does this out of the box?

Here's what public APIs package offers today:

• DelegatingIterable.typed
• DelegatingList.typed
• DelegatingMap.typed
• DelegatingQueue.typed
• DelegatingSet.typed

Here's an example of the implementation of those static methods:

https://github.com/dart-lang/collection/blob/fac9e50be7e61819e66abfd6381d55135b8751d3/lib/src/wrappers.dart#L148-L149

I imagine to avoid churn, we could do the following:

• Add a package-internal field called isStrongMode:

final bool isStrongMode = (() {
  bool typeParamIsString<T>(T item) => T == String;
  return typeParamIsString('');
})();

• Change the .typed methods to be:

static List<E> typed<E>(List base) {
  if (isStrongMode) {
    return base.cast<E>();
  }
  return base is List<E> ? base : new TypeSafeList<E>(base);
}

• When Dart 2 is enabled by default everywhere (Dart2JS/VM/Flutter), remove the TypeSafeX wrapper classes, as they will never be used. This should not be a breaking change, strictly.

• At the same time of above, deprecate the .typed methods, because they no longer have value and are misleading, doing is and .cast is fine for all users at this point.

Thoughts? @lrhn @srawlins @kevmoo

[nex3]

As long as we're only supporting Dart 2 (which appears to be the case based on the current pubspec), we can do this much more simply by just using cast() everywhere and deleting the TypeSafe wrappers.

[matanlurey]

Definitely, I just am trying to be nice to users - in my own tests it looks like the type of errors thrown by Dart2 versus thrown currently by the wrappers are not exactly the same.

[nex3]

How much does that buy us in practice? I don't see how code could ever actually construct a TypeSafeList with your proposed intermediate implementation.

[matanlurey]

Until the VM and Dart2JS enforce strong mode, strong-mode typed lists will not throw. So you could potentially be using .typed for safety, and it throws in DDC but not Dart2JS.

[nex3]

But if dart2js isn't using strong mode semantics, then base is List<E> will always be true (because <E> is erased) and nothing will throw anyway.