Address some more linter/typing concerns, update analysis_options.yaml.

renggli · renggli · commit 6ac436902dfa · 2017-10-22T19:19:25.000+02:00
diff --git a/analysis_options.yaml b/analysis_options.yaml
@@ -3,62 +3,89 @@ analyzer:
 
 linter:
   rules:
-    # errors
-    - avoid_empty_else
-    - avoid_slow_async_io
-    - cancel_subscriptions
-    - close_sinks
-    - comment_references
-    - control_flow_in_finally
-    - hash_and_equals
-    - iterable_contains_unrelated_type
-    - list_remove_unrelated_type
-    - no_adjacent_strings_in_list
-    - no_duplicate_case_values
-    - test_types_in_equals
-    - throw_in_finally
-    - unrelated_type_equality_checks
-    - valid_regexps
-    # style rules
+    - always_declare_return_types
     - always_put_control_body_on_new_line
+    - always_put_required_named_parameters_first
     - always_require_non_null_named_parameters
+#    - always_specify_types
+    - annotate_overrides
     - avoid_annotating_with_dynamic
+#    - avoid_as
     - avoid_catches_without_on_clauses
+#    - avoid_catching_errors
     - avoid_classes_with_only_static_members
+    - avoid_empty_else
+    - avoid_function_literals_in_foreach_calls
+    - avoid_init_to_null
     - avoid_null_checks_in_equality_operators
+#    - avoid_positional_boolean_parameters
     - avoid_return_types_on_setters
     - avoid_returning_null
     - avoid_returning_this
     - avoid_setters_without_getters
+    - avoid_slow_async_io
     - avoid_types_on_closure_parameters
     - await_only_futures
     - camel_case_types
+    - cancel_subscriptions
+#    - cascade_invocations
+    - close_sinks
+    - 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
     - join_return_with_assignment
     - 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
+#    - one_member_abstracts
     - only_throw_errors
     - overridden_fields
     - package_api_docs
+    - package_names
     - package_prefixed_library_names
+#    - parameter_assignments
     - prefer_adjacent_string_concatenation
+    - prefer_asserts_in_initializer_lists
+#    - prefer_bool_in_asserts
     - prefer_collection_literals
     - prefer_conditional_assignment
     - prefer_const_constructors
+    - prefer_const_constructors_in_immutables
     - prefer_constructors_over_static_methods
     - prefer_contains
+#    - prefer_expression_function_bodies
+    - prefer_final_fields
+#    - prefer_final_locals
     - prefer_foreach
     - prefer_function_declarations_over_variables
     - prefer_initializing_formals
     - prefer_interpolation_to_compose_strings
     - prefer_is_empty
     - prefer_is_not_empty
+    - prefer_single_quotes
+#    - prefer_typing_uninitialized_variables
+#    - public_member_api_docs
+    - recursive_getters
     - slash_for_doc_comments
+#    - sort_constructors_first
+#    - sort_unnamed_constructors_first
     - super_goes_last
+    - test_types_in_equals
+    - throw_in_finally
+#    - type_annotate_public_apis
     - type_init_formals
     - unawaited_futures
     - unnecessary_brace_in_string_interps
@@ -67,9 +94,11 @@ linter:
     - unnecessary_null_aware_assignments
     - unnecessary_null_in_if_null_operators
     - unnecessary_overrides
+#    - unnecessary_statements
+#    - unnecessary_this
+    - unrelated_type_equality_checks
     - use_rethrow_when_possible
     - use_setters_to_change_properties
     - use_string_buffers
     - use_to_and_as_if_applicable
