avoid_annotating_with_dynamic and new typedef

[dotdoom]

I'm struggling to make an otherwise useful avoid_annotating_with_dynamic work with my typedef:

typedef CallbackWithParameter = Future<void> Function(dynamic);
// or
typedef CallbackWithParameter = Future<void> Function(dynamic parameter);

both are syntactically valid, but none satisfies this lint check. Templatizing CallbackWithParameter fixes this, but it's not exactly what I'm looking for. Is this check incompatible with the new typedefs?

[bwilkerson]

Is this check incompatible with the new typedefs?

I don't think so. In both cases you're annotating that the parameter to the function has the type dynamic, which is what the rule is intended to catch. It's possible that this example is one of the places where you'd like to explicitly use dynamic (in which case an 'ignore' comment might be necessary). It's also possible that what you're trying to say is that the parameter is allowed to be any Object. But at this point I'm only guessing at possible solutions.

[dotdoom]

Depending on what the purpose of linter is, an 'ignore' comment may be the right solution. I'm not trying to dispute it though, because I'm new to Dart and even more to the linter.

What I want to say is, contrary to this check description, dynamic is not assumed here by Dart, like e.g. in function parameters, and is required by syntax if the intent is to have a dynamic argument type.

If the purpose of this check is to discourage the use of dynamic, perhaps the description should be rephrased.

[bwilkerson]

Depending on what the purpose of linter is ...

The purpose of the linter is to help users catch code patterns that, while valid Dart, they would prefer to not have in their code base. Sometimes those patterns are purely a matter of preference, sometimes they help avoid errors in the code.

... contrary to this check description, dynamic is not assumed here by Dart ...

You're right. I now think the rule has a bug in that it fails to allow for the generic function type syntax.

[srawlins]

I think @dotdoom is correct here. The lint rule says to not type dynamic when a type is implicitly dynamic. We can write:

typedef CallbackWithParameter = Future<void> Function(dynamic);
// or
typedef CallbackWithParameter = Future<void> Function(dynamic parameter);

but we cannot write

typedef CallbackWithParameter = Future<void> Function(parameter);

(unlike in a function-typed parameter), so the the lint should not report this, as there is no implicit dynamic in function types.