proposal: type_local_variable_instead_of_casting

[srawlins]

type_local_variable_instead_of_casting

Please respond with a better name if you have one. prefer_type_annotation_over_cast?

Description

This rule encourages one to "cast" (generally upcast) an expression in a new local variable via the variable's declaration rather than an as-expression. I hope that's crystal clear :)

Details

Sometimes an expression is upcast via as, such as:

var bar = foo.map((e) => e.toString()).toList() as Iterable<String>;
if (iterable.isEmpty) bar = someIterable;

// or
var x = [1, 2, 3] as List<num>;
x.add(0.5);

Errors would arise if either cast were removed. However, we could make the code more idiomatic by casting with the variable's declaration (side-stepping inference):

Iterable<String> bar = foo.map((e) => e.toString()).toList();
if (iterable.isEmpty) bar = someIterable;

// or
List<num> x = [1, 2, 3];
x.add(0.5);

This arises from lots of discussion in #48984, and examples in #44411, #49269, and #49550.

Kind

Style.

Discussion

See discussion at #48984.

Discussion checklist

• List any existing rules this proposal modifies, complements, overlaps or conflicts with.
• List any relevant issues (reported here, the SDK Tracker, or elsewhere).
• If there's any prior art (e.g., in other linters), please add references here.
• If this proposal corresponds to Effective Dart or Flutter Style Guide advice, please call it out. (If there isn't any corresponding advice, should there be?)
• If this proposal is motivated by real-world examples, please provide as many details as you can. Demonstrating potential impact is especially valuable.

[eernstg]

I like the

(generally upcast)

part, because this presumably means that we would lint the following bug as well:

var bar = foo.map((e) => e.toString()).toList() as Iterable<int>; // Oops, will throw.

because we're linting the syntactic pattern var v = e as T;, not just the situation where e as T is an upcast.

[lrhn]

Naming: prefer_variable_type_for_upcast.

It won't work for a downcast anyway, except from dynamic, and then it doesn't matter which version you use, it's either an explicit or implicit as cast. (I guess dart2js omits the implicit cast, but I wouldn't push the user in either direction then, since they might want to control whether there is a runtime check or not.)