-    # pub rules
-    - package_names
+    - valid_regexps
diff --git a/lib/xml/builder.dart b/lib/xml/builder.dart
@@ -115,10 +115,10 @@ class XmlBuilder {
   ///     });
   ///
   void element(String name,
-      {String namespace: null,
+      {String namespace,
       Map<String, String> namespaces: const {},
       Map<String, String> attributes: const {},
-      Object nest: null}) {
+      Object nest}) {
     var element = new XmlElementBuilder();
     _stack.add(element);
     namespaces.forEach(this.namespace);
diff --git a/lib/xml/grammar.dart b/lib/xml/grammar.dart
@@ -7,31 +7,31 @@ import 'package:xml/xml/utils/entities.dart';
 /// XML grammar definition with [TNode] and [TName].
 abstract class XmlGrammarDefinition<TNode, TName> extends GrammarDefinition {
   // name patterns
-  static const NAME_START_CHARS = ':A-Z_a-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF'
+  static const String NAME_START_CHARS = ':A-Z_a-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF'
       '\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001\uD7FF'
       '\uF900-\uFDCF\uFDF0-\uFFFD';
-  static const NAME_CHARS = '-.0-9\u00B7\u0300-\u036F\u203F-\u2040$NAME_START_CHARS';
-  static const CHAR_DATA = '^<';
+  static const String NAME_CHARS = '-.0-9\u00B7\u0300-\u036F\u203F-\u2040$NAME_START_CHARS';
+  static const String CHAR_DATA = '^<';
 
   // basic tokens
-  static const DOUBLE_QUOTE = '"';
-  static const SINGLE_QUOTE = "'";
-  static const EQUALS = '=';
-  static const WHITESPACE = ' ';
-  static const OPEN_COMMENT = '<!--';
-  static const CLOSE_COMMENT = '-->';
-  static const OPEN_CDATA = '<![CDATA[';
-  static const CLOSE_CDATA = ']]>';
-  static const OPEN_ELEMENT = '<';
-  static const CLOSE_ELEMENT = '>';
-  static const OPEN_END_ELEMENT = '</';
-  static const CLOSE_END_ELEMENT = '/>';
-  static const OPEN_DOCTYPE = '<!DOCTYPE';
-  static const CLOSE_DOCTYPE = '>';
-  static const OPEN_DOCTYPE_BLOCK = '[';
-  static const CLOSE_DOCTYPE_BLOCK = ']';
-  static const OPEN_PROCESSING = '<?';
-  static const CLOSE_PROCESSING = '?>';
+  static const String DOUBLE_QUOTE = '"';
+  static const String SINGLE_QUOTE = "'";
+  static const String EQUALS = '=';
+  static const String WHITESPACE = ' ';
+  static const String OPEN_COMMENT = '<!--';
+  static const String CLOSE_COMMENT = '-->';
+  static const String OPEN_CDATA = '<![CDATA[';
+  static const String CLOSE_CDATA = ']]>';
+  static const String OPEN_ELEMENT = '<';
+  static const String CLOSE_ELEMENT = '>';
+  static const String OPEN_END_ELEMENT = '</';
+  static const String CLOSE_END_ELEMENT = '/>';
+  static const String OPEN_DOCTYPE = '<!DOCTYPE';
+  static const String CLOSE_DOCTYPE = '>';
+  static const String OPEN_DOCTYPE_BLOCK = '[';
+  static const String CLOSE_DOCTYPE_BLOCK = ']';
+  static const String OPEN_PROCESSING = '<?';
+  static const String CLOSE_PROCESSING = '?>';
 
   // parser callbacks
   TNode createAttribute(TName name, String text, XmlAttributeType type);
@@ -45,39 +45,40 @@ abstract class XmlGrammarDefinition<TNode, TName> extends GrammarDefinition {
   TNode createText(String text);
 
   // productions
-  start() => ref(document).end();
+  @override
+  Parser start() => ref(document).end();
 
-  attribute() => ref(qualified)
+  Parser attribute() => ref(qualified)
       .seq(ref(spaceOptional))
       .seq(char(EQUALS))
       .seq(ref(spaceOptional))
       .seq(ref(attributeValue))
       .map((each) => createAttribute(each[0] as TName, each[4][0], each[4][1]));
-  attributeValue() => ref(attributeValueDouble).or(ref(attributeValueSingle));
-  attributeValueDouble() => char(DOUBLE_QUOTE)
+  Parser attributeValue() => ref(attributeValueDouble).or(ref(attributeValueSingle));
+  Parser attributeValueDouble() => char(DOUBLE_QUOTE)
       .seq(new XmlCharacterDataParser(DOUBLE_QUOTE, 0))
       .seq(char(DOUBLE_QUOTE))
       .map((each) => [each[1], XmlAttributeType.DOUBLE_QUOTE]);
-  attributeValueSingle() => char(SINGLE_QUOTE)
+  Parser attributeValueSingle() => char(SINGLE_QUOTE)
       .seq(new XmlCharacterDataParser(SINGLE_QUOTE, 0))
       .seq(char(SINGLE_QUOTE))
       .map((each) => [each[1], XmlAttributeType.SINGLE_QUOTE]);
-  attributes() => ref(space).seq(ref(attribute)).pick(1).star();
-  comment() => string(OPEN_COMMENT)
+  Parser attributes() => ref(space).seq(ref(attribute)).pick(1).star();
+  Parser comment() => string(OPEN_COMMENT)
       .seq(any().starLazy(string(CLOSE_COMMENT)).flatten())
       .seq(string(CLOSE_COMMENT))
       .map((each) => createComment(each[1]));
-  cdata() => string(OPEN_CDATA)
+  Parser cdata() => string(OPEN_CDATA)
       .seq(any().starLazy(string(CLOSE_CDATA)).flatten())
       .seq(string(CLOSE_CDATA))
       .map((each) => createCDATA(each[1]));
-  content() => ref(characterData)
+  Parser content() => ref(characterData)
       .or(ref(element))
       .or(ref(processing))
       .or(ref(comment))
       .or(ref(cdata))
       .star();
-  doctype() => string(OPEN_DOCTYPE)
+  Parser doctype() => string(OPEN_DOCTYPE)
       .seq(ref(space))
       .seq(ref(nameToken)
           .or(ref(attributeValue))
@@ -91,7 +92,7 @@ abstract class XmlGrammarDefinition<TNode, TName> extends GrammarDefinition {
       .seq(ref(spaceOptional))
       .seq(char(CLOSE_DOCTYPE))
       .map((each) => createDoctype(each[2]));
-  document() => ref(misc)
+  Parser document() => ref(misc)
           .seq(ref(doctype).optional())
           .seq(ref(misc))
           .seq(ref(element))
@@ -107,7 +108,7 @@ abstract class XmlGrammarDefinition<TNode, TName> extends GrammarDefinition {
         nodes.addAll(each[4] as Iterable<TNode>);
         return createDocument(nodes);
       });
-  element() => char(OPEN_ELEMENT)
+  Parser element() => char(OPEN_ELEMENT)
           .seq(ref(qualified))
           .seq(ref(attributes))
           .seq(ref(spaceOptional))
@@ -129,20 +130,20 @@ abstract class XmlGrammarDefinition<TNode, TName> extends GrammarDefinition {
           }
         }
       });
-  processing() => string(OPEN_PROCESSING)
+  Parser processing() => string(OPEN_PROCESSING)
       .seq(ref(nameToken))
       .seq(ref(space).seq(any().starLazy(string(CLOSE_PROCESSING)).flatten()).pick(1).optional(''))
       .seq(string(CLOSE_PROCESSING))
       .map((each) => createProcessing(each[1], each[2]));
-  qualified() => ref(nameToken).map(createQualified);
+  Parser qualified() => ref(nameToken).map(createQualified);
 
-  characterData() => new XmlCharacterDataParser(OPEN_ELEMENT, 1).map(createText);
-  misc() => ref(spaceText).or(ref(comment)).or(ref(processing)).star();
-  space() => whitespace().plus();
-  spaceText() => ref(space).flatten().map(createText);
-  spaceOptional() => whitespace().star();
+  Parser characterData() => new XmlCharacterDataParser(OPEN_ELEMENT, 1).map(createText);
+  Parser misc() => ref(spaceText).or(ref(comment)).or(ref(processing)).star();
+  Parser space() => whitespace().plus();
+  Parser spaceText() => ref(space).flatten().map(createText);
+  Parser spaceOptional() => whitespace().star();
 
-  nameToken() => ref(nameStartChar).seq(ref(nameChar).star()).flatten();
-  nameStartChar() => pattern(NAME_START_CHARS, 'Expected name');
-  nameChar() => pattern(NAME_CHARS);
+  Parser nameToken() => ref(nameStartChar).seq(ref(nameChar).star()).flatten();
+  Parser nameStartChar() => pattern(NAME_START_CHARS, 'Expected name');
+  Parser nameChar() => pattern(NAME_CHARS);
 }
diff --git a/test/xml_test.dart b/test/xml_test.dart
@@ -128,7 +128,7 @@ void assertTextInvariants(XmlNode xml) {
           reason: 'All nodes are supposed to return text strings.');
     }
     if (node is XmlParent) {
-      var previousType = null;
+      var previousType;
       var nodeTypes = node.children
           .map((node) => node.nodeType);
       for (var currentType in nodeTypes) {
@@ -340,8 +340,8 @@ void main() {
       XmlDocument document = parse('<element attr="value1">text</element>');
       XmlElement node = document.rootElement;
       expect(() => new XmlElement(node.name, [], []), throwsStateError);
-      expect(() => new XmlElement(new XmlName("data"), node.attributes, []), throwsStateError);
-      expect(() => new XmlElement(new XmlName("data"), [], node.children), throwsStateError);
+      expect(() => new XmlElement(new XmlName('data'), node.attributes, []), throwsStateError);
+      expect(() => new XmlElement(new XmlName('data'), [], node.children), throwsStateError);
     });
     test('attribute', () {
       XmlDocument document = parse('<data ns:attr="Am I or are the other crazy?" />');
@@ -404,7 +404,7 @@ void main() {
     test('attribute (readopt name)', () {
       XmlDocument document = parse('<data ns:attr=\'&lt;&gt;&amp;&apos;&quot;&#xA;&#xD;&#x9;\' />');
       XmlAttribute node = document.rootElement.attributes.single;
-      expect(() => new XmlAttribute(node.name, ""), throwsStateError);
+      expect(() => new XmlAttribute(node.name, ''), throwsStateError);
     });
     test('text', () {
       XmlDocument document = parse('<data>Am I or are the other crazy?</data>');
@@ -551,24 +551,24 @@ void main() {
           '  <body lang="en"/>'
           '</html>');
       List<XmlNode> nodes = new List.from(document.descendants)..add(document);
-      nodes.forEach((node) {
+      for (var node in nodes) {
         if (node is XmlAttribute || node is XmlElement) {
           expect((node as XmlNamed).name.namespaceUri, 'http://www.w3.org/1999/xhtml');
         }
-      });
+      }
     });
     test('prefix namespace', () {
       XmlDocument document = parse(
           '<xhtml:html xmlns:xhtml="http://www.w3.org/1999/xhtml">'
           '  <xhtml:body xhtml:lang="en"/>'
           '</xhtml:html>');
       List<XmlNode> nodes = new List.from(document.descendants)..add(document);
-      nodes.forEach((node) {
+      for (var node in nodes) {
         if ((node is XmlAttribute && node.name.prefix != 'xmlns') ||
             (node is XmlElement)) {
           expect((node as XmlNamed).name.namespaceUri, 'http://www.w3.org/1999/xhtml');
         }
-      });
+      }
     });
   });
   group('entities', () {
