cleanup: enable and fix a number of lints

Author: kevmoo

analysis_options.yaml

@@ -1,2 +1,78 @@
 analyzer:
   strong-mode: true
+  errors:
+    dead_code: error
+    override_on_non_overriding_method: error
+    unused_element: error
+    unused_import: error
+    unused_local_variable: error
+linter:
+  rules:
+    - always_declare_return_types
+    #- annotate_overrides
+    - avoid_empty_else
+    - avoid_function_literals_in_foreach_calls
+    - avoid_init_to_null
+    - avoid_null_checks_in_equality_operators
+    - avoid_renaming_method_parameters
+    - avoid_return_types_on_setters
+    - avoid_returning_null
+    - avoid_types_as_parameter_names
+    - avoid_unused_constructor_parameters
+    - await_only_futures
+    - camel_case_types
+    - cancel_subscriptions
+    #- cascade_invocations
+    - comment_references
+    - constant_identifier_names
+    - control_flow_in_finally
+    - directives_ordering
+    - empty_catches
+    - empty_constructor_bodies
+    - empty_statements
+    - hash_and_equals
+    - implementation_imports
+    - invariant_booleans
+    - iterable_contains_unrelated_type
+    - library_names
+    - library_prefixes
+    - list_remove_unrelated_type
+    - literal_only_boolean_expressions
+    - no_adjacent_strings_in_list
+    - no_duplicate_case_values
+    - non_constant_identifier_names
+    - omit_local_variable_types
+    - only_throw_errors
+    - overridden_fields
+    #- package_api_docs
+    - package_names
+    - package_prefixed_library_names
+    - prefer_adjacent_string_concatenation
+    - prefer_collection_literals
+    - prefer_conditional_assignment
+    - prefer_const_constructors
+    - prefer_contains
+    - prefer_equal_for_default_values
+    - prefer_final_fields
+    - prefer_initializing_formals
+    #- prefer_interpolation_to_compose_strings
+    - prefer_is_empty
+    - prefer_is_not_empty
+    #- prefer_single_quotes
+    - prefer_typing_uninitialized_variables
+    - recursive_getters
+    - slash_for_doc_comments
+    - super_goes_last
+    - test_types_in_equals
+    - throw_in_finally
+    - type_init_formals
+    - unawaited_futures
+    - unnecessary_brace_in_string_interps
+    - unnecessary_getters_setters
+    - unnecessary_lambdas
+    - unnecessary_null_aware_assignments
+    - unnecessary_statements
+    - unnecessary_this
+    - unrelated_type_equality_checks
+    - use_rethrow_when_possible
+    - valid_regexps

lib/mirror_matchers.dart

@@ -29,8 +29,8 @@ class _HasProperty extends Matcher {
       addStateInfo(matchState, {'reason': 'has no property named "$_name"'});
       return false;
     }
