enable and fix a number of lints

Author: kevmoo

analysis_options.yaml

@@ -13,19 +13,23 @@ analyzer:
 linter:
   rules:
     - avoid_bool_literals_in_conditional_expressions
+    - avoid_catching_errors
     - avoid_classes_with_only_static_members
     - avoid_function_literals_in_foreach_calls
+    - avoid_private_typedef_functions
+    - avoid_redundant_argument_values
     - avoid_renaming_method_parameters
     - avoid_returning_null
     - avoid_returning_null_for_future
     - avoid_returning_null_for_void
     - avoid_returning_this
     - avoid_single_cascade_in_expression_statements
     - avoid_unused_constructor_parameters
+    - avoid_void_async
     - await_only_futures
     - camel_case_types
     - cancel_subscriptions
-    #- cascade_invocations
+    - cascade_invocations
     - comment_references
     - constant_identifier_names
     - control_flow_in_finally
@@ -37,28 +41,44 @@ linter:
     - invariant_booleans
     - iterable_contains_unrelated_type
     - join_return_with_assignment
+    - lines_longer_than_80_chars
     - list_remove_unrelated_type
     - literal_only_boolean_expressions
+    - missing_whitespace_between_adjacent_strings
     - no_adjacent_strings_in_list
+    - no_runtimeType_toString
     - non_constant_identifier_names
     - only_throw_errors
     - overridden_fields
     - package_api_docs
     - package_names
     - package_prefixed_library_names
+    - prefer_asserts_in_initializer_lists
     - prefer_const_constructors
-    #- prefer_final_locals
+    - prefer_const_declarations
+    - prefer_expression_function_bodies
+    - prefer_final_locals
+    - prefer_function_declarations_over_variables
     - prefer_initializing_formals
+    - prefer_inlined_adds
     - prefer_interpolation_to_compose_strings
+    - prefer_is_not_operator
     - prefer_null_aware_operators
+    - prefer_relative_imports
     - prefer_typing_uninitialized_variables
+    - prefer_void_to_null
+    - provide_deprecation_message
+    - sort_pub_dependencies
     - test_types_in_equals
     - throw_in_finally
     - unnecessary_await_in_return
     - unnecessary_brace_in_string_interps
     - unnecessary_getters_setters
     - unnecessary_lambdas
     - unnecessary_null_aware_assignments
+    - unnecessary_overrides
     - unnecessary_parenthesis
     - unnecessary_statements
+    - unnecessary_string_interpolations
+    - use_string_buffers
     - void_checks

lib/http_retry.dart

@@ -48,20 +48,21 @@ class RetryClient extends BaseClient {
   /// the client has a chance to perform side effects like logging. The
   /// `response` parameter will be null if the request was retried due to an
   /// error for which [whenError] returned `true`.
-  RetryClient(this._inner,
-      {int retries,
-      bool when(BaseResponse response),
-      bool whenError(error, StackTrace stackTrace),
-      Duration delay(int retryCount),
-      void onRetry(BaseRequest request, BaseResponse response, int retryCount)})
-      : _retries = retries ?? 3,
+  RetryClient(
+    this._inner, {
+    int retries,
+    bool Function(BaseResponse) when,
+    bool Function(Object, StackTrace) whenError,
+    Duration Function(int retryCount) delay,
+    void Function(BaseRequest, BaseResponse, int retryCount) onRetry,
+  })  : _retries = retries ?? 3,
         _when = when ?? ((response) => response.statusCode == 503),
         _whenError = whenError ?? ((_, __) => false),
         _delay = delay ??
             ((retryCount) =>
-                Duration(milliseconds: 500) * math.pow(1.5, retryCount)),
+                const Duration(milliseconds: 500) * math.pow(1.5, retryCount)),
         _onRetry = onRetry {
-    RangeError.checkNotNegative(_retries, "retries");
+    RangeError.checkNotNegative(_retries, 'retries');
   }
 
   /// Like [new RetryClient], but with a pre-computed list of [delays]
@@ -70,27 +71,38 @@ class RetryClient extends BaseClient {
   /// This will retry a request at most `delays.length` times, using each delay
   /// in order. It will wait for `delays[0]` after the initial request,
   /// `delays[1]` after the first retry, and so on.
-  RetryClient.withDelays(Client inner, Iterable<Duration> delays,
-      {bool when(BaseResponse response),
-      bool whenError(error, StackTrace stackTrace),
-      void onRetry(BaseRequest request, BaseResponse response, int retryCount)})
-      : this._withDelays(inner, delays.toList(),
-            when: when, whenError: whenError, onRetry: onRetry);
-
-  RetryClient._withDelays(Client inner, List<Duration> delays,
-      {bool when(BaseResponse response),
-      bool whenError(error, StackTrace stackTrace),
-      void onRetry(BaseRequest request, BaseResponse response, int retryCount)})
-      : this(inner,
-            retries: delays.length,
-            delay: (retryCount) => delays[retryCount],
-            when: when,
-            whenError: whenError,
-            onRetry: onRetry);
+  RetryClient.withDelays(
+    Client inner,
+    Iterable<Duration> delays, {
+    bool Function(BaseResponse) when,
+    bool Function(Object, StackTrace) whenError,
+    void Function(BaseRequest, BaseResponse, int retryCount) onRetry,
+  }) : this._withDelays(
+          inner,
+          delays.toList(),
+          when: when,
+          whenError: whenError,
+          onRetry: onRetry,
+        );
+
+  RetryClient._withDelays(
+    Client inner,
+    List<Duration> delays, {
+    bool Function(BaseResponse) when,
+    bool Function(Object, StackTrace) whenError,
+    void Function(BaseRequest, BaseResponse, int) onRetry,
+  }) : this(
+          inner,
+          retries: delays.length,
+          delay: (retryCount) => delays[retryCount],
+          when: when,
+          whenError: whenError,
+          onRetry: onRetry,
+        );
 
   @override
   Future<StreamedResponse> send(BaseRequest request) async {
-    var splitter = StreamSplitter(request.finalize());
+    final splitter = StreamSplitter(request.finalize());
 
     var i = 0;
     for (;;) {
@@ -117,12 +129,12 @@ class RetryClient extends BaseClient {
 
   /// Returns a copy of [original] with the given [body].
   StreamedRequest _copyRequest(BaseRequest original, Stream<List<int>> body) {
-    var request = StreamedRequest(original.method, original.url);
-    request.contentLength = original.contentLength;
-    request.followRedirects = original.followRedirects;
-    request.headers.addAll(original.headers);
-    request.maxRedirects = original.maxRedirects;
-    request.persistentConnection = original.persistentConnection;
+    final request = StreamedRequest(original.method, original.url)
+      ..contentLength = original.contentLength
+      ..followRedirects = original.followRedirects
+      ..headers.addAll(original.headers)
+      ..maxRedirects = original.maxRedirects
+      ..persistentConnection = original.persistentConnection;
 
     body.listen(request.sink.add,
         onError: request.sink.addError,