-    bool isInstanceField = candidate is VariableMirror && !candidate.isStatic;
-    bool isInstanceGetter =
+    var isInstanceField = candidate is VariableMirror && !candidate.isStatic;
+    var isInstanceGetter =
         candidate is MethodMirror && candidate.isGetter && !candidate.isStatic;
     if (!(isInstanceField || isInstanceGetter)) {
       addStateInfo(matchState, {
@@ -60,14 +60,14 @@ class _HasProperty extends Matcher {
       item, Description mismatchDescription, Map matchState, bool verbose) {
     var reason = matchState == null ? null : matchState['reason'];
     if (reason != null) {
-      mismatchDescription.add(reason);
+      mismatchDescription.add(reason as String);
     } else {
       mismatchDescription
           .add('has property "$_name" with value ')
           .addDescriptionOf(matchState['value']);
       var innerDescription = new StringDescription();
-      _matcher.describeMismatch(
-          matchState['value'], innerDescription, matchState['state'], verbose);
+      _matcher.describeMismatch(matchState['value'], innerDescription,
+          matchState['state'] as Map, verbose);
       if (innerDescription.length > 0) {
         mismatchDescription.add(' which ').add(innerDescription.toString());
       }

lib/src/core_matchers.dart

@@ -86,7 +86,7 @@ class _IsNotNaN extends Matcher {
 Matcher same(expected) => new _IsSameAs(expected);
 
 class _IsSameAs extends Matcher {
-  final _expected;
+  final Object _expected;
   const _IsSameAs(this._expected);
   bool matches(item, Map matchState) => identical(item, _expected);
   // If all types were hashable we could show a hash here.
@@ -113,10 +113,11 @@ class _IsAnything extends Matcher {
 /// 'Foo', we would write:
 ///
 ///     expect(bar, new isInstanceOf<Foo>());
+// ignore: camel_case_types
 class isInstanceOf<T> extends Matcher {
   const isInstanceOf();
 
-  bool matches(obj, Map matchState) => obj is T;
+  bool matches(item, Map matchState) => item is T;
 
   Description describe(Description description) =>
       description.add('an instance of $T');
@@ -195,7 +196,7 @@ class _IsMap extends TypeMatcher {
 const Matcher isList = const _IsList();
 
 class _IsList extends TypeMatcher {
-  const _IsList() : super("List");
+  const _IsList() : super('List');
   bool matches(item, Map matchState) => item is List;
 }
 
@@ -205,7 +206,7 @@ Matcher hasLength(matcher) => new _HasLength(wrapMatcher(matcher));
 
 class _HasLength extends Matcher {
   final Matcher _matcher;
-  const _HasLength([Matcher matcher = null]) : this._matcher = matcher;
+  const _HasLength([Matcher matcher]) : this._matcher = matcher;
 
   bool matches(item, Map matchState) {
     try {
@@ -214,8 +215,10 @@ class _HasLength extends Matcher {
       if (item.length * item.length >= 0) {
         return _matcher.matches(item.length, matchState);
       }
-    } catch (e) {}
-    return false;
+    } catch (e) {
+      return false;
+    }
+    throw new UnsupportedError('Should never get here');
   }
 
   Description describe(Description description) =>
@@ -231,8 +234,10 @@ class _HasLength extends Matcher {
             .add('has length of ')
             .addDescriptionOf(item.length);
       }
-    } catch (e) {}
-    return mismatchDescription.add('has no length property');
+    } catch (e) {
+      return mismatchDescription.add('has no length property');
+    }
+    throw new UnsupportedError('Should never get here');
   }
 }
 
@@ -246,16 +251,16 @@ class _HasLength extends Matcher {
 Matcher contains(expected) => new _Contains(expected);
 
 class _Contains extends Matcher {
-  final _expected;
+  final Object _expected;
 
   const _Contains(this._expected);
 
   bool matches(item, Map matchState) {
     if (item is String) {
-      return item.indexOf(_expected) >= 0;
+      return item.contains((_expected as Pattern));
     } else if (item is Iterable) {
       if (_expected is Matcher) {
-        return item.any((e) => _expected.matches(e, matchState));
+        return item.any((e) => (_expected as Matcher).matches(e, matchState));
       } else {
         return item.contains(_expected);
       }
@@ -284,17 +289,18 @@ class _Contains extends Matcher {
 Matcher isIn(expected) => new _In(expected);
 
 class _In extends Matcher {
-  final _expected;
+  final Object _expected;
 
   const _In(this._expected);
 
   bool matches(item, Map matchState) {
-    if (_expected is String) {
-      return _expected.indexOf(item) >= 0;
-    } else if (_expected is Iterable) {
-      return _expected.any((e) => e == item);
-    } else if (_expected is Map) {
-      return _expected.containsKey(item);
+    var expected = _expected;
+    if (expected is String) {
+      return expected.contains(item as Pattern);
+    } else if (expected is Iterable) {
+      return expected.contains(item);
+    } else if (expected is Map) {
+      return expected.containsKey(item);
     }
     return false;
   }

lib/src/custom_matcher.dart

@@ -39,7 +39,7 @@ class CustomMatcher extends Matcher {
       : this._matcher = wrapMatcher(matcher);
 
   /// Override this to extract the interesting feature.
-  featureValueOf(actual) => actual;
+  Object featureValueOf(actual) => actual;
 
   bool matches(item, Map matchState) {
     try {
@@ -84,7 +84,7 @@ class CustomMatcher extends Matcher {
     var innerDescription = new StringDescription();
 
     _matcher.describeMismatch(matchState['custom.feature'], innerDescription,
-        matchState['state'], verbose);
+        matchState['state'] as Map, verbose);
 
     if (innerDescription.length > 0) {
       mismatchDescription.add(' which ').add(innerDescription.toString());

lib/src/equals_matcher.dart

@@ -16,7 +16,7 @@ import 'util.dart';
 /// handle cyclic structures a recursion depth [limit] can be provided. The
 /// default limit is 100. [Set]s will be compared order-independently.
 Matcher equals(expected, [int limit = 100]) => expected is String
-    ? new _StringEqualsMatcher(expected)
+    ? new _StringEqualsMatcher(expected) as Matcher
     : new _DeepMatcher(expected, limit);
 
 typedef _RecursiveMatcher = List<String> Function(
@@ -44,7 +44,7 @@ class _StringEqualsMatcher extends Matcher {
       buff.write('is different.');
       var escapedItem = escape(item);
       var escapedValue = escape(_value);
-      int minLength = escapedItem.length < escapedValue.length
+      var minLength = escapedItem.length < escapedValue.length
           ? escapedItem.length
           : escapedValue.length;
       var start = 0;
@@ -71,7 +71,7 @@ class _StringEqualsMatcher extends Matcher {
         _writeLeading(buff, escapedItem, start);
         _writeTrailing(buff, escapedItem, start);
         buff.write('\n          ');
-        for (int i = (start > 10 ? 14 : start); i > 0; i--) buff.write(' ');
+        for (var i = (start > 10 ? 14 : start); i > 0; i--) buff.write(' ');
         buff.write('^\n Differ at offset $start');
       }
 
@@ -99,7 +99,7 @@ class _StringEqualsMatcher extends Matcher {
 }
 
 class _DeepMatcher extends Matcher {
-  final _expected;
+  final Object _expected;
   final int _limit;
 
   _DeepMatcher(this._expected, [int limit = 1000]) : this._limit = limit;
@@ -136,7 +136,7 @@ class _DeepMatcher extends Matcher {
   List<String> _compareSets(Set expected, Object actual,
       _RecursiveMatcher matcher, int depth, String location) {
     if (actual is Iterable) {
-      Set other = actual.toSet();
+      var other = actual.toSet();
 
       for (var expectedElement in expected) {
         if (other.every((actualElement) =>
@@ -235,8 +235,8 @@ class _DeepMatcher extends Matcher {
     var rp = _recursiveMatch(expected, actual, '', 0);
     if (rp == null) return null;
     String reason;
-    if (rp[0].length > 0) {
-      if (rp[1].length > 0) {
+    if (rp[0].isNotEmpty) {
+      if (rp[1].isNotEmpty) {
         reason = "${rp[0]} at location ${rp[1]}";
       } else {
         reason = rp[0];
@@ -257,12 +257,12 @@ class _DeepMatcher extends Matcher {
 
   Description describeMismatch(
       item, Description mismatchDescription, Map matchState, bool verbose) {
-    var reason = matchState['reason'] ?? '';
+    var reason = matchState['reason'] as String ?? '';
     // If we didn't get a good reason, that would normally be a
     // simple 'is <value>' message. We only add that if the mismatch
     // description is non empty (so we are supplementing the mismatch
     // description).
-    if (reason.length == 0 && mismatchDescription.length > 0) {
+    if (reason.isEmpty && mismatchDescription.length > 0) {
       mismatchDescription.add('is ').addDescriptionOf(item);
     } else {
       mismatchDescription.add(reason);

lib/src/interfaces.dart

@@ -27,8 +27,6 @@ abstract class Description {
   Description addAll(String start, String separator, String end, Iterable list);
 }
 
-/// [expect] Matchers must implement/extend the Matcher class.
-///
 /// The base Matcher class has a generic implementation of [describeMismatch]
 /// so this does not need to be provided unless a more clear description is
 /// required. The other two methods ([matches] and [describe])

lib/src/iterable_matchers.dart

@@ -2,8 +2,8 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
-import 'equals_matcher.dart';
 import 'description.dart';
+import 'equals_matcher.dart';
 import 'interfaces.dart';
 import 'util.dart';
 
@@ -45,7 +45,7 @@ class _EveryElement extends _IterableMatcher {
           .add(' which ');
       var subDescription = new StringDescription();
       _matcher.describeMismatch(
-          element, subDescription, matchState['state'], verbose);
+          element, subDescription, matchState['state'] as Map, verbose);
       if (subDescription.length > 0) {
         mismatchDescription.add(subDescription.toString());
       } else {
@@ -159,10 +159,13 @@ class _UnorderedMatches extends Matcher {
         _allowUnmatchedValues = allowUnmatchedValues ?? false;
 
   String _test(item) {
-    if (item is! Iterable) return 'not iterable';
-
-    var values = item.toList();
+    if (item is Iterable) {
+      return _testCore(item.toList());
+    }
+    return 'not iterable';
+  }
 
+  String _testCore(List values) {
     // Check the lengths are the same.
     if (_expected.length > values.length) {
       return 'has too few elements (${values.length} < ${_expected.length})';
@@ -172,8 +175,8 @@ class _UnorderedMatches extends Matcher {
 
     var edges =
         new List.generate(values.length, (_) => <int>[], growable: false);
-    for (int v = 0; v < values.length; v++) {
-      for (int m = 0; m < _expected.length; m++) {
+    for (var v = 0; v < values.length; v++) {
+      for (var m = 0; m < _expected.length; m++) {
         if (_expected[m].matches(values[v], {})) {
           edges[v].add(m);
         }
@@ -182,10 +185,10 @@ class _UnorderedMatches extends Matcher {
     // The index into `values` matched with each matcher or `null` if no value
     // has been matched yet.
     var matched = new List<int>(_expected.length);
-    for (int valueIndex = 0; valueIndex < values.length; valueIndex++) {
+    for (var valueIndex = 0; valueIndex < values.length; valueIndex++) {
       _findPairing(edges, valueIndex, matched);
     }
-    for (int matcherIndex = 0;
+    for (var matcherIndex = 0;
         matcherIndex < _expected.length;
         matcherIndex++) {
       if (matched[matcherIndex] == null) {
@@ -216,10 +219,10 @@ class _UnorderedMatches extends Matcher {
           Map matchState, bool verbose) =>
       mismatchDescription.add(_test(item));
 
-  /// Returns [true] if the value at [valueIndex] can be paired with some
+  /// Returns `true` if the value at [valueIndex] can be paired with some
   /// unmatched matcher and updates the state of [matched].
   ///
-  /// If there is a conflic where multiple values may match the same matcher
+  /// If there is a conflict where multiple values may match the same matcher
   /// recursively looks for a new place to match the old value. [reserved]
   /// tracks the matchers that have been used _during_ this search.
   bool _findPairing(List<List<int>> edges, int valueIndex, List<int> matched,