diff --git a/CHANGELOG.md b/CHANGELOG.md
index b2f49e7..d819fba 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,6 @@
+## 0.16.1
+ * Add an analysis_options.yaml and fix or suppress all the complaints from it.
+
 ## 0.16.0
  * Fix 'k' formatting (1 to 24 hours) which incorrectly showed 0 to 23.
  * Tighten up types in a couple of places.
diff --git a/lib/date_symbol_data_custom.dart b/lib/date_symbol_data_custom.dart
index 67ad522..40a9afc 100644
--- a/lib/date_symbol_data_custom.dart
+++ b/lib/date_symbol_data_custom.dart
@@ -1,14 +1,12 @@
-// Copyright (c) 2017, the Dart project authors.
-// Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code
-// is governed by a
+// Copyright (c) 2017, the Dart project authors. Please see the AUTHORS file 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.
 
 /// API to allow setting Date/Time formatting in a custom way.
 ///
 /// It does not actually provide any data - that's left to the user of the API.
-import "date_symbols.dart";
-import "src/date_format_internal.dart";
+import 'date_symbols.dart';
+import 'src/date_format_internal.dart';
 
 /// This should be called for at least one [locale] before any date
 /// formatting methods are called.
@@ -23,13 +21,16 @@
     {String locale, DateSymbols symbols, Map<String, String> patterns}) {
   initializeDateSymbols(_emptySymbols);
   initializeDatePatterns(_emptyPatterns);
-  if (symbols == null)
-    throw new ArgumentError("Missing DateTime formatting symbols");
-  if (patterns == null)
-    throw new ArgumentError("Missing DateTime formatting patterns");
-  if (locale != symbols.NAME)
-    throw new ArgumentError.value(
-        [locale, symbols.NAME], "Locale does not match symbols.NAME");
+  if (symbols == null) {
+    throw ArgumentError('Missing DateTime formatting symbols');
+  }
+  if (patterns == null) {
+    throw ArgumentError('Missing DateTime formatting patterns');
+  }
+  if (locale != symbols.NAME) {
+    throw ArgumentError.value(
+        [locale, symbols.NAME], 'Locale does not match symbols.NAME');
+  }
   dateTimeSymbols[symbols.NAME] = symbols;
   dateTimePatterns[symbols.NAME] = patterns;
 }
diff --git a/lib/date_symbol_data_file.dart b/lib/date_symbol_data_file.dart
index dbb1dc0..6a4f33d 100644
--- a/lib/date_symbol_data_file.dart
+++ b/lib/date_symbol_data_file.dart
@@ -23,19 +23,21 @@
 /// methods are called. It sets up the lookup for date symbols using [path].
 /// The [path] parameter should end with a directory separator appropriate
 /// for the platform.
-Future initializeDateFormatting(String locale, String filePath) {
-  var reader = new FileDataReader(path.join(filePath, 'symbols'));
-  initializeDateSymbols(() => new LazyLocaleData(
+Future<void> initializeDateFormatting(String locale, String filePath) {
+  var reader = FileDataReader(path.join(filePath, 'symbols'));
+  initializeDateSymbols(() => LazyLocaleData(
       reader, _createDateSymbol, availableLocalesForDateFormatting));
-  var reader2 = new FileDataReader(path.join(filePath, 'patterns'));
+  var reader2 = FileDataReader(path.join(filePath, 'patterns'));
   initializeDatePatterns(() =>
-      new LazyLocaleData(reader2, (x) => x, availableLocalesForDateFormatting));
+      LazyLocaleData(reader2, (x) => x, availableLocalesForDateFormatting));
   return initializeIndividualLocaleDateFormatting((symbols, patterns) {
-    return Future.wait(
-        <Future>[symbols.initLocale(locale), patterns.initLocale(locale)]);
+    return Future.wait(<Future<dynamic>>[
+      symbols.initLocale(locale),
+      patterns.initLocale(locale)
+    ]);
   });
 }
 
 /// Defines how new date symbol entries are created.
-DateSymbols _createDateSymbol(Map map) =>
-    new DateSymbols.deserializeFromMap(map);
+DateSymbols _createDateSymbol(Map<dynamic, dynamic> map) =>
+    DateSymbols.deserializeFromMap(map);
diff --git a/lib/date_symbol_data_http_request.dart b/lib/date_symbol_data_http_request.dart
index fd4f625..0950856 100644
--- a/lib/date_symbol_data_http_request.dart
+++ b/lib/date_symbol_data_http_request.dart
@@ -21,17 +21,17 @@
 /// methods are called. It sets up the lookup for date symbols using [url].
 /// The [url] parameter should end with a "/". For example,
 ///   "http://localhost:8000/dates/"
-Future initializeDateFormatting(String locale, String url) {
-  var reader = new HttpRequestDataReader('${url}symbols/');
-  initializeDateSymbols(() => new LazyLocaleData(
+Future<void> initializeDateFormatting(String locale, String url) {
+  var reader = HttpRequestDataReader('${url}symbols/');
+  initializeDateSymbols(() => LazyLocaleData(
       reader, _createDateSymbol, availableLocalesForDateFormatting));
-  var reader2 = new HttpRequestDataReader('${url}patterns/');
+  var reader2 = HttpRequestDataReader('${url}patterns/');
   initializeDatePatterns(() =>
-      new LazyLocaleData(reader2, (x) => x, availableLocalesForDateFormatting));
-  var actualLocale = Intl.verifiedLocale(
-      locale, (l) => availableLocalesForDateFormatting.contains(l));
+      LazyLocaleData(reader2, (x) => x, availableLocalesForDateFormatting));
+  var actualLocale =
+      Intl.verifiedLocale(locale, availableLocalesForDateFormatting.contains);
   return initializeIndividualLocaleDateFormatting((symbols, patterns) {
-    return Future.wait(<Future>[
+    return Future.wait(<Future<List<dynamic>>>[
       symbols.initLocale(actualLocale),
       patterns.initLocale(actualLocale)
     ]);
@@ -39,5 +39,5 @@
 }
 
 /// Defines how new date symbol entries are created.
-DateSymbols _createDateSymbol(Map map) =>
-    new DateSymbols.deserializeFromMap(map);
+DateSymbols _createDateSymbol(Map<dynamic, dynamic> map) =>
+    DateSymbols.deserializeFromMap(map);
diff --git a/lib/date_symbol_data_local.dart b/lib/date_symbol_data_local.dart
index 6f74968..36db1cc 100644
--- a/lib/date_symbol_data_local.dart
+++ b/lib/date_symbol_data_local.dart
@@ -15,6 +15,9 @@
 /// to incorporate changes before we could correct CLDR. All manual
 /// modification must be documented in this section, and should be
 /// removed after those changes land to CLDR.
+
+// MANUAL EDIT TO SUPPRESS WARNINGS IN GENERATED CODE
+// ignore_for_file: unnecessary_new, prefer_single_quotes, directives_ordering
 library date_symbol_data_local;
 
 import "date_symbols.dart";
@@ -26,7 +29,7 @@
 /// formatting methods are called. It sets up the lookup for date
 /// symbols. Both the [locale] and [ignored] parameter are ignored, as
 /// the data for all locales is directly available.
-Future initializeDateFormatting([String locale, String ignored]) {
+Future<void> initializeDateFormatting([String locale, String ignored]) {
   initializeDateSymbols(dateTimeSymbolMap);
   initializeDatePatterns(dateTimePatternMap);
   return new Future.value(null);
@@ -35,7 +38,7 @@
 /// Returns a Map from locale names to the DateSymbols instance for
 /// that locale. Internal use only. Call initializeDateFormatting
 /// instead.
-Map dateTimeSymbolMap() => {
+Map<dynamic, dynamic> dateTimeSymbolMap() => {
       // Date/time formatting symbols for locale en_ISO.
       "en_ISO": new DateSymbols(
           NAME: 'en_ISO',
diff --git a/lib/date_symbols.dart b/lib/date_symbols.dart
index dca4020..da43178 100644
--- a/lib/date_symbols.dart
+++ b/lib/date_symbols.dart
@@ -3,6 +3,9 @@
 // BSD-style license that can be found in the LICENSE file.
 library date_symbols;
 
+// Suppress naming lints, as changes would be breaking.
+// ignore_for_file: avoid_types_as_parameter_names,non_constant_identifier_names
+
 /// This holds onto information about how a particular locale formats dates. It
 /// contains mostly strings, e.g. what the names of months or weekdays are,
 /// but also indicates things like the first day of the week. We expect the data
@@ -132,83 +135,81 @@
 
   // TODO(alanknight): Replace this with use of a more general serialization
   // facility once one is available. Issue 4926.
-  DateSymbols.deserializeFromMap(Map map) {
-    List<String> _getStringList(String name) =>
-        new List<String>.from(map[name]);
-    NAME = map["NAME"];
-    ERAS = _getStringList("ERAS");
-    ERANAMES = _getStringList("ERANAMES");
-    NARROWMONTHS = _getStringList("NARROWMONTHS");
-    STANDALONENARROWMONTHS = _getStringList("STANDALONENARROWMONTHS");
-    MONTHS = _getStringList("MONTHS");
-    STANDALONEMONTHS = _getStringList("STANDALONEMONTHS");
-    SHORTMONTHS = _getStringList("SHORTMONTHS");
-    STANDALONESHORTMONTHS = _getStringList("STANDALONESHORTMONTHS");
-    WEEKDAYS = _getStringList("WEEKDAYS");
-    STANDALONEWEEKDAYS = _getStringList("STANDALONEWEEKDAYS");
-    SHORTWEEKDAYS = _getStringList("SHORTWEEKDAYS");
-    STANDALONESHORTWEEKDAYS = _getStringList("STANDALONESHORTWEEKDAYS");
-    NARROWWEEKDAYS = _getStringList("NARROWWEEKDAYS");
-    STANDALONENARROWWEEKDAYS = _getStringList("STANDALONENARROWWEEKDAYS");
-    SHORTQUARTERS = _getStringList("SHORTQUARTERS");
-    QUARTERS = _getStringList("QUARTERS");
-    AMPMS = _getStringList("AMPMS");
-    ZERODIGIT = map["ZERODIGIT"];
-    DATEFORMATS = _getStringList("DATEFORMATS");
-    TIMEFORMATS = _getStringList("TIMEFORMATS");
-    AVAILABLEFORMATS =
-        new Map<String, String>.from(map["AVAILABLEFORMATS"] ?? {});
-    FIRSTDAYOFWEEK = map["FIRSTDAYOFWEEK"];
-    WEEKENDRANGE = new List<int>.from(map["WEEKENDRANGE"]);
-    FIRSTWEEKCUTOFFDAY = map["FIRSTWEEKCUTOFFDAY"];
-    DATETIMEFORMATS = _getStringList("DATETIMEFORMATS");
+  DateSymbols.deserializeFromMap(Map<dynamic, dynamic> map) {
+    List<String> _getStringList(String name) => List<String>.from(map[name]);
+    NAME = map['NAME'];
+    ERAS = _getStringList('ERAS');
+    ERANAMES = _getStringList('ERANAMES');
+    NARROWMONTHS = _getStringList('NARROWMONTHS');
+    STANDALONENARROWMONTHS = _getStringList('STANDALONENARROWMONTHS');
+    MONTHS = _getStringList('MONTHS');
+    STANDALONEMONTHS = _getStringList('STANDALONEMONTHS');
+    SHORTMONTHS = _getStringList('SHORTMONTHS');
+    STANDALONESHORTMONTHS = _getStringList('STANDALONESHORTMONTHS');
+    WEEKDAYS = _getStringList('WEEKDAYS');
+    STANDALONEWEEKDAYS = _getStringList('STANDALONEWEEKDAYS');
+    SHORTWEEKDAYS = _getStringList('SHORTWEEKDAYS');
+    STANDALONESHORTWEEKDAYS = _getStringList('STANDALONESHORTWEEKDAYS');
+    NARROWWEEKDAYS = _getStringList('NARROWWEEKDAYS');
+    STANDALONENARROWWEEKDAYS = _getStringList('STANDALONENARROWWEEKDAYS');
+    SHORTQUARTERS = _getStringList('SHORTQUARTERS');
+    QUARTERS = _getStringList('QUARTERS');
+    AMPMS = _getStringList('AMPMS');
+    ZERODIGIT = map['ZERODIGIT'];
+    DATEFORMATS = _getStringList('DATEFORMATS');
+    TIMEFORMATS = _getStringList('TIMEFORMATS');
+    AVAILABLEFORMATS = Map<String, String>.from(map['AVAILABLEFORMATS'] ?? {});
+    FIRSTDAYOFWEEK = map['FIRSTDAYOFWEEK'];
+    WEEKENDRANGE = List<int>.from(map['WEEKENDRANGE']);
+    FIRSTWEEKCUTOFFDAY = map['FIRSTWEEKCUTOFFDAY'];
+    DATETIMEFORMATS = _getStringList('DATETIMEFORMATS');
   }
 
-  Map serializeToMap() {
+  Map<String, dynamic> serializeToMap() {
     // Don't write default ZERODIGIT, conserves space, but also minimize file
     // churn.
     var basicMap = _serializeToMap();
     if (ZERODIGIT != null && ZERODIGIT != '') {
-      basicMap["ZERODIGIT"] = ZERODIGIT;
+      basicMap['ZERODIGIT'] = ZERODIGIT;
     }
     return basicMap;
   }
 
-  Map _serializeToMap() => {
-        "NAME": NAME,
-        "ERAS": ERAS,
-        "ERANAMES": ERANAMES,
-        "NARROWMONTHS": NARROWMONTHS,
-        "STANDALONENARROWMONTHS": STANDALONENARROWMONTHS,
-        "MONTHS": MONTHS,
-        "STANDALONEMONTHS": STANDALONEMONTHS,
-        "SHORTMONTHS": SHORTMONTHS,
-        "STANDALONESHORTMONTHS": STANDALONESHORTMONTHS,
-        "WEEKDAYS": WEEKDAYS,
-        "STANDALONEWEEKDAYS": STANDALONEWEEKDAYS,
-        "SHORTWEEKDAYS": SHORTWEEKDAYS,
-        "STANDALONESHORTWEEKDAYS": STANDALONESHORTWEEKDAYS,
-        "NARROWWEEKDAYS": NARROWWEEKDAYS,
-        "STANDALONENARROWWEEKDAYS": STANDALONENARROWWEEKDAYS,
-        "SHORTQUARTERS": SHORTQUARTERS,
-        "QUARTERS": QUARTERS,
-        "AMPMS": AMPMS,
-        "DATEFORMATS": DATEFORMATS,
-        "TIMEFORMATS": TIMEFORMATS,
-        "AVAILABLEFORMATS": AVAILABLEFORMATS,
-        "FIRSTDAYOFWEEK": FIRSTDAYOFWEEK,
-        "WEEKENDRANGE": WEEKENDRANGE,
-        "FIRSTWEEKCUTOFFDAY": FIRSTWEEKCUTOFFDAY,
-        "DATETIMEFORMATS": DATETIMEFORMATS,
+  Map<String, dynamic> _serializeToMap() => {
+        'NAME': NAME,
+        'ERAS': ERAS,
+        'ERANAMES': ERANAMES,
+        'NARROWMONTHS': NARROWMONTHS,
+        'STANDALONENARROWMONTHS': STANDALONENARROWMONTHS,
+        'MONTHS': MONTHS,
+        'STANDALONEMONTHS': STANDALONEMONTHS,
+        'SHORTMONTHS': SHORTMONTHS,
+        'STANDALONESHORTMONTHS': STANDALONESHORTMONTHS,
+        'WEEKDAYS': WEEKDAYS,
+        'STANDALONEWEEKDAYS': STANDALONEWEEKDAYS,
+        'SHORTWEEKDAYS': SHORTWEEKDAYS,
+        'STANDALONESHORTWEEKDAYS': STANDALONESHORTWEEKDAYS,
+        'NARROWWEEKDAYS': NARROWWEEKDAYS,
+        'STANDALONENARROWWEEKDAYS': STANDALONENARROWWEEKDAYS,
+        'SHORTQUARTERS': SHORTQUARTERS,
+        'QUARTERS': QUARTERS,
+        'AMPMS': AMPMS,
+        'DATEFORMATS': DATEFORMATS,
+        'TIMEFORMATS': TIMEFORMATS,
+        'AVAILABLEFORMATS': AVAILABLEFORMATS,
+        'FIRSTDAYOFWEEK': FIRSTDAYOFWEEK,
+        'WEEKENDRANGE': WEEKENDRANGE,
+        'FIRSTWEEKCUTOFFDAY': FIRSTWEEKCUTOFFDAY,
+        'DATETIMEFORMATS': DATETIMEFORMATS,
       };
 
-  toString() => NAME;
+  String toString() => NAME;
 }
 
 /// We hard-code the locale data for en_US here so that there's at least one
 /// locale always available.
-var en_USSymbols = new DateSymbols(
-    NAME: "en_US",
+var en_USSymbols = DateSymbols(
+    NAME: 'en_US',
     ERAS: const ['BC', 'AD'],
     ERANAMES: const ['Before Christ', 'Anno Domini'],
     NARROWMONTHS: const [
diff --git a/lib/date_time_patterns.dart b/lib/date_time_patterns.dart
index 457cdd0..21be1fc 100644
--- a/lib/date_time_patterns.dart
+++ b/lib/date_time_patterns.dart
@@ -8,12 +8,15 @@
 /// 'http://go/generate_datetime_pattern_dart.cc' (Google internal)
 /// File generated from CLDR ver. 35.0
 
+// MANUAL EDIT TO SUPPRESS WARNINGS IN GENERATED CODE
+// ignore_for_file: unnecessary_const
+
 library date_time_patterns;
 
 /// Returns a Map from locale names to another Map that goes from skeletons
 /// to the locale-specific formatting patterns.
 /// Internal use only. Call initializeDateFormatting instead.
-Map dateTimePatternMap() => const {
+Map<dynamic, dynamic> dateTimePatternMap() => const {
       /// Extended set of localized date/time patterns for locale af.
       'af': const {
         'd': 'd', // DAY
diff --git a/lib/intl.dart b/lib/intl.dart
index 1eb9f82..f4120c7 100644
--- a/lib/intl.dart
+++ b/lib/intl.dart
@@ -28,7 +28,7 @@
 import 'number_symbols_data.dart';
 import 'src/date_format_internal.dart';
 import 'src/intl_helpers.dart';
-import 'package:intl/src/plural_rules.dart' as plural_rules;
+import 'src/plural_rules.dart' as plural_rules;
 
 part 'src/intl/bidi_formatter.dart';
 part 'src/intl/bidi_utils.dart';
@@ -46,7 +46,7 @@
 ///
 /// Examples:
 ///      today(date) => Intl.message(
-///          "Today's date is $date",
+///          'Today's date is $date',
 ///          name: 'today',
 ///          args: [date],
 ///          desc: 'Indicate the current date',
@@ -71,12 +71,12 @@
 /// the main [package documentation](https://pub.dartlang.org/packages/intl)
 ///
 /// You can set the default locale.
-///       Intl.defaultLocale = "pt_BR";
+///       Intl.defaultLocale = 'pt_BR';
 ///
 /// To temporarily use a locale other than the default, use the `withLocale`
 /// function.
-///       var todayString = new DateFormat("pt_BR").format(new DateTime.now());
-///       print(withLocale("pt_BR", () => today(todayString));
+///       var todayString = new DateFormat('pt_BR').format(new DateTime.now());
+///       print(withLocale('pt_BR', () => today(todayString));
 ///
 /// See `tests/message_format_test.dart` for more examples.
 //TODO(efortuna): documentation example involving the offset parameter?
@@ -114,7 +114,7 @@
   /// If [desiredLocale] is not specified, then we default to [locale].
   DateFormat date([String pattern, String desiredLocale]) {
     var actualLocale = (desiredLocale == null) ? locale : desiredLocale;
-    return new DateFormat(pattern, actualLocale);
+    return DateFormat(pattern, actualLocale);
   }
 
   /// Constructor optionally [aLocale] for specifics of the language
@@ -130,7 +130,7 @@
   /// returns the value of this call and provides a scope for the variables that
   /// will be substituted in the message.
   ///
-  /// The [message_str] is the string to be translated, which may be
+  /// The [messageText] is the string to be translated, which may be
   /// interpolated based on one or more variables.
   ///
   /// The [args] is a list containing the arguments of the enclosing function.
@@ -150,11 +150,11 @@
   /// For example
   ///
   ///       hello(yourName) => Intl.message(
-  ///         "Hello, $yourName",
-  ///         name: "hello",
+  ///         'Hello, $yourName',
+  ///         name: 'hello',
   ///         args: [yourName],
-  ///         desc: "Say hello",
-  ///         examples: const {"yourName": "Sparky"});
+  ///         desc: 'Say hello',
+  ///         examples: const {'yourName': 'Sparky'});
   ///
   /// The source code will be processed via the analyzer to extract out the
   /// message data, so only a subset of valid Dart code is accepted. In
@@ -175,22 +175,22 @@
   // We want dart2js to try to inline these messages, but not inline the
   // internal messages, so it will eliminate the descriptions and other
   // information not neeeded at runtime.
-  static String message(String message_str,
-          {String desc: '',
+  static String message(String messageText,
+          {String desc = '',
           Map<String, Object> examples,
           String locale,
           String name,
           List<Object> args,
           String meaning,
           bool skip}) =>
-      _message(message_str, locale, name, args, meaning);
+      _message(messageText, locale, name, args, meaning);
 
   /// Omit the compile-time only parameters so dart2js can see to drop them.
   @pragma('dart2js:noInline')
-  static String _message(String message_str, String locale, String name,
+  static String _message(String messageText, String locale, String name,
       List<Object> args, String meaning) {
     return messageLookup.lookupMessage(
-        message_str, locale, name, args, meaning);
+        messageText, locale, name, args, meaning);
   }
 
   /// Return the locale for this instance. If none was set, the locale will
@@ -214,7 +214,7 @@
   /// [newLocale] is null the default locale will be returned.
   static String verifiedLocale(
       String newLocale, bool Function(String) localeExists,
-      {String Function(String) onFailure: _throwLocaleError}) {
+      {String Function(String) onFailure = _throwLocaleError}) {
     // TODO(alanknight): Previously we kept a single verified locale on the Intl
     // object, but with different verification for different uses, that's more
     // difficult. As a result, we call this more often. Consider keeping
@@ -230,7 +230,7 @@
     for (var each in [
       canonicalizedLocale(newLocale),
       shortLocale(newLocale),
-      "fallback"
+      'fallback'
     ]) {
       if (localeExists(each)) {
         return each;
@@ -242,7 +242,7 @@
   /// The default action if a locale isn't found in verifiedLocale. Throw
   /// an exception indicating the locale isn't correct.
   static String _throwLocaleError(String localeName) {
-    throw new ArgumentError("Invalid locale '$localeName'");
+    throw ArgumentError('Invalid locale "$localeName"');
   }
 
   /// Return the short version of a locale name, e.g. 'en_US' => 'en'
@@ -264,7 +264,7 @@
     // TODO(alanknight): en_ISO is probably not quite right for the C/Posix
     // locale for formatting. Consider adding C to the formats database.
     if (aLocale == null) return getCurrentLocale();
-    if (aLocale == "C") return "en_ISO";
+    if (aLocale == 'C') return 'en_ISO';
     if (aLocale.length < 5) return aLocale;
     if (aLocale[2] != '-' && (aLocale[2] != '_')) return aLocale;
     var region = aLocale.substring(3);
@@ -359,10 +359,10 @@
       int precision,
       String meaning}) {
     if (other == null) {
-      throw new ArgumentError("The 'other' named argument must be provided");
+      throw ArgumentError("The 'other' named argument must be provided");
     }
     if (howMany == null) {
-      throw new ArgumentError("The howMany argument to plural cannot be null");
+      throw ArgumentError('The howMany argument to plural cannot be null');
     }
 
     // This is for backward compatibility.
@@ -398,15 +398,16 @@
       case plural_rules.PluralCase.OTHER:
         return other;
       default:
-        throw new ArgumentError.value(
-            howMany, "howMany", "Invalid plural argument");
+        throw ArgumentError.value(
+            howMany, 'howMany', 'Invalid plural argument');
     }
   }
 
-  static var _cachedPluralRule;
+  static plural_rules.PluralRule _cachedPluralRule;
   static String _cachedPluralLocale;
 
-  static _pluralRule(String locale, num howMany, int precision) {
+  static plural_rules.PluralRule _pluralRule(
+      String locale, num howMany, int precision) {
     plural_rules.startRuleEvaluation(howMany, precision);
     var verifiedLocale = Intl.verifiedLocale(
         locale, plural_rules.localeHasPluralRules,
@@ -468,15 +469,15 @@
 
   /// Internal: Implements the logic for gender selection - use [gender] for
   /// normal messages.
-  static genderLogic(String targetGender,
-      {female, male, other, String locale}) {
+  static T genderLogic<T>(String targetGender,
+      {T female, T male, T other, String locale}) {
     if (other == null) {
-      throw new ArgumentError("The 'other' named argument must be specified");
+      throw ArgumentError("The 'other' named argument must be specified");
     }
     switch (targetGender) {
-      case "female":
+      case 'female':
         return female == null ? other : female;
-      case "male":
+      case 'male':
         return male == null ? other : male;
       default:
         return other;
@@ -515,7 +516,7 @@
       {String locale, String name, List<Object> args, String meaning}) {
     // Look up our translation, but pass in a null message so we don't have to
     // eagerly evaluate calls that may not be necessary.
-    var stringChoice = choice is String ? choice : "$choice".split('.').last;
+    var stringChoice = choice is String ? choice : '$choice'.split('.').last;
     var modifiedArgs =
         args == null ? null : (<Object>[stringChoice]..addAll(args.skip(1)));
     var translated = _message(null, locale, name, modifiedArgs, meaning);
@@ -527,7 +528,7 @@
 
   /// Internal: Implements the logic for select - use [select] for
   /// normal messages.
-  static selectLogic(Object choice, Map<Object, dynamic> cases) {
+  static T selectLogic<T>(Object choice, Map<Object, T> cases) {
     // This will work if choice is a string, or if it's e.g. an
     // enum and the map uses the enum values as choices.
     var exact = cases[choice];
@@ -536,12 +537,13 @@
     // take the part after the period. We need to do this
     // because enums print as 'EnumType.enumName' and periods
     // aren't acceptable in ICU select choices.
-    var stringChoice = "$choice".split('.').last;
+    var stringChoice = '$choice'.split('.').last;
     var stringMatch = cases[stringChoice];
     if (stringMatch != null) return stringMatch;
-    var other = cases["other"];
-    if (other == null)
-      throw new ArgumentError("The 'other' case must be specified");
+    var other = cases['other'];
+    if (other == null) {
+      throw ArgumentError("The 'other' case must be specified");
+    }
     return other;
   }
 
@@ -557,17 +559,17 @@
   ///
   /// For example
   ///
-  ///       Intl.withLocale("fr", () => new NumberFormat.format(123456));
+  ///       Intl.withLocale('fr', () => new NumberFormat.format(123456));
   ///
   /// or
   ///
   ///       hello(name) => Intl.message(
-  ///           "Hello $name.",
+  ///           'Hello $name.',
   ///           name: 'hello',
   ///           args: [name],
   ///           desc: 'Say Hello');
-  ///       Intl.withLocale("zh", new Timer(new Duration(milliseconds:10),
-  ///           () => print(hello("World")));
+  ///       Intl.withLocale('zh', new Timer(new Duration(milliseconds:10),
+  ///           () => print(hello('World')));
   static dynamic withLocale<T>(String locale, T Function() function) {
     // TODO(alanknight): Make this return T. This requires work because T might
     // be Future and the caller could get an unawaited Future.  Which is
@@ -580,11 +582,11 @@
   /// unless for some reason this gets called inside a message that resets the
   /// locale.
   static String getCurrentLocale() {
-    if (defaultLocale == null) defaultLocale = systemLocale;
+    defaultLocale ??= systemLocale;
     return defaultLocale;
   }
 
-  toString() => "Intl($locale)";
+  String toString() => 'Intl($locale)';
 }
 
 /// Convert a string to beginning of sentence case, in a way appropriate to the
@@ -596,7 +598,7 @@
 /// dotted i in Turkish and Azeri.
 String toBeginningOfSentenceCase(String input, [String locale]) {
   if (input == null || input.isEmpty) return input;
-  return "${_upperCaseLetter(input[0], locale)}${input.substring(1)}";
+  return '${_upperCaseLetter(input[0], locale)}${input.substring(1)}';
 }
 
 /// Convert the input single-letter string to upper case. A trivial
@@ -611,8 +613,8 @@
 String _upperCaseLetter(String input, String locale) {
   // Hard-code the important edge case of i->İ
   if (locale != null) {
-    if (input == "i" && locale.startsWith("tr") || locale.startsWith("az")) {
-      return "\u0130";
+    if (input == 'i' && locale.startsWith('tr') || locale.startsWith('az')) {
+      return '\u0130';
     }
   }
   return input.toUpperCase();
diff --git a/lib/intl_browser.dart b/lib/intl_browser.dart
index e38e9f0..28d45ed 100644
--- a/lib/intl_browser.dart
+++ b/lib/intl_browser.dart
@@ -9,9 +9,9 @@
 
 library intl_browser;
 
-import "dart:async";
-import "dart:html";
-import "intl.dart";
+import 'dart:async';
+import 'dart:html';
+import 'intl.dart';
 
 // TODO(alanknight): The need to do this by forcing the user to specially
 // import a particular library is a horrible hack, only done because there
@@ -23,5 +23,5 @@
 /// [Intl.systemLocale] variable.
 Future<String> findSystemLocale() {
   Intl.systemLocale = Intl.canonicalizedLocale(window.navigator.language);
-  return new Future.value(Intl.systemLocale);
+  return Future.value(Intl.systemLocale);
 }
diff --git a/lib/intl_standalone.dart b/lib/intl_standalone.dart
index 7da66d0..90563fc 100644
--- a/lib/intl_standalone.dart
+++ b/lib/intl_standalone.dart
@@ -9,9 +9,9 @@
 
 library intl_standalone;
 
-import "dart:async";
-import "dart:io";
-import "intl.dart";
+import 'dart:async';
+import 'dart:io';
+import 'intl.dart';
 
 // TODO(alanknight): The need to do this by forcing the user to specially
 // import a particular library is a horrible hack, only done because there
@@ -25,7 +25,7 @@
   try {
     Intl.systemLocale = Intl.canonicalizedLocale(Platform.localeName);
   } catch (e) {
-    return new Future.value();
+    return Future.value();
   }
-  return new Future.value(Intl.systemLocale);
+  return Future.value(Intl.systemLocale);
 }
diff --git a/lib/message_lookup_by_library.dart b/lib/message_lookup_by_library.dart
index 5b376e5..1e41981 100644
--- a/lib/message_lookup_by_library.dart
+++ b/lib/message_lookup_by_library.dart
@@ -19,7 +19,7 @@
 /// of individual [MessageLookupByLibrary] instances.
 class CompositeMessageLookup implements MessageLookup {
   /// A map from locale names to the corresponding lookups.
-  Map<String, MessageLookupByLibrary> availableMessages = new Map();
+  Map<String, MessageLookupByLibrary> availableMessages = Map();
 
   /// Return true if we have a message lookup for [localeName].
   bool localeExists(localeName) => availableMessages.containsKey(localeName);
@@ -35,10 +35,9 @@
 
   /// Look up the message with the given [name] and [locale] and return the
   /// translated version with the values in [args] interpolated.  If nothing is
-  /// found, return the result of [ifAbsent] or [message_str]. The
-  /// [desc] and [examples] parameters are ignored
-  String lookupMessage(
-      String message_str, String locale, String name, List args, String meaning,
+  /// found, return the result of [ifAbsent] or [messageText].
+  String lookupMessage(String messageText, String locale, String name,
+      List<dynamic> args, String meaning,
       {MessageIfAbsent ifAbsent}) {
     // If passed null, use the default.
     var knownLocale = locale ?? Intl.getCurrentLocale();
@@ -48,9 +47,9 @@
     // If we didn't find any messages for this locale, use the original string,
     // faking interpolations if necessary.
     if (messages == null) {
-      return ifAbsent == null ? message_str : ifAbsent(message_str, args);
+      return ifAbsent == null ? messageText : ifAbsent(messageText, args);
     }
-    return messages.lookupMessage(message_str, locale, name, args, meaning,
+    return messages.lookupMessage(messageText, locale, name, args, meaning,
         ifAbsent: ifAbsent);
   }
 
@@ -88,34 +87,26 @@
 abstract class MessageLookupByLibrary {
   /// Return the localized version of a message. We are passed the original
   /// version of the message, which consists of a
-  /// [message_str] that will be translated, and which may be interpolated
-  /// based on one or more variables, a [desc] providing a description of usage
-  /// for the [message_str], and a map of [examples] for each data element to be
-  /// substituted into the message.
+  /// [messageText] that will be translated, and which may be interpolated
+  /// based on one or more variables.
   ///
   /// For example, if message="Hello, $name", then
   /// examples = {'name': 'Sparky'}. If not using the user's default locale, or
   /// if the locale is not easily detectable, explicitly pass [locale].
   ///
-  /// The values of [desc] and [examples] are not used at run-time but are only
-  /// made available to the translators, so they MUST be simple Strings
-  /// available at compile time: no String interpolation or concatenation.  The
-  /// expected usage of this is inside a function that takes as parameters the
-  /// variables used in the interpolated string.
-  ///
   /// Ultimately, the information about the enclosing function and its arguments
   /// will be extracted automatically but for the time being it must be passed
   /// explicitly in the [name] and [args] arguments.
-  String lookupMessage(
-      String message_str, String locale, String name, List args, String meaning,
+  String lookupMessage(String messageText, String locale, String name,
+      List<dynamic> args, String meaning,
       {MessageIfAbsent ifAbsent}) {
     var notFound = false;
-    var actualName = computeMessageName(name, message_str, meaning);
+    var actualName = computeMessageName(name, messageText, meaning);
     if (actualName == null) notFound = true;
     var translation = this[actualName];
     notFound = notFound || (translation == null);
     if (notFound) {
-      return ifAbsent == null ? message_str : ifAbsent(message_str, args);
+      return ifAbsent == null ? messageText : ifAbsent(messageText, args);
     } else {
       args = args ?? const [];
       return evaluateMessage(translation, args);
@@ -123,12 +114,12 @@
   }
 
   /// Evaluate the translated message and return the translated string.
-  String evaluateMessage(translation, List args) {
+  String evaluateMessage(translation, List<dynamic> args) {
     return Function.apply(translation, args);
   }
 
   /// Return our message with the given name
-  operator [](String messageName) => messages[messageName];
+  dynamic operator [](String messageName) => messages[messageName];
 
   /// Subclasses should override this to return a list of their message
   /// implementations. In this class these are functions, but subclasses may
@@ -138,9 +129,10 @@
   /// Subclasses should override this to return their locale, e.g. 'en_US'
   String get localeName;
 
-  toString() => localeName;
+  String toString() => localeName;
 
   /// Return a function that returns the given string.
   /// An optimization for dart2js, used from the generated code.
-  static simpleMessage(translatedString) => () => translatedString;
+  static String Function() simpleMessage(translatedString) =>
+      () => translatedString;
 }
diff --git a/lib/number_symbols.dart b/lib/number_symbols.dart
index a18145b..3c18637 100644
--- a/lib/number_symbols.dart
+++ b/lib/number_symbols.dart
@@ -3,6 +3,9 @@
 // BSD-style license that can be found in the LICENSE file.
 library number_symbols;
 
+// Suppress naming issues as changes would be breaking.
+// ignore_for_file: avoid_types_as_parameter_names, non_constant_identifier_names
+
 /// This holds onto information about how a particular locale formats
 /// numbers. It contains strings for things like the decimal separator, digit to
 /// use for "0" and infinity. We expect the data for instances to be generated
@@ -43,7 +46,7 @@
       this.CURRENCY_PATTERN,
       this.DEF_CURRENCY_CODE});
 
-  toString() => NAME;
+  String toString() => NAME;
 }
 
 class CompactNumberSymbols {
diff --git a/lib/number_symbols_data.dart b/lib/number_symbols_data.dart
index d762eb4..146c4e3 100644
--- a/lib/number_symbols_data.dart
+++ b/lib/number_symbols_data.dart
@@ -14,11 +14,13 @@
 /// modification must be documented in this section, and should be
 /// removed after those changes land to CLDR.
 
+// MANUAL EDIT TO SUPPRESS WARNINGS IN GENERATED CODE
+// ignore_for_file: unnecessary_new, prefer_single_quotes, prefer_const_constructors
 library number_symbol_data;
 
 import "number_symbols.dart";
 
-Map numberFormatSymbols = <String, NumberSymbols>{
+Map<dynamic, dynamic> numberFormatSymbols = <String, NumberSymbols>{
   // Number formatting symbols for locale af.
   "af": new NumberSymbols(
       NAME: "af",
diff --git a/lib/src/data/dates/locale_list.dart b/lib/src/data/dates/locale_list.dart
index 1581cca..b62354e 100644
--- a/lib/src/data/dates/locale_list.dart
+++ b/lib/src/data/dates/locale_list.dart
@@ -4,118 +4,118 @@
 
 /// Hard-coded list of all available locales for dates.
 final availableLocalesForDateFormatting = const [
-  "en_ISO",
-  "af",
-  "am",
-  "ar",
-  "ar_DZ",
-  "ar_EG",
-  "az",
-  "be",
-  "bg",
-  "bn",
-  "br",
-  "bs",
-  "ca",
-  "chr",
-  "cs",
-  "cy",
-  "da",
-  "de",
-  "de_AT",
-  "de_CH",
-  "el",
-  "en",
-  "en_AU",
-  "en_CA",
-  "en_GB",
-  "en_IE",
-  "en_IN",
-  "en_MY",
-  "en_SG",
-  "en_US",
-  "en_ZA",
-  "es",
-  "es_419",
-  "es_ES",
-  "es_MX",
-  "es_US",
-  "et",
-  "eu",
-  "fa",
-  "fi",
-  "fil",
-  "fr",
-  "fr_CA",
-  "fr_CH",
-  "ga",
-  "gl",
-  "gsw",
-  "gu",
-  "haw",
-  "he",
-  "hi",
-  "hr",
-  "hu",
-  "hy",
-  "id",
-  "in",
-  "is",
-  "it",
-  "it_CH",
-  "iw",
-  "ja",
-  "ka",
-  "kk",
-  "km",
-  "kn",
-  "ko",
-  "ky",
-  "ln",
-  "lo",
-  "lt",
-  "lv",
-  "mk",
-  "ml",
-  "mn",
-  "mr",
-  "ms",
-  "mt",
-  "my",
-  "nb",
-  "ne",
-  "nl",
-  "no",
-  "no_NO",
-  "or",
-  "pa",
-  "pl",
-  "ps",
-  "pt",
-  "pt_BR",
-  "pt_PT",
-  "ro",
-  "ru",
-  "si",
-  "sk",
-  "sl",
-  "sq",
-  "sr",
-  "sr_Latn",
-  "sv",
-  "sw",
-  "ta",
-  "te",
-  "th",
-  "tl",
-  "tr",
-  "uk",
-  "ur",
-  "uz",
-  "vi",
-  "zh",
-  "zh_CN",
-  "zh_HK",
-  "zh_TW",
-  "zu"
+  'en_ISO',
+  'af',
+  'am',
+  'ar',
+  'ar_DZ',
+  'ar_EG',
+  'az',
+  'be',
+  'bg',
+  'bn',
+  'br',
+  'bs',
+  'ca',
+  'chr',
+  'cs',
+  'cy',
+  'da',
+  'de',
+  'de_AT',
+  'de_CH',
+  'el',
+  'en',
+  'en_AU',
+  'en_CA',
+  'en_GB',
+  'en_IE',
+  'en_IN',
+  'en_MY',
+  'en_SG',
+  'en_US',
+  'en_ZA',
+  'es',
+  'es_419',
+  'es_ES',
+  'es_MX',
+  'es_US',
+  'et',
+  'eu',
+  'fa',
+  'fi',
+  'fil',
+  'fr',
+  'fr_CA',
+  'fr_CH',
+  'ga',
+  'gl',
+  'gsw',
+  'gu',
+  'haw',
+  'he',
+  'hi',
+  'hr',
+  'hu',
+  'hy',
+  'id',
+  'in',
+  'is',
+  'it',
+  'it_CH',
+  'iw',
+  'ja',
+  'ka',
+  'kk',
+  'km',
+  'kn',
+  'ko',
+  'ky',
+  'ln',
+  'lo',
+  'lt',
+  'lv',
+  'mk',
+  'ml',
+  'mn',
+  'mr',
+  'ms',
+  'mt',
+  'my',
+  'nb',
+  'ne',
+  'nl',
+  'no',
+  'no_NO',
+  'or',
+  'pa',
+  'pl',
+  'ps',
+  'pt',
+  'pt_BR',
+  'pt_PT',
+  'ro',
+  'ru',
+  'si',
+  'sk',
+  'sl',
+  'sq',
+  'sr',
+  'sr_Latn',
+  'sv',
+  'sw',
+  'ta',
+  'te',
+  'th',
+  'tl',
+  'tr',
+  'uk',
+  'ur',
+  'uz',
+  'vi',
+  'zh',
+  'zh_CN',
+  'zh_HK',
+  'zh_TW',
+  'zu'
 ];
diff --git a/lib/src/date_format_internal.dart b/lib/src/date_format_internal.dart
index 27924d9..f0ac494 100644
--- a/lib/src/date_format_internal.dart
+++ b/lib/src/date_format_internal.dart
@@ -13,8 +13,9 @@
 library date_format_internal;
 
 import 'dart:async';
-import 'intl_helpers.dart';
+
 import '../date_symbols.dart';
+import 'intl_helpers.dart';
 
 /// This holds the symbols to be used for date/time formatting, indexed
 /// by locale. Note that it will be set differently during initialization,
@@ -37,8 +38,8 @@
   lastDateSymbolLocale = null;
 }
 
-dynamic _dateTimeSymbols = new UninitializedLocaleData(
-    'initializeDateFormatting(<locale>)', en_USSymbols);
+dynamic _dateTimeSymbols =
+    UninitializedLocaleData('initializeDateFormatting(<locale>)', en_USSymbols);
 
 /// Cache the last used symbols to reduce repeated lookups.
 DateSymbols cachedDateSymbols;
@@ -53,7 +54,7 @@
 /// result in an informative error message.
 // TODO(alanknight): Have a valid type for this. Currently it can be an
 // UninitializedLocaleData, Map, or LazyLocaleData.
-dynamic dateTimePatterns = new UninitializedLocaleData(
+dynamic dateTimePatterns = UninitializedLocaleData(
     'initializeDateFormatting(<locale>)', en_USPatterns);
 
 /// Initialize the symbols dictionary. This should be passed a function that
@@ -61,7 +62,7 @@
 /// initializing the data is an expensive operation it need only be done once,
 /// no matter how many times this method is called.
 void initializeDateSymbols(Function symbols) {
-  if (dateTimeSymbols is UninitializedLocaleData) {
+  if (dateTimeSymbols is UninitializedLocaleData<dynamic>) {
     dateTimeSymbols = symbols();
   }
 }
@@ -71,11 +72,11 @@
 /// initializing the data is an expensive operation it need only be done once,
 /// no matter how many times this method is called.
 void initializeDatePatterns(Function patterns) {
-  if (dateTimePatterns is UninitializedLocaleData) {
+  if (dateTimePatterns is UninitializedLocaleData<dynamic>) {
     dateTimePatterns = patterns();
   }
 }
 
-Future initializeIndividualLocaleDateFormatting(Function init) {
+Future<dynamic> initializeIndividualLocaleDateFormatting(Function init) {
   return init(dateTimeSymbols, dateTimePatterns);
 }
diff --git a/lib/src/file_data_reader.dart b/lib/src/file_data_reader.dart
index d5d1ff5..10b6edc 100644
--- a/lib/src/file_data_reader.dart
+++ b/lib/src/file_data_reader.dart
@@ -8,8 +8,9 @@
 library file_data_reader;
 
 import 'dart:async';
-import 'package:path/path.dart';
 import 'dart:io';
+
+import 'package:path/path.dart';
 import 'intl_helpers.dart';
 
 class FileDataReader implements LocaleDataReader {
@@ -19,8 +20,8 @@
   FileDataReader(this.path);
 
   /// Read the locale data found for [locale] on our [path].
-  Future read(String locale) {
-    var file = new File(join(path, '$locale.json'));
+  Future<String> read(String locale) {
+    var file = File(join(path, '$locale.json'));
     return file.readAsString();
   }
 }
diff --git a/lib/src/http_request_data_reader.dart b/lib/src/http_request_data_reader.dart
index c9c6cd6..da11908 100644
--- a/lib/src/http_request_data_reader.dart
+++ b/lib/src/http_request_data_reader.dart
@@ -16,8 +16,8 @@
   String url;
   HttpRequestDataReader(this.url);
 
-  Future read(String locale) {
-    var request = new HttpRequest();
+  Future<String> read(String locale) {
+    var request = HttpRequest();
     request.timeout = 5000;
     return _getString('$url$locale.json', request).then((r) => r.responseText);
   }
@@ -26,7 +26,7 @@
   /// of HttpRequest getString, but was the simplest way I could find to
   /// issue a request with a timeout.
   Future<HttpRequest> _getString(String url, HttpRequest xhr) {
-    var completer = new Completer<HttpRequest>();
+    var completer = Completer<HttpRequest>();
     xhr.open('GET', url, async: true);
     xhr.onLoad.listen((e) {
       // Note: file:// URIs have status of 0.
diff --git a/lib/src/intl/bidi_formatter.dart b/lib/src/intl/bidi_formatter.dart
index c40fd5e..f275d23 100644
--- a/lib/src/intl/bidi_formatter.dart
+++ b/lib/src/intl/bidi_formatter.dart
@@ -4,6 +4,9 @@
 
 part of intl;
 
+// Suppress naming issues as changing them would be breaking.
+// ignore_for_file: non_constant_identifier_names
+
 /// Bidi stands for Bi-directional text.  According to
 /// [Wikipedia](http://en.wikipedia.org/wiki/Bi-directional_text):
 /// Bi-directional text is text containing text in both text directionalities,
@@ -58,7 +61,7 @@
   TextDirection contextDirection;
 
   /// Indicates if we should always wrap the formatted text in a &lt;span&lt;,.
-  bool _alwaysSpan;
+  final bool _alwaysSpan;
 
   /// Create a formatting object with a direction. If [alwaysSpan] is true we
   /// should always use a `span` tag, even when the input directionality is
@@ -93,9 +96,9 @@
   /// a trailing unicode BiDi mark matching the context directionality is
   /// appended (LRM or RLM). If [isHtml] is false, we HTML-escape the [text].
   String wrapWithSpan(String text,
-      {bool isHtml: false, bool resetDir: true, TextDirection direction}) {
-    if (direction == null) direction = estimateDirection(text, isHtml: isHtml);
-    var result;
+      {bool isHtml = false, bool resetDir = true, TextDirection direction}) {
+    direction ??= estimateDirection(text, isHtml: isHtml);
+    String result;
     if (!isHtml) text = const HtmlEscape().convert(text);
     var directionChange = contextDirection.isDirectionChange(direction);
     if (_alwaysSpan || directionChange) {
@@ -128,12 +131,12 @@
   /// [isHtml]. [isHtml] is used to designate if the text contains HTML (escaped
   /// or unescaped).
   String wrapWithUnicode(String text,
-      {bool isHtml: false, bool resetDir: true, TextDirection direction}) {
-    if (direction == null) direction = estimateDirection(text, isHtml: isHtml);
+      {bool isHtml = false, bool resetDir = true, TextDirection direction}) {
+    direction ??= estimateDirection(text, isHtml: isHtml);
     var result = text;
     if (contextDirection.isDirectionChange(direction)) {
       var marker = direction == TextDirection.RTL ? Bidi.RLE : Bidi.LRE;
-      result = "${marker}$text${Bidi.PDF}";
+      result = '$marker$text${Bidi.PDF}';
     }
     return result + (resetDir ? _resetDir(text, direction, isHtml) : '');
   }
@@ -142,7 +145,7 @@
   /// general-purpose method (using relative word counts). A
   /// TextDirection.UNKNOWN return value indicates completely neutral input.
   /// [isHtml] is true if [text] HTML or HTML-escaped.
-  TextDirection estimateDirection(String text, {bool isHtml: false}) {
+  TextDirection estimateDirection(String text, {bool isHtml = false}) {
     return Bidi.estimateDirectionOfText(text, isHtml: isHtml); //TODO~!!!
   }
 
diff --git a/lib/src/intl/bidi_utils.dart b/lib/src/intl/bidi_utils.dart
index 438ef29..7e8be01 100644
--- a/lib/src/intl/bidi_utils.dart
+++ b/lib/src/intl/bidi_utils.dart
@@ -4,6 +4,9 @@
 
 part of intl;
 
+// Suppress naming issues as changing them would be breaking.
+// ignore_for_file: constant_identifier_names
+
 /// Bidi stands for Bi-directional text.  According to
 /// http://en.wikipedia.org/wiki/Bi-directional_text: Bi-directional text is
 /// text containing text in both text directionalities, both right-to-left (RTL)
@@ -21,12 +24,12 @@
 /// bidi functionality in the given directional context, instead of using
 /// bidi_utils.dart directly.
 class TextDirection {
-  static const LTR = const TextDirection._('LTR', 'ltr');
-  static const RTL = const TextDirection._('RTL', 'rtl');
+  static const LTR = TextDirection._('LTR', 'ltr');
+  static const RTL = TextDirection._('RTL', 'rtl');
   // If the directionality of the text cannot be determined and we are not using
   // the context direction (or if the context direction is unknown), then the
   // text falls back on the more common ltr direction.
-  static const UNKNOWN = const TextDirection._('UNKNOWN', 'ltr');
+  static const UNKNOWN = TextDirection._('UNKNOWN', 'ltr');
 
   /// Textual representation of the directionality constant. One of
   /// 'LTR', 'RTL', or 'UNKNOWN'.
@@ -43,9 +46,11 @@
       otherDirection != TextDirection.UNKNOWN && this != otherDirection;
 }
 
+// ignore: avoid_classes_with_only_static_members
 /// This provides utility methods for working with bidirectional text. All
 /// of the methods are static, and are organized into a class primarily to
 /// group them together for documentation and discoverability.
+// TODO(alanknight): Consider a better way of organizing these.
 class Bidi {
   /// Unicode "Left-To-Right Embedding" (LRE) character.
   static const LRE = '\u202A';
@@ -63,7 +68,7 @@
   static const RLM = '\u200F';
 
   /// Constant to define the threshold of RTL directionality.
-  static num _RTL_DETECTION_THRESHOLD = 0.40;
+  static const _RTL_DETECTION_THRESHOLD = 0.40;
 
   /// Practical patterns to identify strong LTR and RTL characters,
   /// respectively.  These patterns are not completely correct according to the
@@ -86,20 +91,20 @@
     // The regular expression is simplified for an HTML tag (opening or
     // closing) or an HTML escape. We might want to skip over such expressions
     // when estimating the text directionality.
-    return text.replaceAll(new RegExp(r'<[^>]*>|&[^;]+;'), ' ');
+    return text.replaceAll(RegExp(r'<[^>]*>|&[^;]+;'), ' ');
   }
 
   /// Determines if the first character in [text] with strong directionality is
   /// LTR. If [isHtml] is true, the text is HTML or HTML-escaped.
   static bool startsWithLtr(String text, [isHtml = false]) {
-    return new RegExp('^[^$_RTL_CHARS]*[$_LTR_CHARS]')
+    return RegExp('^[^$_RTL_CHARS]*[$_LTR_CHARS]')
         .hasMatch(isHtml ? stripHtmlIfNeeded(text) : text);
   }
 
   /// Determines if the first character in [text] with strong directionality is
   /// RTL. If [isHtml] is true, the text is HTML or HTML-escaped.
   static bool startsWithRtl(String text, [isHtml = false]) {
-    return new RegExp('^[^$_LTR_CHARS]*[$_RTL_CHARS]')
+    return RegExp('^[^$_LTR_CHARS]*[$_RTL_CHARS]')
         .hasMatch(isHtml ? stripHtmlIfNeeded(text) : text);
   }
 
@@ -107,7 +112,7 @@
   /// character in [text] is LTR. If [isHtml] is true, the text is HTML or
   /// HTML-escaped.
   static bool endsWithLtr(String text, [isHtml = false]) {
-    return new RegExp('[$_LTR_CHARS][^$_RTL_CHARS]*\$')
+    return RegExp('[$_LTR_CHARS][^$_RTL_CHARS]*\$')
         .hasMatch(isHtml ? stripHtmlIfNeeded(text) : text);
   }
 
@@ -115,25 +120,25 @@
   /// character in [text] is RTL. If [isHtml] is true, the text is HTML or
   /// HTML-escaped.
   static bool endsWithRtl(String text, [isHtml = false]) {
-    return new RegExp('[$_RTL_CHARS][^$_LTR_CHARS]*\$')
+    return RegExp('[$_RTL_CHARS][^$_LTR_CHARS]*\$')
         .hasMatch(isHtml ? stripHtmlIfNeeded(text) : text);
   }
 
   /// Determines if the given [text] has any LTR characters in it.
   /// If [isHtml] is true, the text is HTML or HTML-escaped.
   static bool hasAnyLtr(String text, [isHtml = false]) {
-    return new RegExp(r'[' '$_LTR_CHARS' r']')
+    return RegExp(r'[' '$_LTR_CHARS' r']')
         .hasMatch(isHtml ? stripHtmlIfNeeded(text) : text);
   }
 
   /// Determines if the given [text] has any RTL characters in it.
   /// If [isHtml] is true, the text is HTML or HTML-escaped.
   static bool hasAnyRtl(String text, [isHtml = false]) {
-    return new RegExp(r'[' '$_RTL_CHARS' r']')
+    return RegExp(r'[' '$_RTL_CHARS' r']')
         .hasMatch(isHtml ? stripHtmlIfNeeded(text) : text);
   }
 
-  static final _rtlLocaleRegex = new RegExp(
+  static final _rtlLocaleRegex = RegExp(
       r'^(ar|dv|he|iw|fa|nqo|ps|sd|ug|ur|yi|.*[-_]'
       r'(Arab|Hebr|Thaa|Nkoo|Tfng))(?!.*[-_](Latn|Cyrl)($|-|_))'
       r'($|-|_)',
@@ -209,9 +214,9 @@
   /// FF and IE).
   static String _enforceInHtmlHelper(String html, String direction) {
     if (html.startsWith('<')) {
-      StringBuffer buffer = new StringBuffer();
+      var buffer = StringBuffer();
       var startIndex = 0;
-      Match match = new RegExp('<\\w+').firstMatch(html);
+      Match match = RegExp('<\\w+').firstMatch(html);
       if (match != null) {
         buffer
           ..write(html.substring(startIndex, match.end))
@@ -230,10 +235,10 @@
   /// RTL directionality, regardless of the estimated directionality.
   static String guardBracketInHtml(String str, [bool isRtlContext]) {
     var useRtl = isRtlContext == null ? hasAnyRtl(str) : isRtlContext;
-    RegExp matchingBrackets =
-        new RegExp(r'(\(.*?\)+)|(\[.*?\]+)|(\{.*?\}+)|(&lt;.*?(&gt;)+)');
+    var matchingBrackets =
+        RegExp(r'(\(.*?\)+)|(\[.*?\]+)|(\{.*?\}+)|(&lt;.*?(&gt;)+)');
     return _guardBracketHelper(str, matchingBrackets,
-        '<span dir=${useRtl? "rtl" : "ltr"}>', '</span>');
+        '<span dir=${useRtl ? "rtl" : "ltr"}>', '</span>');
   }
 
   /// Apply bracket guard to [str] using LRM and RLM. This is to address the
@@ -245,8 +250,8 @@
   static String guardBracketInText(String str, [bool isRtlContext]) {
     var useRtl = isRtlContext == null ? hasAnyRtl(str) : isRtlContext;
     var mark = useRtl ? RLM : LRM;
-    return _guardBracketHelper(str,
-        new RegExp(r'(\(.*?\)+)|(\[.*?\]+)|(\{.*?\}+)|(<.*?>+)'), mark, mark);
+    return _guardBracketHelper(
+        str, RegExp(r'(\(.*?\)+)|(\[.*?\]+)|(\{.*?\}+)|(<.*?>+)'), mark, mark);
   }
 
   /// (Mostly) reimplements the $& functionality of "replace" in JavaScript.
@@ -257,16 +262,16 @@
   /// is implemented in Dart.  // See Issue 2979.
   static String _guardBracketHelper(String str, RegExp regexp,
       [String before, String after]) {
-    var buffer = new StringBuffer();
+    var buffer = StringBuffer();
     var startIndex = 0;
-    regexp.allMatches(str).forEach((match) {
+    for (var match in regexp.allMatches(str)) {
       buffer
         ..write(str.substring(startIndex, match.start))
         ..write(before)
         ..write(str.substring(match.start, match.end))
         ..write(after);
       startIndex = match.end;
-    });
+    }
     return (buffer..write(str.substring(startIndex))).toString();
   }
 
@@ -281,24 +286,24 @@
   /// Otherwise, returns UNKNOWN, which is used to mean `neutral`.
   /// Numbers and URLs are counted as weakly LTR.
   static TextDirection estimateDirectionOfText(String text,
-      {bool isHtml: false}) {
+      {bool isHtml = false}) {
     text = isHtml ? stripHtmlIfNeeded(text) : text;
     var rtlCount = 0;
     var total = 0;
     var hasWeaklyLtr = false;
     // Split a string into 'words' for directionality estimation based on
     // relative word counts.
-    for (String token in text.split(new RegExp(r'\s+'))) {
+    for (var token in text.split(RegExp(r'\s+'))) {
       if (startsWithRtl(token)) {
         rtlCount++;
         total++;
-      } else if (new RegExp(r'^http://').hasMatch(token)) {
+      } else if (RegExp(r'^http://').hasMatch(token)) {
         // Checked if token looks like something that must always be LTR even in
         // RTL text, such as a URL.
         hasWeaklyLtr = true;
       } else if (hasAnyLtr(token)) {
         total++;
-      } else if (new RegExp(r'\d').hasMatch(token)) {
+      } else if (RegExp(r'\d').hasMatch(token)) {
         // Checked if token contains any numerals.
         hasWeaklyLtr = true;
       }
@@ -316,18 +321,18 @@
   /// Replace the double and single quote directly after a Hebrew character in
   /// [str] with GERESH and GERSHAYIM. This is most likely the user's intention.
   static String normalizeHebrewQuote(String str) {
-    StringBuffer buf = new StringBuffer();
-    if (str.length > 0) {
+    var buf = StringBuffer();
+    if (str.isNotEmpty) {
       buf.write(str.substring(0, 1));
     }
     // Start at 1 because we're looking for the patterns [\u0591-\u05f2])" or
     // [\u0591-\u05f2]'.
-    for (int i = 1; i < str.length; i++) {
+    for (var i = 1; i < str.length; i++) {
       if (str.substring(i, i + 1) == '"' &&
-          new RegExp('[\u0591-\u05f2]').hasMatch(str.substring(i - 1, i))) {
+          RegExp('[\u0591-\u05f2]').hasMatch(str.substring(i - 1, i))) {
         buf.write('\u05f4');
       } else if (str.substring(i, i + 1) == "'" &&
-          new RegExp('[\u0591-\u05f2]').hasMatch(str.substring(i - 1, i))) {
+          RegExp('[\u0591-\u05f2]').hasMatch(str.substring(i - 1, i))) {
         buf.write('\u05f3');
       } else {
         buf.write(str.substring(i, i + 1));
@@ -339,6 +344,6 @@
   /// Check the estimated directionality of [str], return true if the piece of
   /// text should be laid out in RTL direction. If [isHtml] is true, the string
   /// is HTML or HTML-escaped.
-  static bool detectRtlDirectionality(String str, {bool isHtml: false}) =>
+  static bool detectRtlDirectionality(String str, {bool isHtml = false}) =>
       estimateDirectionOfText(str, isHtml: isHtml) == TextDirection.RTL;
 }
diff --git a/lib/src/intl/compact_number_format.dart b/lib/src/intl/compact_number_format.dart
index 5818018..a1e459d 100644
--- a/lib/src/intl/compact_number_format.dart
+++ b/lib/src/intl/compact_number_format.dart
@@ -4,6 +4,9 @@
 
 part of intl;
 
+// Suppress naming issues as changes would be breaking.
+// ignore_for_file: constant_identifier_names
+
 /// An abstract class for compact number styles.
 abstract class _CompactStyleBase {
   /// The _CompactStyle for the sign of [number], i.e. positive or
@@ -14,7 +17,7 @@
   ///
   /// If the pattern is
   ///
-  ///       4: "00K",
+  ///       4: '00K',
   ///
   /// then this is 5, meaning we expect this to be a 5-digit (or more)
   /// number. We will scale by 1000 and expect 2 integer digits remaining, so we
@@ -42,7 +45,7 @@
       number < 0 ? negativeStyle : positiveStyle;
   int get totalDigits => positiveStyle.totalDigits;
   int get divisor => positiveStyle.divisor;
-  get allStyles => [positiveStyle, negativeStyle];
+  List<_CompactStyle> get allStyles => [positiveStyle, negativeStyle];
 }
 
 /// Represents a compact format for a particular base
@@ -61,11 +64,11 @@
 class _CompactStyle extends _CompactStyleBase {
   _CompactStyle(
       {this.pattern,
-      this.requiredDigits: 0,
-      this.divisor: 1,
-      this.expectedDigits: 1,
-      this.prefix: '',
-      this.suffix: ''});
+      this.requiredDigits = 0,
+      this.divisor = 1,
+      this.expectedDigits = 1,
+      this.prefix = '',
+      this.suffix = ''});
 
   /// The pattern on which this is based.
   ///
@@ -99,16 +102,16 @@
   ///
   /// If the pattern is
   ///
-  ///       4: "00K",
+  ///       4: '00K',
   ///
   /// then this is 5, meaning we expect this to be a 5-digit (or more)
   /// number. We will scale by 1000 and expect 2 integer digits remaining, so we
   /// get something like '12K'. This is used to find the closest pattern for a
   /// number.
-  get totalDigits => requiredDigits + expectedDigits - 1;
+  int get totalDigits => requiredDigits + expectedDigits - 1;
 
   /// Return true if this is the fallback compact pattern, printing the number
-  /// un-compacted. e.g. 1200 might print as "1.2K", but 12 just prints as "12".
+  /// un-compacted. e.g. 1200 might print as '1.2K', but 12 just prints as '12'.
   ///
   /// For currencies, with the fallback pattern we use the super implementation
   /// so that we will respect things like the default number of decimal digits
@@ -119,14 +122,13 @@
   ///
   /// This happens if the pattern has no abbreviation for scaling (e.g. K, M).
   /// So either the pattern is empty or it is of a form like '0 $'. This is a
-  /// workaround for locales like "it", which include patterns with no suffix
+  /// workaround for locales like 'it', which include patterns with no suffix
   /// for numbers >= 1000 but < 1,000,000.
   bool get printsAsIs =>
-      isFallback ||
-      pattern.replaceAll(new RegExp('[0\u00a0\u00a4]'), '').isEmpty;
+      isFallback || pattern.replaceAll(RegExp('[0\u00a0\u00a4]'), '').isEmpty;
 
   _CompactStyle styleForSign(number) => this;
-  get allStyles => [this];
+  List<_CompactStyle> get allStyles => [this];
 }
 
 enum _CompactFormatType {
@@ -136,7 +138,7 @@
 }
 
 class _CompactNumberFormat extends NumberFormat {
-  /// A default, using the decimal pattern, for the [getPattern] constructor parameter.
+  /// A default, using the decimal pattern, for the `getPattern` constructor parameter.
   static String _forDecimal(NumberSymbols symbols) => symbols.DECIMAL_PATTERN;
 
   // Will be either the COMPACT_DECIMAL_SHORT_PATTERN,
@@ -150,10 +152,10 @@
       _CompactFormatType formatType,
       String name,
       String currencySymbol,
-      String getPattern(NumberSymbols symbols): _forDecimal,
-      String computeCurrencySymbol(NumberFormat),
+      String Function(NumberSymbols) getPattern = _forDecimal,
+      String Function(NumberFormat) computeCurrencySymbol,
       int decimalDigits,
-      bool isForCurrency: false})
+      bool isForCurrency = false})
       : super._forPattern(locale, getPattern,
             name: name,
             currencySymbol: currencySymbol,
@@ -176,12 +178,12 @@
         _patterns = compactSymbols.COMPACT_DECIMAL_SHORT_CURRENCY_PATTERN;
         break;
       default:
-        throw new ArgumentError.notNull("formatType");
+        throw ArgumentError.notNull('formatType');
     }
     _patterns.forEach((int impliedDigits, String pattern) {
-      if (pattern.contains(";")) {
-        var patterns = pattern.split(";");
-        _styles.add(new _CompactStyleWithNegative(
+      if (pattern.contains(';')) {
+        var patterns = pattern.split(';');
+        _styles.add(_CompactStyleWithNegative(
             _createStyle(patterns.first, impliedDigits),
             _createStyle(patterns.last, impliedDigits)));
       } else {
@@ -192,12 +194,12 @@
     // Reverse the styles so that we look through them from largest to smallest.
     _styles = _styles.reversed.toList();
     // Add a fallback style that just prints the number.
-    _styles.add(new _CompactStyle());
+    _styles.add(_CompactStyle());
   }
 
-  final _regex = new RegExp('([^0]*)(0+)(.*)');
+  final _regex = RegExp('([^0]*)(0+)(.*)');
 
-  final _justZeros = new RegExp(r'^0*$');
+  final _justZeros = RegExp(r'^0*$');
 
   /// Does pattern have any additional characters or is it just zeros.
   bool _hasNonZeroContent(String pattern) => !_justZeros.hasMatch(pattern);
@@ -217,7 +219,7 @@
     if (_hasNonZeroContent(pattern)) {
       divisor = pow(10, impliedDigits - integerDigits + 1);
     }
-    return new _CompactStyle(
+    return _CompactStyle(
         pattern: pattern,
         requiredDigits: impliedDigits,
         expectedDigits: integerDigits,
@@ -243,12 +245,12 @@
     // so remove it and replace. This has the remote possibility of a false
     // positive, but it seems unlikely that e.g. USD would occur as a string in
     // a regular number.
-    if (this._isForCurrency && !_style.isFallback) {
+    if (_isForCurrency && !_style.isFallback) {
       formatted = formatted.replaceFirst(currencySymbol, '').trim();
       prefix = prefix.replaceFirst('\u00a4', currencySymbol);
       suffix = suffix.replaceFirst('\u00a4', currencySymbol);
     }
-    var withExtras = "${prefix}$formatted${suffix}";
+    var withExtras = '$prefix$formatted$suffix';
     _style = null;
     return withExtras;
   }
@@ -285,8 +287,8 @@
     var divided = numerator ~/ denominator;
     var integerPart = divided.toInt();
     if (divided != integerPart) {
-      throw new FormatException(
-          "Number too big to use with compact format", numerator);
+      throw FormatException(
+          'Number too big to use with compact format', numerator);
     }
     var remainder = numerator.remainder(denominator).toInt();
     var originalFraction = numerator - (numerator ~/ 1);
@@ -312,8 +314,8 @@
         return style.styleForSign(number);
       }
     }
-    throw new FormatException(
-        "No compact style found for number. This should not happen", number);
+    throw FormatException(
+        'No compact style found for number. This should not happen', number);
   }
 
   Iterable<_CompactStyle> get _stylesForSearching =>
@@ -330,7 +332,7 @@
         }
       }
     }
-    throw new FormatException(
+    throw FormatException(
         "Cannot parse compact number in locale '$locale'", text);
   }
 
diff --git a/lib/src/intl/date_format.dart b/lib/src/intl/date_format.dart
index 55901ff..5625802 100644
--- a/lib/src/intl/date_format.dart
+++ b/lib/src/intl/date_format.dart
@@ -4,6 +4,9 @@
 
 part of intl;
 
+// Suppress naming issues as changes would breaking.
+// ignore_for_file: non_constant_identifier_names, constant_identifier_names
+
 // TODO(efortuna): Customized pattern system -- suggested by i18n needs
 // feedback on appropriateness.
 /// DateFormat is for formatting and parsing dates in a locale-sensitive
@@ -16,7 +19,7 @@
 /// date-time strings under certain locales. Date elements that vary across
 /// locales include month name, weekname, field, order, etc.
 ///
-/// Formatting dates in the default "en_US" format does not require any
+/// Formatting dates in the default 'en_US' format does not require any
 /// initialization. e.g.
 ///
 /// ```dart
@@ -25,7 +28,7 @@
 ///
 /// But for other locales, the formatting data for the locale must be
 /// obtained. This can currently be done in one of three ways, determined by
-/// which library you import. In all cases, the "initializeDateFormatting"
+/// which library you import. In all cases, the 'initializeDateFormatting'
 /// method must be called and will return a future that is complete once the
 /// locale data is available. The result of the future isn't important, but the
 /// data for that locale is available to the date formatting and parsing once it
@@ -36,7 +39,7 @@
 ///
 /// ```dart
 /// import 'package:intl/date_symbol_data_local.dart';
-/// initializeDateFormatting("fr_FR", null).then((_) => runMyCode());
+/// initializeDateFormatting('fr_FR', null).then((_) => runMyCode());
 /// ```
 ///
 /// If we are running outside of a browser, we may want to read the data
@@ -44,7 +47,7 @@
 ///
 /// ```dart
 /// import 'package:intl/date_symbol_data_file.dart';
-/// initializeDateFormatting("de_DE", null).then((_) => runMyCode());
+/// initializeDateFormatting('de_DE', null).then((_) => runMyCode());
 /// ```
 ///
 /// If we are running in a browser, we may want to read the data from the
@@ -52,7 +55,7 @@
 ///
 /// ```dart
 /// import 'package:intl/date_symbol_data_http_request.dart';
-/// initializeDateFormatting("pt_BR", null).then((_) => runMyCode());
+/// initializeDateFormatting('pt_BR', null).then((_) => runMyCode());
 /// ```
 ///
 /// The code in example/basic/basic_example.dart shows a full example of
@@ -60,7 +63,7 @@
 ///
 /// Once we have the locale data, we need to specify the particular format.
 /// This library uses the ICU/JDK date/time pattern specification both for
-/// complete format specifications and also the abbreviated "skeleton" form
+/// complete format specifications and also the abbreviated 'skeleton' form
 /// which can also adapt to different locales and is preferred where available.
 ///
 /// Skeletons: These can be specified either as the ICU constant name or as the
@@ -118,8 +121,8 @@
 ///      Pattern                           Result
 ///      ----------------                  -------
 ///      new DateFormat.yMd()             -> 7/10/1996
-///      new DateFormat("yMd")            -> 7/10/1996
-///      new DateFormat.yMMMMd("en_US")   -> July 10, 1996
+///      new DateFormat('yMd')            -> 7/10/1996
+///      new DateFormat.yMMMMd('en_US')   -> July 10, 1996
 ///      new DateFormat.jm()              -> 5:08 PM
 ///      new DateFormat.yMd().add_jm()    -> 7/10/1996 5:08 PM
 ///      new DateFormat.Hm()              -> 17:08 // force 24 hour time
@@ -127,9 +130,9 @@
 /// Explicit Pattern Syntax: Formats can also be specified with a pattern
 /// string.  This can be used for formats that don't have a skeleton available,
 /// but these will not adapt to different locales. For example, in an explicit
-/// pattern the letters "H" and "h" are available for 24 hour and 12 hour time
+/// pattern the letters 'H' and 'h' are available for 24 hour and 12 hour time
 /// formats respectively. But there isn't a way in an explicit pattern to get
-/// the behaviour of the "j" skeleton, which prints 24 hour or 12 hour time
+/// the behaviour of the 'j' skeleton, which prints 24 hour or 12 hour time
 /// according to the conventions of the locale, and also includes am/pm markers
 /// where appropriate. So it is preferable to use the skeletons.
 ///
@@ -169,9 +172,9 @@
 /// * less than 3--use numeric form if one exists
 ///
 /// **Number**: the minimum number of digits. Shorter numbers are zero-padded to
-/// this amount (e.g. if "m" produces "6", "mm" produces "06"). Year is handled
+/// this amount (e.g. if 'm' produces '6', 'mm' produces '06'). Year is handled
 /// specially; that is, if the count of 'y' is 2, the Year will be truncated to
-/// 2 digits. (e.g., if "yyyy" produces "1997", "yy" produces "97".) Unlike
+/// 2 digits. (e.g., if 'yyyy' produces '1997', 'yy' produces '97'.) Unlike
 /// other fields, fractional seconds are padded on the right with zero.
 ///
 /// **(Text & Number)**: 3 or over, use text, otherwise use number.
@@ -187,27 +190,27 @@
 ///
 ///     Format Pattern                    Result
 ///     --------------                    -------
-///     "yyyy.MM.dd G 'at' HH:mm:ss vvvv" 1996.07.10 AD at 15:08:56 Pacific Time
-///     "EEE, MMM d, ''yy"                Wed, Jul 10, '96
-///     "h:mm a"                          12:08 PM
-///     "hh 'o''clock' a, zzzz"           12 o'clock PM, Pacific Daylight Time
-///     "K:mm a, vvv"                     0:00 PM, PT
-///     "yyyyy.MMMMM.dd GGG hh:mm aaa"    01996.July.10 AD 12:08 PM
+///     'yyyy.MM.dd G 'at' HH:mm:ss vvvv' 1996.07.10 AD at 15:08:56 Pacific Time
+///     'EEE, MMM d, ''yy'                Wed, Jul 10, '96
+///     'h:mm a'                          12:08 PM
+///     'hh 'o''clock' a, zzzz'           12 o'clock PM, Pacific Daylight Time
+///     'K:mm a, vvv'                     0:00 PM, PT
+///     'yyyyy.MMMMM.dd GGG hh:mm aaa'    01996.July.10 AD 12:08 PM
 ///
-/// When parsing a date string using the abbreviated year pattern ("yy"),
+/// When parsing a date string using the abbreviated year pattern ('yy'),
 /// DateFormat must interpret the abbreviated year relative to some
 /// century. It does this by adjusting dates to be within 80 years before and 20
 /// years after the time the parse function is called. For example, using a
-/// pattern of "MM/dd/yy" and a DateParse instance created on Jan 1, 1997,
-/// the string "01/11/12" would be interpreted as Jan 11, 2012 while the string
-/// "05/04/64" would be interpreted as May 4, 1964. During parsing, only
+/// pattern of 'MM/dd/yy' and a DateParse instance created on Jan 1, 1997,
+/// the string '01/11/12' would be interpreted as Jan 11, 2012 while the string
+/// '05/04/64' would be interpreted as May 4, 1964. During parsing, only
 /// strings consisting of exactly two digits will be parsed into the default
 /// century. Any other numeric string, such as a one digit string, a three or
 /// more digit string will be interpreted as its face value.
 ///
 /// If the year pattern does not have exactly two 'y' characters, the year is
 /// interpreted literally, regardless of the number of digits. So using the
-/// pattern "MM/dd/yyyy", "01/11/12" parses to Jan 11, 12 A.D.
+/// pattern 'MM/dd/yyyy', '01/11/12' parses to Jan 11, 12 A.D.
 
 class DateFormat {
   /// Creates a new DateFormat, using the format specified by [newPattern].
@@ -230,7 +233,7 @@
   /// new DateFormat('EEE, M/d/y');
   /// ```
   ///
-  /// would produce the same result, a date of the form "Wed, 6/27/2012".
+  /// would produce the same result, a date of the form 'Wed, 6/27/2012'.
   ///
   /// The first version would produce a different format string if used in
   /// another locale, but the second format would always be the same.
@@ -241,7 +244,7 @@
     // TODO(alanknight): It should be possible to specify multiple skeletons eg
     // date, time, timezone all separately. Adding many or named parameters to
     // the constructor seems awkward, especially with the possibility of
-    // confusion with the locale. A "fluent" interface with cascading on an
+    // confusion with the locale. A 'fluent' interface with cascading on an
     // instance might work better? A list of patterns is also possible.
     _locale = Intl.verifiedLocale(locale, localeExists);
     addPattern(newPattern);
@@ -251,8 +254,10 @@
   /// and internal format.
   String format(DateTime date) {
     // TODO(efortuna): read optional TimeZone argument (or similar)?
-    var result = new StringBuffer();
-    _formatFields.forEach((field) => result.write(field.format(date)));
+    var result = StringBuffer();
+    for (var field in _formatFields) {
+      result.write(field.format(date));
+    }
     return result.toString();
   }
 
@@ -280,7 +285,7 @@
   DateTime parse(String inputString, [bool utc = false]) =>
       _parse(inputString, utc: utc, strict: false);
 
-  /// Given user input, attempt to parse the [inputString] "loosely" into the
+  /// Given user input, attempt to parse the [inputString] 'loosely' into the
   /// anticipated format, accepting some variations from the strict format.
   ///
   /// If [inputString] is accepted by [parseStrict], just return the result. If
@@ -297,14 +302,14 @@
   ///
   /// For example, this will accept
   ///
-  ///       new DateFormat.yMMMd("en_US").parseLoose("SEp   3 2014");
-  ///       new DateFormat.yMd("en_US").parseLoose("09    03/2014");
-  ///       new DateFormat.yMd("en_US").parseLoose("09 / 03 / 2014");
+  ///       new DateFormat.yMMMd('en_US').parseLoose('SEp   3 2014');
+  ///       new DateFormat.yMd('en_US').parseLoose('09    03/2014');
+  ///       new DateFormat.yMd('en_US').parseLoose('09 / 03 / 2014');
   ///
   /// It will NOT accept
   ///
-  ///      // "Sept" is not a valid month name.
-  ///      new DateFormat.yMMMd("en_US").parseLoose("Sept 3, 2014");
+  ///      // 'Sept' is not a valid month name.
+  ///      new DateFormat.yMMMd('en_US').parseLoose('Sept 3, 2014');
   DateTime parseLoose(String inputString, [bool utc = false]) {
     try {
       return _parse(inputString, utc: utc, strict: true);
@@ -314,13 +319,15 @@
   }
 
   DateTime _parseLoose(String inputString, bool utc) {
-    var dateFields = new _DateBuilder();
+    var dateFields = _DateBuilder();
     if (utc) dateFields.utc = true;
-    var stream = new _Stream(inputString);
-    _formatFields.forEach((f) => f.parseLoose(stream, dateFields));
+    var stream = _Stream(inputString);
+    for (var field in _formatFields) {
+      field.parseLoose(stream, dateFields);
+    }
     if (!stream.atEnd()) {
-      throw new FormatException(
-          "Characters remaining after date parsing in $inputString");
+      throw FormatException(
+          'Characters remaining after date parsing in $inputString');
     }
     dateFields.verify(inputString);
     return dateFields.asDate();
@@ -337,17 +344,19 @@
   DateTime parseStrict(String inputString, [bool utc = false]) =>
       _parse(inputString, utc: utc, strict: true);
 
-  DateTime _parse(String inputString, {bool utc: false, bool strict: false}) {
+  DateTime _parse(String inputString, {bool utc = false, bool strict = false}) {
     // TODO(alanknight): The Closure code refers to special parsing of numeric
     // values with no delimiters, which we currently don't do. Should we?
-    var dateFields = new _DateBuilder();
+    var dateFields = _DateBuilder();
     if (utc) dateFields.utc = true;
-    dateFields._dateOnly = this.dateOnly;
-    var stream = new _Stream(inputString);
-    _formatFields.forEach((f) => f.parse(stream, dateFields));
+    dateFields._dateOnly = dateOnly;
+    var stream = _Stream(inputString);
+    for (var field in _formatFields) {
+      field.parse(stream, dateFields);
+    }
     if (strict && !stream.atEnd()) {
-      throw new FormatException(
-          "Characters remaining after date parsing in $inputString");
+      throw FormatException(
+          'Characters remaining after date parsing in $inputString');
     }
     if (strict) dateFields.verify(inputString);
     return dateFields.asDate();
@@ -382,25 +391,25 @@
   /// Returns a list of all locales for which we have date formatting
   /// information.
   static List<String> allLocalesWithSymbols() =>
-      new List<String>.from(dateTimeSymbols.keys);
+      List<String>.from(dateTimeSymbols.keys);
 
   /// The named constructors for this class are all conveniences for creating
-  /// instances using one of the known "skeleton" formats, and having code
+  /// instances using one of the known 'skeleton' formats, and having code
   /// completion support for discovering those formats.
   /// So,
   ///
   /// ```dart
-  /// new DateFormat.yMd("en_US")
+  /// new DateFormat.yMd('en_US')
   /// ```
   ///
   /// is equivalent to
   ///
   /// ```dart
-  /// new DateFormat("yMd", "en_US")
+  /// new DateFormat('yMd', 'en_US')
   /// ```
   ///
   /// To create a compound format you can use these constructors in combination
-  /// with the "add_*" methods below. e.g.
+  /// with the 'add_*' methods below. e.g.
   ///
   /// ```dart
   /// new DateFormat.yMd().add_Hms();
@@ -408,49 +417,49 @@
   ///
   /// If the optional [locale] is omitted, the format will be created using the
   /// default locale in [Intl.systemLocale].
-  DateFormat.d([locale]) : this("d", locale);
-  DateFormat.E([locale]) : this("E", locale);
-  DateFormat.EEEE([locale]) : this("EEEE", locale);
-  DateFormat.LLL([locale]) : this("LLL", locale);
-  DateFormat.LLLL([locale]) : this("LLLL", locale);
-  DateFormat.M([locale]) : this("M", locale);
-  DateFormat.Md([locale]) : this("Md", locale);
-  DateFormat.MEd([locale]) : this("MEd", locale);
-  DateFormat.MMM([locale]) : this("MMM", locale);
-  DateFormat.MMMd([locale]) : this("MMMd", locale);
-  DateFormat.MMMEd([locale]) : this("MMMEd", locale);
-  DateFormat.MMMM([locale]) : this("MMMM", locale);
-  DateFormat.MMMMd([locale]) : this("MMMMd", locale);
-  DateFormat.MMMMEEEEd([locale]) : this("MMMMEEEEd", locale);
-  DateFormat.QQQ([locale]) : this("QQQ", locale);
-  DateFormat.QQQQ([locale]) : this("QQQQ", locale);
-  DateFormat.y([locale]) : this("y", locale);
-  DateFormat.yM([locale]) : this("yM", locale);
-  DateFormat.yMd([locale]) : this("yMd", locale);
-  DateFormat.yMEd([locale]) : this("yMEd", locale);
-  DateFormat.yMMM([locale]) : this("yMMM", locale);
-  DateFormat.yMMMd([locale]) : this("yMMMd", locale);
-  DateFormat.yMMMEd([locale]) : this("yMMMEd", locale);
-  DateFormat.yMMMM([locale]) : this("yMMMM", locale);
-  DateFormat.yMMMMd([locale]) : this("yMMMMd", locale);
-  DateFormat.yMMMMEEEEd([locale]) : this("yMMMMEEEEd", locale);
-  DateFormat.yQQQ([locale]) : this("yQQQ", locale);
-  DateFormat.yQQQQ([locale]) : this("yQQQQ", locale);
-  DateFormat.H([locale]) : this("H", locale);
-  DateFormat.Hm([locale]) : this("Hm", locale);
-  DateFormat.Hms([locale]) : this("Hms", locale);
-  DateFormat.j([locale]) : this("j", locale);
-  DateFormat.jm([locale]) : this("jm", locale);
-  DateFormat.jms([locale]) : this("jms", locale);
-  DateFormat.jmv([locale]) : this("jmv", locale);
-  DateFormat.jmz([locale]) : this("jmz", locale);
-  DateFormat.jv([locale]) : this("jv", locale);
-  DateFormat.jz([locale]) : this("jz", locale);
-  DateFormat.m([locale]) : this("m", locale);
-  DateFormat.ms([locale]) : this("ms", locale);
-  DateFormat.s([locale]) : this("s", locale);
+  DateFormat.d([locale]) : this('d', locale);
+  DateFormat.E([locale]) : this('E', locale);
+  DateFormat.EEEE([locale]) : this('EEEE', locale);
+  DateFormat.LLL([locale]) : this('LLL', locale);
+  DateFormat.LLLL([locale]) : this('LLLL', locale);
+  DateFormat.M([locale]) : this('M', locale);
+  DateFormat.Md([locale]) : this('Md', locale);
+  DateFormat.MEd([locale]) : this('MEd', locale);
+  DateFormat.MMM([locale]) : this('MMM', locale);
+  DateFormat.MMMd([locale]) : this('MMMd', locale);
+  DateFormat.MMMEd([locale]) : this('MMMEd', locale);
+  DateFormat.MMMM([locale]) : this('MMMM', locale);
+  DateFormat.MMMMd([locale]) : this('MMMMd', locale);
+  DateFormat.MMMMEEEEd([locale]) : this('MMMMEEEEd', locale);
+  DateFormat.QQQ([locale]) : this('QQQ', locale);
+  DateFormat.QQQQ([locale]) : this('QQQQ', locale);
+  DateFormat.y([locale]) : this('y', locale);
+  DateFormat.yM([locale]) : this('yM', locale);
+  DateFormat.yMd([locale]) : this('yMd', locale);
+  DateFormat.yMEd([locale]) : this('yMEd', locale);
+  DateFormat.yMMM([locale]) : this('yMMM', locale);
+  DateFormat.yMMMd([locale]) : this('yMMMd', locale);
+  DateFormat.yMMMEd([locale]) : this('yMMMEd', locale);
+  DateFormat.yMMMM([locale]) : this('yMMMM', locale);
+  DateFormat.yMMMMd([locale]) : this('yMMMMd', locale);
+  DateFormat.yMMMMEEEEd([locale]) : this('yMMMMEEEEd', locale);
+  DateFormat.yQQQ([locale]) : this('yQQQ', locale);
+  DateFormat.yQQQQ([locale]) : this('yQQQQ', locale);
+  DateFormat.H([locale]) : this('H', locale);
+  DateFormat.Hm([locale]) : this('Hm', locale);
+  DateFormat.Hms([locale]) : this('Hms', locale);
+  DateFormat.j([locale]) : this('j', locale);
+  DateFormat.jm([locale]) : this('jm', locale);
+  DateFormat.jms([locale]) : this('jms', locale);
+  DateFormat.jmv([locale]) : this('jmv', locale);
+  DateFormat.jmz([locale]) : this('jmz', locale);
+  DateFormat.jv([locale]) : this('jv', locale);
+  DateFormat.jz([locale]) : this('jz', locale);
+  DateFormat.m([locale]) : this('m', locale);
+  DateFormat.ms([locale]) : this('ms', locale);
+  DateFormat.s([locale]) : this('s', locale);
 
-  /// The "add_*" methods append a particular skeleton to the format, or set
+  /// The 'add_*' methods append a particular skeleton to the format, or set
   /// it as the only format if none was previously set. These are primarily
   /// useful for creating compound formats. For example
   ///
@@ -459,47 +468,47 @@
   /// ```
   ///
   /// would create a date format that prints both the date and the time.
-  DateFormat add_d() => addPattern("d");
-  DateFormat add_E() => addPattern("E");
-  DateFormat add_EEEE() => addPattern("EEEE");
-  DateFormat add_LLL() => addPattern("LLL");
-  DateFormat add_LLLL() => addPattern("LLLL");
-  DateFormat add_M() => addPattern("M");
-  DateFormat add_Md() => addPattern("Md");
-  DateFormat add_MEd() => addPattern("MEd");
-  DateFormat add_MMM() => addPattern("MMM");
-  DateFormat add_MMMd() => addPattern("MMMd");
-  DateFormat add_MMMEd() => addPattern("MMMEd");
-  DateFormat add_MMMM() => addPattern("MMMM");
-  DateFormat add_MMMMd() => addPattern("MMMMd");
-  DateFormat add_MMMMEEEEd() => addPattern("MMMMEEEEd");
-  DateFormat add_QQQ() => addPattern("QQQ");
-  DateFormat add_QQQQ() => addPattern("QQQQ");
-  DateFormat add_y() => addPattern("y");
-  DateFormat add_yM() => addPattern("yM");
-  DateFormat add_yMd() => addPattern("yMd");
-  DateFormat add_yMEd() => addPattern("yMEd");
-  DateFormat add_yMMM() => addPattern("yMMM");
-  DateFormat add_yMMMd() => addPattern("yMMMd");
-  DateFormat add_yMMMEd() => addPattern("yMMMEd");
-  DateFormat add_yMMMM() => addPattern("yMMMM");
-  DateFormat add_yMMMMd() => addPattern("yMMMMd");
-  DateFormat add_yMMMMEEEEd() => addPattern("yMMMMEEEEd");
-  DateFormat add_yQQQ() => addPattern("yQQQ");
-  DateFormat add_yQQQQ() => addPattern("yQQQQ");
-  DateFormat add_H() => addPattern("H");
-  DateFormat add_Hm() => addPattern("Hm");
-  DateFormat add_Hms() => addPattern("Hms");
-  DateFormat add_j() => addPattern("j");
-  DateFormat add_jm() => addPattern("jm");
-  DateFormat add_jms() => addPattern("jms");
-  DateFormat add_jmv() => addPattern("jmv");
-  DateFormat add_jmz() => addPattern("jmz");
-  DateFormat add_jv() => addPattern("jv");
-  DateFormat add_jz() => addPattern("jz");
-  DateFormat add_m() => addPattern("m");
-  DateFormat add_ms() => addPattern("ms");
-  DateFormat add_s() => addPattern("s");
+  DateFormat add_d() => addPattern('d');
+  DateFormat add_E() => addPattern('E');
+  DateFormat add_EEEE() => addPattern('EEEE');
+  DateFormat add_LLL() => addPattern('LLL');
+  DateFormat add_LLLL() => addPattern('LLLL');
+  DateFormat add_M() => addPattern('M');
+  DateFormat add_Md() => addPattern('Md');
+  DateFormat add_MEd() => addPattern('MEd');
+  DateFormat add_MMM() => addPattern('MMM');
+  DateFormat add_MMMd() => addPattern('MMMd');
+  DateFormat add_MMMEd() => addPattern('MMMEd');
+  DateFormat add_MMMM() => addPattern('MMMM');
+  DateFormat add_MMMMd() => addPattern('MMMMd');
+  DateFormat add_MMMMEEEEd() => addPattern('MMMMEEEEd');
+  DateFormat add_QQQ() => addPattern('QQQ');
+  DateFormat add_QQQQ() => addPattern('QQQQ');
+  DateFormat add_y() => addPattern('y');
+  DateFormat add_yM() => addPattern('yM');
+  DateFormat add_yMd() => addPattern('yMd');
+  DateFormat add_yMEd() => addPattern('yMEd');
+  DateFormat add_yMMM() => addPattern('yMMM');
+  DateFormat add_yMMMd() => addPattern('yMMMd');
+  DateFormat add_yMMMEd() => addPattern('yMMMEd');
+  DateFormat add_yMMMM() => addPattern('yMMMM');
+  DateFormat add_yMMMMd() => addPattern('yMMMMd');
+  DateFormat add_yMMMMEEEEd() => addPattern('yMMMMEEEEd');
+  DateFormat add_yQQQ() => addPattern('yQQQ');
+  DateFormat add_yQQQQ() => addPattern('yQQQQ');
+  DateFormat add_H() => addPattern('H');
+  DateFormat add_Hm() => addPattern('Hm');
+  DateFormat add_Hms() => addPattern('Hms');
+  DateFormat add_j() => addPattern('j');
+  DateFormat add_jm() => addPattern('jm');
+  DateFormat add_jms() => addPattern('jms');
+  DateFormat add_jmv() => addPattern('jmv');
+  DateFormat add_jmz() => addPattern('jmz');
+  DateFormat add_jv() => addPattern('jv');
+  DateFormat add_jz() => addPattern('jz');
+  DateFormat add_m() => addPattern('m');
+  DateFormat add_ms() => addPattern('ms');
+  DateFormat add_s() => addPattern('s');
 
   /// For each of the skeleton formats we also allow the use of the
   /// corresponding ICU constant names.
@@ -569,33 +578,32 @@
 
   /// We are being asked to do formatting without having set any pattern.
   /// Use a default.
-  _useDefaultPattern() {
+  void _useDefaultPattern() {
     add_yMMMMd();
     add_jms();
   }
 
   /// A series of regular expressions used to parse a format string into its
   /// component fields.
-  static List<RegExp> _matchers = [
+  static final List<RegExp> _matchers = [
     // Quoted String - anything between single quotes, with escaping
     //   of single quotes by doubling them.
-    // e.g. in the pattern "hh 'o''clock'" will match 'o''clock'
-    new RegExp("^\'(?:[^\']|\'\')*\'"),
+    // e.g. in the pattern 'hh 'o''clock'' will match 'o''clock'
+    RegExp('^\'(?:[^\']|\'\')*\''),
     // Fields - any sequence of 1 or more of the same field characters.
-    // e.g. in "hh:mm:ss" will match hh, mm, and ss. But in "hms" would
+    // e.g. in 'hh:mm:ss' will match hh, mm, and ss. But in 'hms' would
     // match each letter individually.
-    new RegExp(
-        "^(?:G+|y+|M+|k+|S+|E+|a+|h+|K+|H+|c+|L+|Q+|d+|D+|m+|s+|v+|z+|Z+)"),
+    RegExp('^(?:G+|y+|M+|k+|S+|E+|a+|h+|K+|H+|c+|L+|Q+|d+|D+|m+|s+|v+|z+|Z+)'),
     // Everything else - A sequence that is not quotes or field characters.
-    // e.g. in "hh:mm:ss" will match the colons.
-    new RegExp("^[^\'GyMkSEahKHcLQdDmsvzZ]+")
+    // e.g. in 'hh:mm:ss' will match the colons.
+    RegExp('^[^\'GyMkSEahKHcLQdDmsvzZ]+')
   ];
 
   /// Set our pattern, appending it to any existing patterns. Also adds a single
   /// space to separate the two.
-  _appendPattern(String inputPattern, [String separator = ' ']) {
+  void _appendPattern(String inputPattern, [String separator = ' ']) {
     _pattern =
-        _pattern == null ? inputPattern : "$_pattern$separator$inputPattern";
+        _pattern == null ? inputPattern : '$_pattern$separator$inputPattern';
   }
 
   /// Add [inputPattern] to this instance as a pattern.
@@ -607,7 +615,7 @@
   /// pattern.
   DateFormat addPattern(String inputPattern, [String separator = ' ']) {
     // TODO(alanknight): This is an expensive operation. Caching recently used
-    // formats, or possibly introducing an entire "locale" object that would
+    // formats, or possibly introducing an entire 'locale' object that would
     // cache patterns for that locale could be a good optimization.
     // If we have already parsed the format fields, reset them.
     _formatFieldsPrivate = null;
@@ -621,12 +629,12 @@
   }
 
   /// Return the pattern that we use to format dates.
-  get pattern => _pattern;
+  String get pattern => _pattern;
 
   /// Return the skeletons for our current locale.
-  Map get _availableSkeletons => dateTimePatterns[locale];
+  Map<dynamic, dynamic> get _availableSkeletons => dateTimePatterns[locale];
 
-  /// Return the [DateSymbol] information for the locale.
+  /// Return the [DateSymbols] information for the locale.
   ///
   /// This can be useful to find lists like the names of weekdays or months in a
   /// locale, but the structure of this data may change, and it's generally
@@ -645,9 +653,9 @@
   /// Should a new DateFormat for [locale] have useNativeDigits true.
   ///
   /// For example, for locale 'ar' when this setting is true, DateFormat will
-  /// format using Eastern Arabic digits, e.g. "\u0660, \u0661, \u0662". If it
+  /// format using Eastern Arabic digits, e.g. '\u0660, \u0661, \u0662'. If it
   /// is false, a new DateFormat will format using ASCII digits.
-  static shouldUseNativeDigitsByDefaultFor(String locale) {
+  static bool shouldUseNativeDigitsByDefaultFor(String locale) {
     return _useNativeDigitsByDefault[locale] ?? true;
   }
 
@@ -655,12 +663,12 @@
   /// true.
   ///
   /// For example, for locale 'ar' when this setting is true, DateFormat will
-  /// format using Eastern Arabic digits, e.g. "\u0660, \u0661, \u0662". If it
+  /// format using Eastern Arabic digits, e.g. '\u0660, \u0661, \u0662'. If it
   /// is false, a new DateFormat will format using ASCII digits.
   ///
   /// If not indicated, the default value is true, so native digits will be
   /// used.
-  static useNativeDigitsByDefaultFor(String locale, bool value) {
+  static void useNativeDigitsByDefaultFor(String locale, bool value) {
     _useNativeDigitsByDefault[locale] = value;
   }
 
@@ -687,7 +695,7 @@
   ///
   /// Keys are the zero digits, and the values are matchers for digits in that
   /// locale.
-  static Map<String, RegExp> _digitMatchers = {};
+  static final Map<String, RegExp> _digitMatchers = {};
 
   RegExp _digitMatcher;
 
@@ -699,7 +707,7 @@
   }
 
   /// Hard-code the most common matcher, which has special RegExp syntax.
-  static final RegExp _asciiDigitMatcher = new RegExp(r'^\d+');
+  static final RegExp _asciiDigitMatcher = RegExp(r'^\d+');
 
   int _localeZeroCodeUnit;
 
@@ -713,7 +721,7 @@
 
   /// For performance, keep the zero digit available.
   String get localeZero => _localeZero == null
-      ? _localeZero = (useNativeDigits ? dateSymbols.ZERODIGIT ?? '0' : '0')
+      ? _localeZero = useNativeDigits ? dateSymbols.ZERODIGIT ?? '0' : '0'
       : _localeZero;
 
   // Does this use non-ASCII digits, e.g. Eastern Arabic.
@@ -727,23 +735,23 @@
   /// locale digits.
   String _localizeDigits(String numberString) {
     if (usesAsciiDigits) return numberString;
-    var newDigits = new List<int>(numberString.length);
+    var newDigits = List<int>(numberString.length);
     var oldDigits = numberString.codeUnits;
     for (var i = 0; i < numberString.length; i++) {
       newDigits[i] = oldDigits[i] + localeZeroCodeUnit - _asciiZeroCodeUnit;
     }
-    return new String.fromCharCodes(newDigits);
+    return String.fromCharCodes(newDigits);
   }
 
   /// A regular expression that matches for digits in a particular
   /// locale, defined by the digit for zero in that locale.
   RegExp _initDigitMatcher() {
     if (usesAsciiDigits) return _asciiDigitMatcher;
-    List<int> localeDigits = new Iterable.generate(10, (i) => i)
+    var localeDigits = Iterable.generate(10, (i) => i)
         .map((i) => localeZeroCodeUnit + i)
         .toList();
-    var localeDigitsString = new String.fromCharCodes(localeDigits);
-    return new RegExp(r'^[' + localeDigitsString + ']+');
+    var localeDigitsString = String.fromCharCodes(localeDigits);
+    return RegExp('^[$localeDigitsString]+');
   }
 
   /// Return true if the locale exists, or if it is null. The null case
@@ -753,11 +761,12 @@
     return dateTimeSymbols.containsKey(localeName);
   }
 
-  static List get _fieldConstructors => [
-        (pattern, parent) => new _DateFormatQuotedField(pattern, parent),
-        (pattern, parent) => new _DateFormatPatternField(pattern, parent),
-        (pattern, parent) => new _DateFormatLiteralField(pattern, parent)
-      ];
+  static List<_DateFormatField Function(String, DateFormat)>
+      get _fieldConstructors => [
+            (pattern, parent) => _DateFormatQuotedField(pattern, parent),
+            (pattern, parent) => _DateFormatPatternField(pattern, parent),
+            (pattern, parent) => _DateFormatLiteralField(pattern, parent)
+          ];
 
   /// Parse the template pattern and return a list of field objects.
   List<_DateFormatField> parsePattern(String pattern) {
diff --git a/lib/src/intl/date_format_field.dart b/lib/src/intl/date_format_field.dart
index 8c250d2..c5bc6fc 100644
--- a/lib/src/intl/date_format_field.dart
+++ b/lib/src/intl/date_format_field.dart
@@ -6,10 +6,10 @@
 
 /// This is a private class internal to DateFormat which is used for formatting
 /// particular fields in a template. e.g. if the format is hh:mm:ss then the
-/// fields would be "hh", ":", "mm", ":", and "ss". Each type of field knows
+/// fields would be 'hh', ':', 'mm', ':', and 'ss'. Each type of field knows
 /// how to format that portion of a date.
 abstract class _DateFormatField {
-  /// The format string that defines us, e.g. "hh"
+  /// The format string that defines us, e.g. 'hh'
   final String pattern;
 
   /// The DateFormat that we are part of.
@@ -84,8 +84,8 @@
 
   /// Throw a format exception with an error message indicating the position.
   void throwFormatException(_Stream stream) {
-    throw new FormatException("Trying to read $this from ${stream.contents} "
-        "at position ${stream.index}");
+    throw FormatException('Trying to read $this from ${stream.contents} '
+        'at position ${stream.index}');
   }
 }
 
@@ -95,11 +95,11 @@
 class _DateFormatLiteralField extends _DateFormatField {
   _DateFormatLiteralField(pattern, parent) : super(pattern, parent);
 
-  parse(_Stream input, _DateBuilder dateFields) {
+  void parse(_Stream input, _DateBuilder dateFields) {
     parseLiteral(input);
   }
 
-  parseLoose(_Stream input, _DateBuilder dateFields) =>
+  void parseLoose(_Stream input, _DateBuilder dateFields) =>
       parseLiteralLoose(input);
 }
 
@@ -115,14 +115,14 @@
     _fullPattern = pattern;
   }
 
-  parse(_Stream input, _DateBuilder dateFields) {
+  void parse(_Stream input, _DateBuilder dateFields) {
     parseLiteral(input);
   }
 
-  parseLoose(_Stream input, _DateBuilder dateFields) =>
+  void parseLoose(_Stream input, _DateBuilder dateFields) =>
       parseLiteralLoose(input);
 
-  static final _twoEscapedQuotes = new RegExp(r"''");
+  static final _twoEscapedQuotes = RegExp(r"''");
 
   static String _patchQuotes(String pattern) {
     if (pattern == "''") {
@@ -135,7 +135,7 @@
   }
 }
 
-/// A field that parses "loosely", meaning that we'll accept input that is
+/// A field that parses 'loosely', meaning that we'll accept input that is
 /// missing delimiters, has upper/lower case mixed up, and might not strictly
 /// conform to the pattern, e.g. the pattern calls for Sep we might accept
 /// sep, september, sEPTember. Doesn't affect numeric fields.
@@ -144,7 +144,7 @@
 
   /// Parse from a list of possibilities, but case-insensitively.
   /// Assumes that input is lower case.
-  int parseEnumeratedString(_Stream input, List possibilities) {
+  int parseEnumeratedString(_Stream input, List<String> possibilities) {
     var lowercasePossibilities =
         possibilities.map((x) => x.toLowerCase()).toList();
     try {
@@ -254,7 +254,7 @@
   /// into the correct place in dateFields. Allow looser parsing, accepting
   /// case-insensitive input and skipped delimiters.
   void parseLoose(_Stream input, _DateBuilder dateFields) {
-    new _LoosePatternField(pattern, parent).parse(input, dateFields);
+    _LoosePatternField(pattern, parent).parse(input, dateFields);
   }
 
   bool _forDate;
@@ -263,7 +263,7 @@
   /// time.
   ///
   /// The [pattern] will contain one or more of a particular format character,
-  /// e.g. "yyyy" for a four-digit year. This hard-codes all the pattern
+  /// e.g. 'yyyy' for a four-digit year. This hard-codes all the pattern
   /// characters that pertain to dates. The remaining characters, 'ahHkKms' are
   /// all time-related. See e.g. [formatField]
   bool get forDate => _forDate ??= 'cdDEGLMQvyZz'.contains(pattern[0]);
@@ -389,12 +389,12 @@
   /// Return the symbols for our current locale.
   DateSymbols get symbols => parent.dateSymbols;
 
-  formatEra(DateTime date) {
+  String formatEra(DateTime date) {
     var era = date.year > 0 ? 1 : 0;
     return width >= 4 ? symbols.ERANAMES[era] : symbols.ERAS[era];
   }
 
-  formatYear(DateTime date) {
+  String formatYear(DateTime date) {
     // TODO(alanknight): Proper handling of years <= 0
     var year = date.year;
     if (year < 0) {
@@ -404,13 +404,18 @@
   }
 
   /// We are given [input] as a stream from which we want to read a date. We
-  /// can't dynamically build up a date, so we are given a list [dateFields] of
-  /// the constructor arguments and an [position] at which to set it
-  /// (year,month,day,hour,minute,second,fractionalSecond)
-  /// then after all parsing is done we construct a date from the arguments.
+  /// can't dynamically build up a date, so the caller has a list of the
+  /// constructor arguments and a position at which to set it
+  /// (year,month,day,hour,minute,second,fractionalSecond) and gives us a setter
+  /// for it.
+  ///
+  /// Then after all parsing is done we construct a date from the
+  /// arguments.
+  ///
   /// This method handles reading any of the numeric fields. The [offset]
   /// argument allows us to compensate for zero-based versus one-based values.
-  void handleNumericField(_Stream input, Function setter, [int offset = 0]) {
+  void handleNumericField(_Stream input, void Function(num) setter,
+      [int offset = 0]) {
     var result = input.nextInteger(
         digitMatcher: parent.digitMatcher,
         zeroDigit: parent.localeZeroCodeUnit);
@@ -419,13 +424,16 @@
   }
 
   /// We are given [input] as a stream from which we want to read a date. We
-  /// can't dynamically build up a date, so we are given a list [dateFields] of
-  /// the constructor arguments and an [position] at which to set it
-  /// (year,month,day,hour,minute,second,fractionalSecond)
-  /// then after all parsing is done we construct a date from the arguments.
-  /// This method handles reading any of string fields from an enumerated set.
-  int parseEnumeratedString(_Stream input, List possibilities) {
-    var results = new _Stream(possibilities)
+  /// can't dynamically build up a date, so the caller has a list of the
+  /// constructor arguments and a position at which to set it
+  /// (year,month,day,hour,minute,second,fractionalSecond) and gives us a setter
+  /// for it.
+  ///
+  /// Then after all parsing is done we construct a date from the
+  /// arguments. This method handles reading any of string fields from an
+  /// enumerated set.
+  int parseEnumeratedString(_Stream input, List<String> possibilities) {
+    var results = _Stream(possibilities)
         .findIndexes((each) => input.peek(each.length) == each);
     if (results.isEmpty) throwFormatException(input);
     results.sort(
@@ -449,7 +457,7 @@
   }
 
   void parseMonth(input, dateFields) {
-    var possibilities;
+    List<String> possibilities;
     switch (width) {
       case 5:
         possibilities = symbols.NARROWMONTHS;
@@ -490,7 +498,7 @@
   }
 
   void parseAmPm(input, dateFields) {
-    // If we see a "PM" note it in an extra field.
+    // If we see a 'PM' note it in an extra field.
     var ampm = parseEnumeratedString(input, symbols.AMPMS);
     if (ampm == 1) dateFields.pm = true;
   }
@@ -530,7 +538,7 @@
 
   void parseStandaloneDay(_Stream input) {
     // This is ignored, but we still have to skip over it the correct amount.
-    var possibilities;
+    List<String> possibilities;
     switch (width) {
       case 5:
         possibilities = symbols.STANDALONENARROWWEEKDAYS;
@@ -561,7 +569,7 @@
   }
 
   void parseStandaloneMonth(input, dateFields) {
-    var possibilities;
+    List<String> possibilities;
     switch (width) {
       case 5:
         possibilities = symbols.STANDALONENARROWMONTHS;
@@ -625,15 +633,15 @@
 
   String formatTimeZoneId(DateTime date) {
     // TODO(alanknight): implement time zone support
-    throw new UnimplementedError();
+    throw UnimplementedError();
   }
 
   String formatTimeZone(DateTime date) {
-    throw new UnimplementedError();
+    throw UnimplementedError();
   }
 
   String formatTimeZoneRFC(DateTime date) {
-    throw new UnimplementedError();
+    throw UnimplementedError();
   }
 
   /// Return a string representation of the object padded to the left with
diff --git a/lib/src/intl/date_format_helpers.dart b/lib/src/intl/date_format_helpers.dart
index 7781c77..8193a47 100644
--- a/lib/src/intl/date_format_helpers.dart
+++ b/lib/src/intl/date_format_helpers.dart
@@ -19,7 +19,7 @@
 /// Return true if this is a leap year. Rely on [DateTime] to do the
 /// underlying calculation, even though it doesn't expose the test to us.
 bool _isLeapYear(DateTime date) {
-  var feb29 = new DateTime(date.year, 2, 29);
+  var feb29 = DateTime(date.year, 2, 29);
   return feb29.month == 2;
 }
 
@@ -54,7 +54,10 @@
   /// bad. Compensate by adjusting the time portion forward. But only do that
   /// when we're explicitly trying to construct a date, which we can tell from
   /// the format.
-  bool _dateOnly = false;
+
+  // We do set it, the analyzer just can't tell.
+  // ignore: prefer_final_fields
+  var _dateOnly = false;
 
   // Functions that exist just to be closurized so we can pass them to a general
   // method.
@@ -86,22 +89,22 @@
     fractionalSecond = x;
   }
 
-  get hour24 => pm ? hour + 12 : hour;
+  int get hour24 => pm ? hour + 12 : hour;
 
   /// Verify that we correspond to a valid date. This will reject out of
   /// range values, even if the DateTime constructor would accept them. An
   /// invalid message will result in throwing a [FormatException].
-  verify(String s) {
-    _verify(month, 1, 12, "month", s);
-    _verify(hour24, 0, 23, "hour", s);
-    _verify(minute, 0, 59, "minute", s);
-    _verify(second, 0, 59, "second", s);
-    _verify(fractionalSecond, 0, 999, "fractional second", s);
+  void verify(String s) {
+    _verify(month, 1, 12, 'month', s);
+    _verify(hour24, 0, 23, 'hour', s);
+    _verify(minute, 0, 59, 'minute', s);
+    _verify(second, 0, 59, 'second', s);
+    _verify(fractionalSecond, 0, 999, 'fractional second', s);
     // Verifying the day is tricky, because it depends on the month. Create
     // our resulting date and then verify that our values agree with it
     // as an additional verification. And since we're doing that, also
     // check the year, which we otherwise can't verify, and the hours,
-    // which will catch cases like "14:00:00 PM".
+    // which will catch cases like '14:00:00 PM'.
     var date = asDate();
     // On rare occasions, possibly related to DST boundaries, a parsed date will
     // come out as 1:00am. We compensate for the case of going backwards in
@@ -109,42 +112,42 @@
     // that doesn't exist. So tolerate an hour value of zero or one in these
     // cases.
     var minimumDate = _dateOnly && date.hour == 1 ? 0 : date.hour;
-    _verify(hour24, minimumDate, date.hour, "hour", s, date);
+    _verify(hour24, minimumDate, date.hour, 'hour', s, date);
     if (day > 31) {
       // We have an ordinal date, compute the corresponding date for the result
       // and compare to that.
       var leapYear = _isLeapYear(date);
       var correspondingDay = _dayOfYear(date.month, date.day, leapYear);
-      _verify(day, correspondingDay, correspondingDay, "day", s, date);
+      _verify(day, correspondingDay, correspondingDay, 'day', s, date);
     } else {
       // We have the day of the month, compare directly.
-      _verify(day, date.day, date.day, "day", s, date);
+      _verify(day, date.day, date.day, 'day', s, date);
     }
-    _verify(year, date.year, date.year, "year", s, date);
+    _verify(year, date.year, date.year, 'year', s, date);
   }
 
-  _verify(int value, int min, int max, String desc, String originalInput,
+  void _verify(int value, int min, int max, String desc, String originalInput,
       [DateTime parsed]) {
     if (value < min || value > max) {
-      var parsedDescription = parsed == null ? "" : " Date parsed as $parsed.";
-      throw new FormatException(
-          "Error parsing $originalInput, invalid $desc value: $value."
-          " Expected value between $min and $max.$parsedDescription");
+      var parsedDescription = parsed == null ? '' : ' Date parsed as $parsed.';
+      throw FormatException(
+          'Error parsing $originalInput, invalid $desc value: $value.'
+          ' Expected value between $min and $max.$parsedDescription');
     }
   }
 
   /// Return a date built using our values. If no date portion is set,
-  /// use the "Epoch" of January 1, 1970.
-  DateTime asDate({int retries: 3}) {
+  /// use the 'Epoch' of January 1, 1970.
+  DateTime asDate({int retries = 3}) {
     // TODO(alanknight): Validate the date, especially for things which
     // can crash the VM, e.g. large month values.
 
     if (utc) {
-      return new DateTime.utc(
+      return DateTime.utc(
           year, month, day, hour24, minute, second, fractionalSecond);
     } else {
-      var preliminaryResult = new DateTime(
-          year, month, day, hour24, minute, second, fractionalSecond);
+      var preliminaryResult =
+          DateTime(year, month, day, hour24, minute, second, fractionalSecond);
       return _correctForErrors(preliminaryResult, retries);
     }
   }
@@ -187,7 +190,7 @@
         result.isUtc &&
         (result.hour != hour24 ||
             result.day != correspondingDay ||
-            !new DateTime.now().isUtc)) {
+            !DateTime.now().isUtc)) {
       // This may be a UTC failure. Retry and if the result doesn't look
       // like it's in the UTC time zone, use that instead.
       return asDate(retries: retries - 1);
@@ -199,9 +202,10 @@
       // same day that's all right for a date. It gets the day correct, and we
       // have no way to even represent midnight on a day when it doesn't
       // happen.
-      var adjusted = result.add(new Duration(hours: (24 - result.hour)));
-      if (_dayOfYear(adjusted.month, adjusted.day, leapYear) == day)
+      var adjusted = result.add(Duration(hours: 24 - result.hour));
+      if (_dayOfYear(adjusted.month, adjusted.day, leapYear) == day) {
         return adjusted;
+      }
     }
     return result;
   }
@@ -216,18 +220,18 @@
 // strings, or else make the implementation trivial. And consider renaming,
 // as _Stream is now just confusing with the system Streams.
 class _Stream {
-  var contents;
+  dynamic contents;
   int index = 0;
 
   _Stream(this.contents);
 
   bool atEnd() => index >= contents.length;
 
-  next() => contents[index++];
+  dynamic next() => contents[index++];
 
   /// Return the next [howMany] items, or as many as there are remaining.
   /// Advance the stream by that many positions.
-  read([int howMany = 1]) {
+  dynamic read([int howMany = 1]) {
     var result = peek(howMany);
     index += howMany;
     return result;
@@ -242,8 +246,8 @@
 
   /// Return the next [howMany] items, or as many as there are remaining.
   /// Does not modify the stream position.
-  peek([int howMany = 1]) {
-    var result;
+  dynamic peek([int howMany = 1]) {
+    dynamic result;
     if (contents is String) {
       String stringContents = contents;
       result = stringContents.substring(
@@ -256,7 +260,7 @@
   }
 
   /// Return the remaining contents of the stream
-  rest() => peek(contents.length - index);
+  dynamic rest() => peek(contents.length - index);
 
   /// Find the index of the first element for which [f] returns true.
   /// Advances the stream to that position.
@@ -269,7 +273,7 @@
 
   /// Find the indexes of all the elements for which [f] returns true.
   /// Leaves the stream positioned at the end.
-  List findIndexes(Function f) {
+  List<dynamic> findIndexes(Function f) {
     var results = [];
     while (!atEnd()) {
       if (f(next())) results.add(index - 1);
@@ -291,11 +295,11 @@
     if (zeroDigit != null && zeroDigit != DateFormat._asciiZeroCodeUnit) {
       // Trying to optimize this, as it might get called a lot.
       var oldDigits = string.codeUnits;
-      var newDigits = new List<int>(string.length);
+      var newDigits = List<int>(string.length);
       for (var i = 0; i < string.length; i++) {
         newDigits[i] = oldDigits[i] - zeroDigit + DateFormat._asciiZeroCodeUnit;
       }
-      string = new String.fromCharCodes(newDigits);
+      string = String.fromCharCodes(newDigits);
     }
     return int.parse(string);
   }
diff --git a/lib/src/intl/number_format.dart b/lib/src/intl/number_format.dart
index 0185472..c92560b 100644
--- a/lib/src/intl/number_format.dart
+++ b/lib/src/intl/number_format.dart
@@ -4,9 +4,11 @@
 
 part of intl;
 
+// ignore_for_file: constant_identifier_names
+
 /// The function that we pass internally to NumberFormat to get
 /// the appropriate pattern (e.g. currency)
-typedef String _PatternGetter(NumberSymbols symbols);
+typedef _PatternGetter = String Function(NumberSymbols);
 
 /// Provides the ability to format a number in a locale-specific way. The
 /// format is specified as a pattern using a subset of the ICU formatting
@@ -165,12 +167,12 @@
   /// single-threaded and unless we do an asynchronous operation in the process
   /// of formatting then there will only ever be one number being formatted
   /// at a time. In languages with threads we'd need to pass this on the stack.
-  final StringBuffer _buffer = new StringBuffer();
+  final StringBuffer _buffer = StringBuffer();
 
   /// Create a number format that prints using [newPattern] as it applies in
   /// [locale].
   factory NumberFormat([String newPattern, String locale]) =>
-      new NumberFormat._forPattern(locale, (x) => newPattern);
+      NumberFormat._forPattern(locale, (x) => newPattern);
 
   /// Create a number format that prints as DECIMAL_PATTERN.
   NumberFormat.decimalPattern([String locale])
@@ -191,25 +193,24 @@
 
   /// A regular expression to validate currency names are exactly three
   /// alphabetic characters.
-  static final _checkCurrencyName = new RegExp(r'^[a-zA-Z]{3}$');
+  static final _checkCurrencyName = RegExp(r'^[a-zA-Z]{3}$');
 
   /// Create a number format that prints as CURRENCY_PATTERN. (Deprecated:
   /// prefer NumberFormat.currency)
   ///
   /// If provided,
-  /// use [nameOrSymbol] in place of the default currency name. e.g.
+  /// use [currencyNameOrSymbol] in place of the default currency name. e.g.
   ///        var eurosInCurrentLocale = new NumberFormat
   ///            .currencyPattern(Intl.defaultLocale, "€");
-  @Deprecated("Use NumberFormat.currency")
+  @Deprecated('Use NumberFormat.currency')
   factory NumberFormat.currencyPattern(
       [String locale, String currencyNameOrSymbol]) {
     // If it looks like an iso4217 name, pass as name, otherwise as symbol.
     if (currencyNameOrSymbol != null &&
         _checkCurrencyName.hasMatch(currencyNameOrSymbol)) {
-      return new NumberFormat.currency(
-          locale: locale, name: currencyNameOrSymbol);
+      return NumberFormat.currency(locale: locale, name: currencyNameOrSymbol);
     } else {
-      return new NumberFormat.currency(
+      return NumberFormat.currency(
           locale: locale, symbol: currencyNameOrSymbol);
     }
   }
@@ -287,7 +288,7 @@
   /// will format with two, which is the default for that locale.
   factory NumberFormat.simpleCurrency(
       {String locale, String name, int decimalDigits}) {
-    return new NumberFormat._forPattern(locale, (x) => x.CURRENCY_PATTERN,
+    return NumberFormat._forPattern(locale, (x) => x.CURRENCY_PATTERN,
         name: name,
         computeCurrencySymbol: (format) =>
             _simpleCurrencySymbols[format.currencyName] ?? format.currencyName,
@@ -323,167 +324,167 @@
   ///
   /// (The current implementation is the same for all locales, but this is
   /// temporary and callers shouldn't rely on it.)
-  static Map<String, String> _simpleCurrencySymbols = {
-    "AFN": "Af.",
-    "TOP": r"T$",
-    "MGA": "Ar",
-    "THB": "\u0e3f",
-    "PAB": "B/.",
-    "ETB": "Birr",
-    "VEF": "Bs",
-    "BOB": "Bs",
-    "GHS": "GHS",
-    "CRC": "\u20a1",
-    "NIO": r"C$",
-    "GMD": "GMD",
-    "MKD": "din",
-    "BHD": "din",
-    "DZD": "din",
-    "IQD": "din",
-    "JOD": "din",
-    "KWD": "din",
-    "LYD": "din",
-    "RSD": "din",
-    "TND": "din",
-    "AED": "dh",
-    "MAD": "dh",
-    "STD": "Db",
-    "BSD": r"$",
-    "FJD": r"$",
-    "GYD": r"$",
-    "KYD": r"$",
-    "LRD": r"$",
-    "SBD": r"$",
-    "SRD": r"$",
-    "AUD": r"$",
-    "BBD": r"$",
-    "BMD": r"$",
-    "BND": r"$",
-    "BZD": r"$",
-    "CAD": r"$",
-    "HKD": r"$",
-    "JMD": r"$",
-    "NAD": r"$",
-    "NZD": r"$",
-    "SGD": r"$",
-    "TTD": r"$",
-    "TWD": r"NT$",
-    "USD": r"$",
-    "XCD": r"$",
-    "VND": "\u20ab",
-    "AMD": "Dram",
-    "CVE": "CVE",
-    "EUR": "\u20ac",
-    "AWG": "Afl.",
-    "HUF": "Ft",
-    "BIF": "FBu",
-    "CDF": "FrCD",
-    "CHF": "CHF",
-    "DJF": "Fdj",
-    "GNF": "FG",
-    "RWF": "RF",
-    "XOF": "CFA",
-    "XPF": "FCFP",
-    "KMF": "CF",
-    "XAF": "FCFA",
-    "HTG": "HTG",
-    "PYG": "Gs",
-    "UAH": "\u20b4",
-    "PGK": "PGK",
-    "LAK": "\u20ad",
-    "CZK": "K\u010d",
-    "SEK": "kr",
-    "ISK": "kr",
-    "DKK": "kr",
-    "NOK": "kr",
-    "HRK": "kn",
-    "MWK": "MWK",
-    "ZMK": "ZWK",
-    "AOA": "Kz",
-    "MMK": "K",
-    "GEL": "GEL",
-    "LVL": "Ls",
-    "ALL": "Lek",
-    "HNL": "L",
-    "SLL": "SLL",
-    "MDL": "MDL",
-    "RON": "RON",
-    "BGN": "lev",
-    "SZL": "SZL",
-    "TRY": "TL",
-    "LTL": "Lt",
-    "LSL": "LSL",
-    "AZN": "man.",
-    "BAM": "KM",
-    "MZN": "MTn",
-    "NGN": "\u20a6",
-    "ERN": "Nfk",
-    "BTN": "Nu.",
-    "MRO": "MRO",
-    "MOP": "MOP",
-    "CUP": r"$",
-    "CUC": r"$",
-    "ARS": r"$",
-    "CLF": "UF",
-    "CLP": r"$",
-    "COP": r"$",
-    "DOP": r"$",
-    "MXN": r"$",
-    "PHP": "\u20b1",
-    "UYU": r"$",
-    "FKP": "£",
-    "GIP": "£",
-    "SHP": "£",
-    "EGP": "E£",
-    "LBP": "L£",
-    "SDG": "SDG",
-    "SSP": "SSP",
-    "GBP": "£",
-    "SYP": "£",
-    "BWP": "P",
-    "GTQ": "Q",
-    "ZAR": "R",
-    "BRL": r"R$",
-    "OMR": "Rial",
-    "QAR": "Rial",
-    "YER": "Rial",
-    "IRR": "Rial",
-    "KHR": "Riel",
-    "MYR": "RM",
-    "SAR": "Riyal",
-    "BYR": "BYR",
-    "RUB": "руб.",
-    "MUR": "Rs",
-    "SCR": "SCR",
-    "LKR": "Rs",
-    "NPR": "Rs",
-    "INR": "\u20b9",
-    "PKR": "Rs",
-    "IDR": "Rp",
-    "ILS": "\u20aa",
-    "KES": "Ksh",
-    "SOS": "SOS",
-    "TZS": "TSh",
-    "UGX": "UGX",
-    "PEN": "S/.",
-    "KGS": "KGS",
-    "UZS": "so\u02bcm",
-    "TJS": "Som",
-    "BDT": "\u09f3",
-    "WST": "WST",
-    "KZT": "\u20b8",
-    "MNT": "\u20ae",
-    "VUV": "VUV",
-    "KPW": "\u20a9",
-    "KRW": "\u20a9",
-    "JPY": "¥",
-    "CNY": "¥",
-    "PLN": "z\u0142",
-    "MVR": "Rf",
-    "NLG": "NAf",
-    "ZMW": "ZK",
-    "ANG": "ƒ",
-    "TMT": "TMT",
+  static final Map<String, String> _simpleCurrencySymbols = {
+    'AFN': 'Af.',
+    'TOP': r'T$',
+    'MGA': 'Ar',
+    'THB': '\u0e3f',
+    'PAB': 'B/.',
+    'ETB': 'Birr',
+    'VEF': 'Bs',
+    'BOB': 'Bs',
+    'GHS': 'GHS',
+    'CRC': '\u20a1',
+    'NIO': r'C$',
+    'GMD': 'GMD',
+    'MKD': 'din',
+    'BHD': 'din',
+    'DZD': 'din',
+    'IQD': 'din',
+    'JOD': 'din',
+    'KWD': 'din',
+    'LYD': 'din',
+    'RSD': 'din',
+    'TND': 'din',
+    'AED': 'dh',
+    'MAD': 'dh',
+    'STD': 'Db',
+    'BSD': r'$',
+    'FJD': r'$',
+    'GYD': r'$',
+    'KYD': r'$',
+    'LRD': r'$',
+    'SBD': r'$',
+    'SRD': r'$',
+    'AUD': r'$',
+    'BBD': r'$',
+    'BMD': r'$',
+    'BND': r'$',
+    'BZD': r'$',
+    'CAD': r'$',
+    'HKD': r'$',
+    'JMD': r'$',
+    'NAD': r'$',
+    'NZD': r'$',
+    'SGD': r'$',
+    'TTD': r'$',
+    'TWD': r'NT$',
+    'USD': r'$',
+    'XCD': r'$',
+    'VND': '\u20ab',
+    'AMD': 'Dram',
+    'CVE': 'CVE',
+    'EUR': '\u20ac',
+    'AWG': 'Afl.',
+    'HUF': 'Ft',
+    'BIF': 'FBu',
+    'CDF': 'FrCD',
+    'CHF': 'CHF',
+    'DJF': 'Fdj',
+    'GNF': 'FG',
+    'RWF': 'RF',
+    'XOF': 'CFA',
+    'XPF': 'FCFP',
+    'KMF': 'CF',
+    'XAF': 'FCFA',
+    'HTG': 'HTG',
+    'PYG': 'Gs',
+    'UAH': '\u20b4',
+    'PGK': 'PGK',
+    'LAK': '\u20ad',
+    'CZK': 'K\u010d',
+    'SEK': 'kr',
+    'ISK': 'kr',
+    'DKK': 'kr',
+    'NOK': 'kr',
+    'HRK': 'kn',
+    'MWK': 'MWK',
+    'ZMK': 'ZWK',
+    'AOA': 'Kz',
+    'MMK': 'K',
+    'GEL': 'GEL',
+    'LVL': 'Ls',
+    'ALL': 'Lek',
+    'HNL': 'L',
+    'SLL': 'SLL',
+    'MDL': 'MDL',
+    'RON': 'RON',
+    'BGN': 'lev',
+    'SZL': 'SZL',
+    'TRY': 'TL',
+    'LTL': 'Lt',
+    'LSL': 'LSL',
+    'AZN': 'man.',
+    'BAM': 'KM',
+    'MZN': 'MTn',
+    'NGN': '\u20a6',
+    'ERN': 'Nfk',
+    'BTN': 'Nu.',
+    'MRO': 'MRO',
+    'MOP': 'MOP',
+    'CUP': r'$',
+    'CUC': r'$',
+    'ARS': r'$',
+    'CLF': 'UF',
+    'CLP': r'$',
+    'COP': r'$',
+    'DOP': r'$',
+    'MXN': r'$',
+    'PHP': '\u20b1',
+    'UYU': r'$',
+    'FKP': '£',
+    'GIP': '£',
+    'SHP': '£',
+    'EGP': 'E£',
+    'LBP': 'L£',
+    'SDG': 'SDG',
+    'SSP': 'SSP',
+    'GBP': '£',
+    'SYP': '£',
+    'BWP': 'P',
+    'GTQ': 'Q',
+    'ZAR': 'R',
+    'BRL': r'R$',
+    'OMR': 'Rial',
+    'QAR': 'Rial',
+    'YER': 'Rial',
+    'IRR': 'Rial',
+    'KHR': 'Riel',
+    'MYR': 'RM',
+    'SAR': 'Riyal',
+    'BYR': 'BYR',
+    'RUB': 'руб.',
+    'MUR': 'Rs',
+    'SCR': 'SCR',
+    'LKR': 'Rs',
+    'NPR': 'Rs',
+    'INR': '\u20b9',
+    'PKR': 'Rs',
+    'IDR': 'Rp',
+    'ILS': '\u20aa',
+    'KES': 'Ksh',
+    'SOS': 'SOS',
+    'TZS': 'TSh',
+    'UGX': 'UGX',
+    'PEN': 'S/.',
+    'KGS': 'KGS',
+    'UZS': 'so\u02bcm',
+    'TJS': 'Som',
+    'BDT': '\u09f3',
+    'WST': 'WST',
+    'KZT': '\u20b8',
+    'MNT': '\u20ae',
+    'VUV': 'VUV',
+    'KPW': '\u20a9',
+    'KRW': '\u20a9',
+    'JPY': '¥',
+    'CNY': '¥',
+    'PLN': 'z\u0142',
+    'MVR': 'Rf',
+    'NLG': 'NAf',
+    'ZMW': 'ZK',
+    'ANG': 'ƒ',
+    'TMT': 'TMT',
   };
 
   /// Create a number format that prints in a pattern we get from
@@ -495,20 +496,20 @@
   NumberFormat._forPattern(String locale, _PatternGetter getPattern,
       {String name,
       String currencySymbol,
-      String computeCurrencySymbol(NumberFormat),
+      String Function(NumberFormat) computeCurrencySymbol,
       int decimalDigits,
-      bool isForCurrency: false})
+      bool isForCurrency = false})
       : _locale = Intl.verifiedLocale(locale, localeExists),
         _isForCurrency = isForCurrency {
-    this._currencySymbol = currencySymbol;
-    this._decimalDigits = decimalDigits;
+    _currencySymbol = currencySymbol;
+    _decimalDigits = decimalDigits;
     _symbols = numberFormatSymbols[_locale];
     _localeZero = _symbols.ZERO_DIGIT.codeUnitAt(0);
     _zeroOffset = _localeZero - _zero;
     _negativePrefix = _symbols.MINUS_SIGN;
     currencyName = name ?? _symbols.DEF_CURRENCY_CODE;
-    if (this._currencySymbol == null && computeCurrencySymbol != null) {
-      this._currencySymbol = computeCurrencySymbol(this);
+    if (_currencySymbol == null && computeCurrencySymbol != null) {
+      _currencySymbol = computeCurrencySymbol(this);
     }
     _setPattern(getPattern(_symbols));
   }
@@ -516,7 +517,7 @@
   /// A number format for compact representations, e.g. "1.2M" instead
   /// of "1,200,000".
   factory NumberFormat.compact({String locale}) {
-    return new _CompactNumberFormat(
+    return _CompactNumberFormat(
         locale: locale,
         formatType: _CompactFormatType.COMPACT_DECIMAL_SHORT_PATTERN);
   }
@@ -524,7 +525,7 @@
   /// A number format for "long" compact representations, e.g. "1.2 million"
   /// instead of of "1,200,000".
   factory NumberFormat.compactLong({String locale}) {
-    return new _CompactNumberFormat(
+    return _CompactNumberFormat(
         locale: locale,
         formatType: _CompactFormatType.COMPACT_DECIMAL_LONG_PATTERN);
   }
@@ -535,7 +536,7 @@
   /// [NumberFormat.simpleCurrency].
   factory NumberFormat.compactSimpleCurrency(
       {String locale, String name, int decimalDigits}) {
-    return new _CompactNumberFormat(
+    return _CompactNumberFormat(
         locale: locale,
         formatType: _CompactFormatType.COMPACT_DECIMAL_SHORT_CURRENCY_PATTERN,
         name: name,
@@ -550,7 +551,7 @@
   /// of "$1,200,000".
   factory NumberFormat.compactCurrency(
       {String locale, String name, String symbol, int decimalDigits}) {
-    return new _CompactNumberFormat(
+    return _CompactNumberFormat(
         locale: locale,
         formatType: _CompactFormatType.COMPACT_DECIMAL_SHORT_CURRENCY_PATTERN,
         name: name,
@@ -577,7 +578,7 @@
   /// Format [number] according to our pattern and return the formatted string.
   String format(number) {
     if (_isNaN(number)) return symbols.NAN;
-    if (_isInfinite(number)) return "${_signPrefix(number)}${symbols.INFINITY}";
+    if (_isInfinite(number)) return '${_signPrefix(number)}${symbols.INFINITY}';
 
     _add(_signPrefix(number));
     _formatNumber(number.abs());
@@ -590,7 +591,7 @@
 
   /// Parse the number represented by the string. If it's not
   /// parseable, throws a [FormatException].
-  num parse(String text) => new _NumberParser(this, text).value;
+  num parse(String text) => _NumberParser(this, text).value;
 
   /// Format the main part of the number in the form dictated by the pattern.
   void _formatNumber(number) {
@@ -656,24 +657,24 @@
 
   /// Helpers to check numbers that don't conform to the [num] interface,
   /// e.g. Int64
-  _isInfinite(number) => number is num ? number.isInfinite : false;
-  _isNaN(number) => number is num ? number.isNaN : false;
+  bool _isInfinite(number) => number is num ? number.isInfinite : false;
+  bool _isNaN(number) => number is num ? number.isNaN : false;
 
   /// Helper to get the floor of a number which might not be num. This should
   /// only ever be called with an argument which is positive, or whose abs()
   ///  is negative. The second case is the maximum negative value on a
   ///  fixed-length integer. Since they are integers, they are also their own
   ///  floor.
-  _floor(number) {
-    if (number.isNegative && !(number.abs().isNegative)) {
-      throw new ArgumentError(
-          "Internal error: expected positive number, got $number");
+  dynamic _floor(dynamic number) {
+    if (number.isNegative && !number.abs().isNegative) {
+      throw ArgumentError(
+          'Internal error: expected positive number, got $number');
     }
     return (number is num) ? number.floor() : number ~/ 1;
   }
 
   /// Helper to round a number which might not be num.
-  _round(number) {
+  dynamic _round(dynamic number) {
     if (number is num) {
       if (number.isInfinite) {
         return _maxInt;
@@ -722,14 +723,14 @@
       max(0, remainingSignificantDigits);
 
   /// Format the basic number portion, including the fractional digits.
-  void _formatFixed(number) {
-    var integerPart;
+  void _formatFixed(dynamic number) {
+    dynamic integerPart;
     int fractionPart;
     int extraIntegerDigits;
     var fractionDigits = maximumFractionDigits;
 
     var power = 0;
-    var digitMultiplier;
+    int digitMultiplier;
 
     if (_isInfinite(number)) {
       integerPart = number.toInt();
@@ -790,7 +791,7 @@
     if (_hasIntegerDigits(integerDigits)) {
       // Add the padding digits to the regular digits so that we get grouping.
       var padding = '0' * (minimumIntegerDigits - digitLength);
-      integerDigits = "$padding$integerDigits";
+      integerDigits = '$padding$integerDigits';
       digitLength = integerDigits.length;
       for (var i = 0; i < digitLength; i++) {
         _addDigit(integerDigits.codeUnitAt(i));
@@ -826,7 +827,7 @@
     var intDigits = _mainIntegerDigits(integerPart);
     var paddedExtra =
         intDigits.isEmpty ? extra : extra.padLeft(_multiplierDigits, '0');
-    return "${intDigits}${paddedExtra}${paddingDigits}";
+    return '$intDigits$paddedExtra$paddingDigits';
   }
 
   /// The digit string of the integer part. This is the empty string if the
@@ -898,7 +899,7 @@
     for (var i = 0; i < numberOfDigits - basic.length; i++) {
       _add(symbols.ZERO_DIGIT);
     }
-    for (int i = 0; i < basic.length; i++) {
+    for (var i = 0; i < basic.length; i++) {
       _addDigit(basic.codeUnitAt(i));
     }
   }
@@ -946,8 +947,8 @@
     if (newPattern == null) return;
     // Make spaces non-breaking
     _pattern = newPattern.replaceAll(' ', '\u00a0');
-    var parser = new _NumberFormatParser(
-        this, newPattern, currencySymbol, decimalDigits);
+    var parser =
+        _NumberFormatParser(this, newPattern, currencySymbol, decimalDigits);
     parser.parse();
     if (_overridesDecimalDigits) {
       _decimalDigits ??= _defaultDecimalDigits;
@@ -965,7 +966,7 @@
     _finalGroupingSize = 0;
   }
 
-  String toString() => "NumberFormat($_locale, $_pattern)";
+  String toString() => 'NumberFormat($_locale, $_pattern)';
 }
 
 ///  A one-time object for parsing a particular numeric string. One-time here
@@ -990,7 +991,7 @@
   NumberSymbols get symbols => format.symbols;
 
   /// Where we accumulate the normalized representation of the number.
-  final StringBuffer _normalized = new StringBuffer();
+  final StringBuffer _normalized = StringBuffer();
 
   /// Did we see something that indicates this is, or at least might be,
   /// a positive number.
@@ -1025,9 +1026,7 @@
   int get _localeZero => format._localeZero;
 
   ///  Create a new [_NumberParser] on which we can call parse().
-  _NumberParser(this.format, text)
-      : this.text = text,
-        this.input = new _Stream(text) {
+  _NumberParser(this.format, this.text) : input = _Stream(text) {
     scale = format._internalMultiplier;
     value = parse();
   }
@@ -1035,7 +1034,7 @@
   ///  The strings we might replace with functions that return the replacement
   /// values. They are functions because we might need to check something
   /// in the context. Note that the ordering is important here. For example,
-  /// [symbols.PERCENT] might be " %", and we must handle that before we
+  /// `symbols.PERCENT` might be " %", and we must handle that before we
   /// look at an individual space.
   Map<String, Function> get replacements =>
       _replacements ??= _initializeReplacements();
@@ -1060,14 +1059,14 @@
         '-': () => '-',
       };
 
-  invalidFormat() =>
-      throw new FormatException("Invalid number: ${input.contents}");
+  void invalidFormat() =>
+      throw FormatException('Invalid number: ${input.contents}');
 
   /// Replace a space in the number with the normalized form. If space is not
   /// a significant character (normally grouping) then it's just invalid. If it
   /// is the grouping character, then it's only valid if it's followed by a
   /// digit. e.g. '$12 345.00'
-  handleSpace() =>
+  void handleSpace() =>
       groupingIsNotASpaceOrElseItIsSpaceFollowedByADigit ? '' : invalidFormat();
 
   /// Determine if a space is a valid character in the number. See
@@ -1092,7 +1091,7 @@
 
   /// Check to see if the input begins with either the positive or negative
   /// prefixes. Set the [gotPositive] and [gotNegative] variables accordingly.
-  void checkPrefixes({bool skip: false}) {
+  void checkPrefixes({bool skip = false}) {
     bool checkPrefix(String prefix) =>
         prefix.isNotEmpty && input.startsWith(prefix);
 
@@ -1156,11 +1155,11 @@
   /// Parse [text] and return the resulting number. Throws [FormatException]
   /// if we can't parse it.
   num parse() {
-    if (text == symbols.NAN) return (0.0 / 0.0);
-    if (text == "$_positivePrefix${symbols.INFINITY}$_positiveSuffix") {
+    if (text == symbols.NAN) return 0.0 / 0.0;
+    if (text == '$_positivePrefix${symbols.INFINITY}$_positiveSuffix') {
       return 1.0 / 0.0;
     }
-    if (text == "$_negativePrefix${symbols.INFINITY}$_negativeSuffix") {
+    if (text == '$_negativePrefix${symbols.INFINITY}$_negativeSuffix') {
       return -1.0 / 0.0;
     }
 
@@ -1176,7 +1175,7 @@
 
   /// The number is invalid, throw a [FormatException].
   void invalidNumber() =>
-      throw new FormatException("Invalid Number: ${input.contents}");
+      throw FormatException('Invalid Number: ${input.contents}');
 
   /// Parse the number portion of the input, i.e. not any prefixes or suffixes,
   /// and assuming NaN and Infinity are already handled.
@@ -1185,7 +1184,7 @@
       _normalized.write('-');
     }
     while (!done && !input.atEnd()) {
-      int digit = asDigit(input.peek());
+      var digit = asDigit(input.peek());
       if (digit != null) {
         _normalized.writeCharCode(_zero + digit);
         input.next();
@@ -1197,7 +1196,7 @@
 
     var normalizedText = _normalized.toString();
     num parsed = int.tryParse(normalizedText);
-    if (parsed == null) parsed = double.parse(normalizedText);
+    parsed ??= double.parse(normalizedText);
     return parsed / scale;
   }
 }
@@ -1261,8 +1260,8 @@
       // positive trunk.
       for (var each in _iterable(trunk)) {
         if (pattern.current != each && pattern.current != null) {
-          throw new FormatException(
-              "Positive and negative trunks must be the same");
+          throw FormatException(
+              'Positive and negative trunks must be the same', trunk);
         }
         pattern.moveNext();
       }
@@ -1281,9 +1280,9 @@
   /// Parse a prefix or suffix and return the prefix/suffix string. Note that
   /// this also may modify the state of [format].
   String _parseAffix() {
-    var affix = new StringBuffer();
+    var affix = StringBuffer();
     inQuote = false;
-    while (parseCharacterAffix(affix) && pattern.moveNext());
+    while (parseCharacterAffix(affix) && pattern.moveNext()) {}
     return affix.toString();
   }
 
@@ -1319,7 +1318,7 @@
           break;
         case _PATTERN_PERCENT:
           if (format._multiplier != 1 && format._multiplier != _PERCENT_SCALE) {
-            throw new FormatException('Too many percent/permill');
+            throw FormatException('Too many percent/permill', format);
           }
           format._multiplier = _PERCENT_SCALE;
           affix.write(symbols.PERCENT);
@@ -1327,7 +1326,7 @@
         case _PATTERN_PER_MILLE:
           if (format._multiplier != 1 &&
               format._multiplier != _PER_MILLE_SCALE) {
-            throw new FormatException('Too many percent/permill');
+            throw FormatException('Too many percent/permill', format);
           }
           format._multiplier = _PER_MILLE_SCALE;
           affix.write(symbols.PERMILL);
@@ -1350,7 +1349,7 @@
   /// positive or negative prefixes or suffixes.
   String _parseTrunk() {
     var loop = true;
-    var trunk = new StringBuffer();
+    var trunk = StringBuffer();
     while (pattern.current != null && loop) {
       loop = parseTrunkCharacter(trunk);
     }
@@ -1370,7 +1369,7 @@
             (decimalPos < digitLeftCount ||
                 decimalPos > digitLeftCount + zeroDigitCount) ||
         groupingCount == 0) {
-      throw new FormatException('Malformed pattern "${pattern.input}"');
+      throw FormatException('Malformed pattern "${pattern.input}"');
     }
     var totalDigits = digitLeftCount + zeroDigitCount + digitRightCount;
 
@@ -1428,8 +1427,7 @@
         break;
       case _PATTERN_ZERO_DIGIT:
         if (digitRightCount > 0) {
-          throw new FormatException(
-              'Unexpected "0" in pattern "' + pattern.input + '"');
+          throw FormatException('Unexpected "0" in pattern "${pattern.input}');
         }
         zeroDigitCount++;
         if (groupingCount >= 0 && decimalPos < 0) {
@@ -1445,7 +1443,7 @@
         break;
       case _PATTERN_DECIMAL_SEPARATOR:
         if (decimalPos >= 0) {
-          throw new FormatException(
+          throw FormatException(
               'Multiple decimal separators in pattern "$pattern"');
         }
         decimalPos = digitLeftCount + zeroDigitCount + digitRightCount;
@@ -1453,7 +1451,7 @@
       case _PATTERN_EXPONENT:
         trunk.write(ch);
         if (format._useExponentialNotation) {
-          throw new FormatException(
+          throw FormatException(
               'Multiple exponential symbols in pattern "$pattern"');
         }
         format._useExponentialNotation = true;
@@ -1478,7 +1476,7 @@
 
         if ((digitLeftCount + zeroDigitCount) < 1 ||
             format.minimumExponentDigits < 1) {
-          throw new FormatException('Malformed exponential pattern "$pattern"');
+          throw FormatException('Malformed exponential pattern "$pattern"');
         }
         return false;
       default:
@@ -1491,10 +1489,10 @@
 }
 
 /// Returns an [Iterable] on the string as a list of substrings.
-Iterable _iterable(String s) => new _StringIterable(s);
+Iterable<String> _iterable(String s) => _StringIterable(s);
 
 /// Return an iterator on the string as a list of substrings.
-Iterator<String> _iterator(String s) => new _StringIterator(s);
+Iterator<String> _iterator(String s) => _StringIterator(s);
 
 // TODO(nweiz): remove this when issue 3780 is fixed.
 /// Provides an Iterable that wraps [_iterator] so it can be used in a `for`
@@ -1510,7 +1508,7 @@
 class _StringIterator implements Iterator<String> {
   final String input;
   int nextIndex = 0;
-  String _current = null;
+  String _current;
 
   _StringIterator(input) : input = _validate(input);
 
@@ -1530,7 +1528,7 @@
   Iterator<String> get iterator => this;
 
   static String _validate(input) {
-    if (input is! String) throw new ArgumentError(input);
+    if (input is! String) throw ArgumentError(input);
     return input;
   }
 }
@@ -1540,7 +1538,7 @@
 ///
 /// It supports no operations other than being used for Intl number formatting.
 abstract class MicroMoney {
-  factory MicroMoney(micros) => new _MicroMoney(micros);
+  factory MicroMoney(micros) => _MicroMoney(micros);
 }
 
 /// Used primarily for currency formatting, this stores millionths of a
@@ -1548,44 +1546,44 @@
 ///
 /// This private class provides the operations needed by the formatting code.
 class _MicroMoney implements MicroMoney {
-  var _micros;
+  final dynamic _micros;
   _MicroMoney(this._micros);
   static const _multiplier = 1000000;
 
-  get _integerPart => _micros ~/ _multiplier;
+  dynamic get _integerPart => _micros ~/ _multiplier;
   int get _fractionPart => (this - _integerPart)._micros.toInt().abs();
 
   bool get isNegative => _micros.isNegative;
 
-  _MicroMoney abs() => isNegative ? new _MicroMoney(_micros.abs()) : this;
+  _MicroMoney abs() => isNegative ? _MicroMoney(_micros.abs()) : this;
 
   // Note that if this is done in a general way there's a risk of integer
   // overflow on JS when multiplying out the [other] parameter, which may be
   // an Int64. In formatting we only ever subtract out our own integer part.
   _MicroMoney operator -(other) {
-    if (other is _MicroMoney) return new _MicroMoney(_micros - other._micros);
-    return new _MicroMoney(_micros - (other * _multiplier));
+    if (other is _MicroMoney) return _MicroMoney(_micros - other._micros);
+    return _MicroMoney(_micros - (other * _multiplier));
   }
 
   _MicroMoney operator +(other) {
-    if (other is _MicroMoney) return new _MicroMoney(_micros + other._micros);
-    return new _MicroMoney(_micros + (other * _multiplier));
+    if (other is _MicroMoney) return _MicroMoney(_micros + other._micros);
+    return _MicroMoney(_micros + (other * _multiplier));
   }
 
   _MicroMoney operator ~/(divisor) {
     if (divisor is! int) {
-      throw new ArgumentError.value(
+      throw ArgumentError.value(
           divisor, 'divisor', '_MicroMoney ~/ only supports int arguments.');
     }
-    return new _MicroMoney((_integerPart ~/ divisor) * _multiplier);
+    return _MicroMoney((_integerPart ~/ divisor) * _multiplier);
   }
 
   _MicroMoney operator *(other) {
     if (other is! int) {
-      throw new ArgumentError.value(
+      throw ArgumentError.value(
           other, 'other', '_MicroMoney * only supports int arguments.');
     }
-    return new _MicroMoney(
+    return _MicroMoney(
         (_integerPart * other) * _multiplier + (_fractionPart * other));
   }
 
@@ -1593,10 +1591,10 @@
   /// not division by another MicroMoney
   _MicroMoney remainder(other) {
     if (other is! int) {
-      throw new ArgumentError.value(
+      throw ArgumentError.value(
           other, 'other', '_MicroMoney.remainder only supports int arguments.');
     }
-    return new _MicroMoney(_micros.remainder(other * _multiplier));
+    return _MicroMoney(_micros.remainder(other * _multiplier));
   }
 
   double toDouble() => _micros.toDouble() / _multiplier;
@@ -1604,11 +1602,11 @@
   int toInt() => _integerPart.toInt();
 
   String toString() {
-    var beforeDecimal = _integerPart.toString();
+    var beforeDecimal = '$_integerPart';
     var decimalPart = '';
     var fractionPart = _fractionPart;
     if (fractionPart != 0) {
-      decimalPart = '.' + fractionPart.toString();
+      decimalPart = '.$fractionPart';
     }
     return '$beforeDecimal$decimalPart';
   }
diff --git a/lib/src/intl_helpers.dart b/lib/src/intl_helpers.dart
index d284f2e..57edee8 100644
--- a/lib/src/intl_helpers.dart
+++ b/lib/src/intl_helpers.dart
@@ -11,7 +11,8 @@
 import 'package:intl/intl.dart';
 
 /// Type for the callback action when a message translation is not found.
-typedef MessageIfAbsent(String message_str, List<Object> args);
+typedef MessageIfAbsent = String Function(
+    String messageText, List<Object> args);
 
 /// This is used as a marker for a locale data map that hasn't been initialized,
 /// and will throw an exception on any usage that isn't the fallback
@@ -21,7 +22,7 @@
   final F fallbackData;
   UninitializedLocaleData(this.message, this.fallbackData);
 
-  operator [](String key) =>
+  F operator [](String key) =>
       (key == 'en_US') ? fallbackData : _throwException();
 
   /// If a message is looked up before any locale initialization, record it,
@@ -37,26 +38,26 @@
   static final bool throwOnFallback = false;
 
   /// The messages that were called before the locale was initialized.
-  List<String> _badMessages = [];
+  final List<String> _badMessages = [];
 
   void _reportErrors() {
-    if (throwOnFallback && _badMessages.length > 0) {
-      throw new StateError(
-          "The following messages were called before locale initialization:"
-          " $_uninitializedMessages");
+    if (throwOnFallback && _badMessages.isNotEmpty) {
+      throw StateError(
+          'The following messages were called before locale initialization:'
+          ' $_uninitializedMessages');
     }
   }
 
   String get _uninitializedMessages =>
-      (_badMessages.toSet().toList()..sort()).join("\n    ");
+      (_badMessages.toSet().toList()..sort()).join('\n    ');
 
-  String lookupMessage(String message_str, String locale, String name,
+  String lookupMessage(String messageText, String locale, String name,
       List<Object> args, String meaning,
       {MessageIfAbsent ifAbsent}) {
     if (throwOnFallback) {
-      _badMessages.add(name ?? message_str);
+      _badMessages.add(name ?? messageText);
     }
-    return message_str;
+    return messageText;
   }
 
   /// Given an initial locale or null, returns the locale that will be used
@@ -67,16 +68,16 @@
 
   bool containsKey(String key) => (key == 'en_US') ? true : _throwException();
 
-  _throwException() {
-    throw new LocaleDataException("Locale data has not been initialized"
-        ", call $message.");
+  F _throwException() {
+    throw LocaleDataException('Locale data has not been initialized'
+        ', call $message.');
   }
 
   void addLocale(String localeName, Function findLocale) => _throwException();
 }
 
 abstract class MessageLookup {
-  String lookupMessage(String message_str, String locale, String name,
+  String lookupMessage(String messageText, String locale, String name,
       List<Object> args, String meaning,
       {MessageIfAbsent ifAbsent});
   void addLocale(String localeName, Function findLocale);
@@ -85,27 +86,27 @@
 class LocaleDataException implements Exception {
   final String message;
   LocaleDataException(this.message);
-  toString() => "LocaleDataException: $message";
+  String toString() => 'LocaleDataException: $message';
 }
 
 ///  An abstract superclass for data readers to keep the type system happy.
 abstract class LocaleDataReader {
-  Future read(String locale);
+  Future<String> read(String locale);
 }
 
 /// The internal mechanism for looking up messages. We expect this to be set
 /// by the implementing package so that we're not dependent on its
 /// implementation.
 MessageLookup messageLookup =
-    new UninitializedLocaleData('initializeMessages(<locale>)', null);
+    UninitializedLocaleData('initializeMessages(<locale>)', null);
 
 /// Initialize the message lookup mechanism. This is for internal use only.
 /// User applications should import `message_lookup_by_library.dart` and call
 /// `initializeMessages`
 void initializeInternalMessageLookup(Function lookupFunction) {
-  if (messageLookup is UninitializedLocaleData) {
+  if (messageLookup is UninitializedLocaleData<dynamic>) {
     // This line has to be precisely this way to work around an analyzer crash.
-    (messageLookup as UninitializedLocaleData)._reportErrors();
+    (messageLookup as UninitializedLocaleData<dynamic>)._reportErrors();
     messageLookup = lookupFunction();
   }
 }
@@ -114,6 +115,6 @@
 /// a name based on that and the meaning, if present.
 // NOTE: THIS LOGIC IS DUPLICATED IN intl_translation AND THE TWO MUST MATCH.
 String computeMessageName(String name, String text, String meaning) {
-  if (name != null && name != "") return name;
-  return meaning == null ? text : "${text}_${meaning}";
+  if (name != null && name != '') return name;
+  return meaning == null ? text : '${text}_$meaning';
 }
diff --git a/lib/src/lazy_locale_data.dart b/lib/src/lazy_locale_data.dart
index b975a4e..0469ef6 100644
--- a/lib/src/lazy_locale_data.dart
+++ b/lib/src/lazy_locale_data.dart
@@ -17,35 +17,32 @@
 /// the external source.
 class LazyLocaleData {
   /// This holds the data we have loaded.
-  Map map;
+  Map<dynamic, dynamic> map;
 
   /// The object that actually does the data reading.
-  LocaleDataReader _reader;
+  final LocaleDataReader _reader;
 
   /// In order to avoid a potentially remote call to see if a locale
   /// is available, we hold a complete list of all the available
   /// locales.
-  List availableLocales;
+  List<String> availableLocales;
 
   /// Given a piece of remote data, apply [_creationFunction] to it to
   /// convert it into the right form. Typically this means converting it
   /// from a Map into an object form.
-  Function _creationFunction;
+  final Function _creationFunction;
 
   /// The set of available locales.
-  Set availableLocaleSet;
-
-  static const jsonDecoder = const JsonCodec();
+  Set<String> availableLocaleSet;
 
   /// The constructor. The [_reader] specifies where the data comes
   /// from. The [_creationFunction] creates the appropriate data type
   /// from the remote data (which typically comes in as a Map). The
   /// [keys] lists the set of remotely available locale names so we know which
   /// things can be fetched without having to check remotely.
-  LazyLocaleData(this._reader, this._creationFunction, List keys) {
-    map = new Map();
-    availableLocales = keys;
-    availableLocaleSet = new Set.from(availableLocales);
+  LazyLocaleData(this._reader, this._creationFunction, this.availableLocales) {
+    map = Map();
+    availableLocaleSet = Set.from(availableLocales);
   }
 
   ///  Tests if we have data for the locale available. Note that this returns
@@ -54,18 +51,17 @@
   bool containsKey(String locale) => availableLocaleSet.contains(locale);
 
   /// Returns the list of keys/locale names.
-  List get keys => availableLocales;
+  List<String> get keys => availableLocales;
 
   /// Returns the data stored for [localeName]. If no data has been loaded
   /// for [localeName], throws an exception. If no data is available for
   /// [localeName] then throw an exception with a different message.
-  operator [](String localeName) {
+  dynamic operator [](String localeName) {
     if (containsKey(localeName)) {
       var data = map[localeName];
       if (data == null) {
-        throw new LocaleDataException(
-            "Locale $localeName has not been initialized."
-            " Call initializeDateFormatting($localeName, <data url>) first");
+        throw LocaleDataException('Locale $localeName has not been initialized.'
+            ' Call initializeDateFormatting($localeName, <data url>) first');
       } else {
         return data;
       }
@@ -76,13 +72,13 @@
 
   /// Throw an exception indicating that the locale has no data available,
   /// either locally or remotely.
-  unsupportedLocale(localeName) {
-    throw new LocaleDataException('Locale $localeName has no data available');
+  void unsupportedLocale(localeName) {
+    throw LocaleDataException('Locale $localeName has no data available');
   }
 
   /// Initialize for locale. Internal use only. As a user, call
   /// initializeDateFormatting instead.
-  Future initLocale(String localeName) {
+  Future<void> initLocale(String localeName) {
     var data = _reader.read(localeName);
     return jsonData(data).then((input) {
       map[localeName] = _creationFunction(input);
@@ -91,7 +87,7 @@
 
   /// Given a Future [input] whose value is expected to be a string in JSON
   /// form, return another future that parses the JSON into a usable format.
-  Future jsonData(Future input) {
-    return input.then((response) => jsonDecoder.decode(response));
+  Future<dynamic> jsonData(Future<String> input) {
+    return input.then((response) => json.decode(response));
   }
 }
diff --git a/lib/src/locale.dart b/lib/src/locale.dart
index 3a941eb..d2c53c9 100644
--- a/lib/src/locale.dart
+++ b/lib/src/locale.dart
@@ -101,7 +101,7 @@
   @override
   bool operator ==(Object other) {
     if (identical(this, other)) return true;
-    return other is Locale && this.toLanguageTag() == other.toLanguageTag();
+    return other is Locale && toLanguageTag() == other.toLanguageTag();
   }
 
   @override
diff --git a/lib/src/locale/locale_extensions.dart b/lib/src/locale/locale_extensions.dart
index 4018ba5..245ecbf 100644
--- a/lib/src/locale/locale_extensions.dart
+++ b/lib/src/locale/locale_extensions.dart
@@ -59,8 +59,9 @@
         otherExtensions == null ||
             otherExtensions.entries.every((e) {
               if (!_otherExtensionsValidKeysRE.hasMatch(e.key)) return false;
-              if (!_otherExtensionsValidValuesRE.hasMatch(e.value))
+              if (!_otherExtensionsValidValuesRE.hasMatch(e.value)) {
                 return false;
+              }
               return true;
             }),
         'otherExtensions keys must match '
@@ -149,21 +150,21 @@
   /// are stored under normalized (lowercased) `key`. See
   /// http://www.unicode.org/reports/tr35/#unicode_locale_extensions for
   /// details.
-  Map<String, String> _uExtensions;
+  final Map<String, String> _uExtensions;
 
   /// `-t-` extension, with keys in sorted order. tlang attributes are stored
   /// under the zero-length string as key. See
   /// http://www.unicode.org/reports/tr35/#transformed_extensions for
   /// details.
-  Map<String, String> _tExtensions;
+  final Map<String, String> _tExtensions;
 
   /// Other extensions, with keys in sorted order. See
   /// http://www.unicode.org/reports/tr35/#other_extensions for details.
-  Map<String, String> _otherExtensions;
+  final Map<String, String> _otherExtensions;
 
   /// -x- extension values. See
   /// http://www.unicode.org/reports/tr35/#pu_extensions for details.
-  String _xExtensions;
+  final String _xExtensions;
 
   /// List of subtags in the [Unicode Locale
   /// Identifier](https://www.unicode.org/reports/tr35/#Unicode_locale_identifier)
@@ -177,11 +178,11 @@
   /// unicode_language_id and '-' as delimiter to provide a UTS #35 compliant
   /// normalized Locale Identifier.
   List<String> get subtags {
-    final List<String> result = [];
-    final List<String> resultVWYZ = [];
+    final result = <String>[];
+    final resultVWYZ = <String>[];
 
     _otherExtensions.forEach((singleton, value) {
-      final int letter = (singleton.codeUnitAt(0) - 0x61) & 0xFFFF;
+      final letter = (singleton.codeUnitAt(0) - 0x61) & 0xFFFF;
       // 't', 'u' and 'x' are handled by other members.
       assert(letter < 26 && letter != 19 && letter != 20 && letter != 23);
       if (letter < 19) {
@@ -209,7 +210,7 @@
       result.addAll(resultVWYZ);
     }
     if (_xExtensions != null) {
-      result.add('x-${_xExtensions}');
+      result.add('x-$_xExtensions');
     }
     return result;
   }
@@ -220,7 +221,7 @@
   if (unsorted == null) {
     return const {};
   }
-  Map<String, String> map = {};
+  var map = <String, String>{};
   for (var key in unsorted.keys.toList()..sort()) {
     map[key] = unsorted[key];
   }
diff --git a/lib/src/locale/locale_implementation.dart b/lib/src/locale/locale_implementation.dart
index 11b398c..ed3dea3 100644
--- a/lib/src/locale/locale_implementation.dart
+++ b/lib/src/locale/locale_implementation.dart
@@ -27,8 +27,8 @@
         'countryCode must match RegExp/${_normalizedRegionRE.pattern}/ '
         'but is "$countryCode".');
     assert(
-        variants is List &&
-            variants.every((v) => _normalizedVariantRE.hasMatch(v)),
+        variants is List<String> &&
+            variants.every(_normalizedVariantRE.hasMatch),
         'each variant must match RegExp/${_normalizedVariantRE.pattern}/ '
         'but variants are "$variants".');
   }
@@ -55,8 +55,7 @@
   /// [variants], does not imply subtags are valid as per Unicode LDML spec!
   //
   // Must be static to get tree-shaken away in production code.
-  static final _normalizedVariantRE =
-      RegExp(r'^[a-z\d]{5,8}$|^\d[a-z\d]{3}$');
+  static final _normalizedVariantRE = RegExp(r'^[a-z\d]{5,8}$|^\d[a-z\d]{3}$');
 
   /// Simple factory which assumes parameters are syntactically correct.
   ///
@@ -173,7 +172,7 @@
   /// Returns the canonical Unicode BCP47 Locale Identifier for this locale.
   String toLanguageTag() {
     if (_languageTag == null) {
-      final List<String> out = [languageCode];
+      final out = [languageCode];
       if (scriptCode != null) out.add(scriptCode);
       if (countryCode != null) out.add(countryCode);
       out.addAll(variants);
diff --git a/lib/src/locale/locale_parser.dart b/lib/src/locale/locale_parser.dart
index 4fb90d5..8c151b0 100644
--- a/lib/src/locale/locale_parser.dart
+++ b/lib/src/locale/locale_parser.dart
@@ -128,7 +128,7 @@
     _currentIndex = 0;
     _current = _subtags[0];
 
-    bool scriptFound = false;
+    var scriptFound = false;
     if (acceptLanguage()) {
       _languageCode = replaceDeprecatedLanguageSubtag(accepted());
       scriptFound = acceptScript();
@@ -160,7 +160,7 @@
   /// empty.
   void processExtensions() {
     while (acceptSingleton()) {
-      String singleton = accepted();
+      var singleton = accepted();
       if (singleton == 'u') {
         processUExtensions();
       } else if (singleton == 't') {
@@ -185,8 +185,8 @@
       return;
     }
     _uExtensions = <String, String>{};
-    bool empty = true;
-    final List<String> attributes = [];
+    var empty = true;
+    final attributes = <String>[];
     while (acceptLowAlphaNumeric3to8()) {
       attributes.add(accepted());
     }
@@ -198,8 +198,8 @@
     // unicode_locale_extensions: collect "(sep keyword)*".
     while (acceptUExtensionKey()) {
       empty = false;
-      String key = accepted();
-      final List<String> typeParts = <String>[];
+      var key = accepted();
+      final typeParts = <String>[];
       while (acceptLowAlphaNumeric3to8()) {
         typeParts.add(accepted());
       }
@@ -229,8 +229,8 @@
       return;
     }
     _tExtensions = <String, String>{};
-    bool empty = true;
-    final List<String> tlang = <String>[];
+    var empty = true;
+    final tlang = <String>[];
     if (acceptLanguage()) {
       empty = false;
       tlang.add(replaceDeprecatedLanguageSubtag(accepted()));
@@ -247,8 +247,8 @@
     }
     // transformed_extensions: collect "(sep tfield)*".
     while (acceptTExtensionKey()) {
-      String tkey = accepted();
-      final List<String> tvalueParts = <String>[];
+      var tkey = accepted();
+      final tvalueParts = <String>[];
       while (acceptLowAlphaNumeric3to8()) {
         tvalueParts.add(accepted());
       }
@@ -274,7 +274,7 @@
   /// If parsing fails, `atEnd()` will be false and/or [problems] will not be
   /// empty.
   void processPrivateUseExtensions() {
-    final List<String> values = <String>[];
+    final values = <String>[];
     while (acceptLowAlphaNumeric1to8()) {
       values.add(accepted());
     }
@@ -290,7 +290,7 @@
   /// If parsing fails, `atEnd()` will be false and/or [problems] will not be
   /// empty.
   void processOtherExtensions(String singleton) {
-    final List<String> values = <String>[];
+    final values = <String>[];
     while (acceptLowAlphaNumeric2to8()) {
       values.add(accepted());
     }
@@ -374,8 +374,9 @@
   /// ranging from 2 to 8.
   bool acceptLowAlphaNumeric2to8() {
     if (atEnd()) return false;
-    if (!_alphaNumeric1to8RegExp.hasMatch(current()) || current().length < 2)
+    if (!_alphaNumeric1to8RegExp.hasMatch(current()) || current().length < 2) {
       return false;
+    }
     advance();
     return true;
   }
@@ -384,8 +385,9 @@
   /// ranging from 3 to 8.
   bool acceptLowAlphaNumeric3to8() {
     if (atEnd()) return false;
-    if (!_alphaNumeric1to8RegExp.hasMatch(current()) || current().length < 3)
+    if (!_alphaNumeric1to8RegExp.hasMatch(current()) || current().length < 3) {
       return false;
+    }
     advance();
     return true;
   }
diff --git a/lib/src/plural_rules.dart b/lib/src/plural_rules.dart
index efa906c..1a3beb5 100644
--- a/lib/src/plural_rules.dart
+++ b/lib/src/plural_rules.dart
@@ -16,9 +16,12 @@
 /// * t	- visible fractional digits in n, without trailing zeros.
 library plural_rules;
 
+// Suppress naming issues as changing them might be breaking.
+// ignore_for_file: constant_identifier_names, non_constant_identifier_names
+
 import 'dart:math' as math;
 
-typedef PluralCase PluralRule();
+typedef PluralRule = PluralCase Function();
 
 /// The possible cases used in a plural rule.
 enum PluralCase { ZERO, ONE, TWO, FEW, MANY, OTHER }
@@ -28,7 +31,7 @@
 
 /// This must be called before evaluating a new rule, because we're using
 /// library-global state to both keep the rules terse and minimize space.
-startRuleEvaluation(num howMany, [int precision = 0]) {
+void startRuleEvaluation(num howMany, [int precision = 0]) {
   _n = howMany;
   _precision = precision;
   _i = _n.round();
@@ -67,8 +70,8 @@
 /// The short names for parameters / return match the CLDR syntax and UTS #35
 ///     (https://unicode.org/reports/tr35/tr35-numbers.html#Plural_rules_syntax)
 /// Takes the item count [n] and a [precision].
-_updateVF(num n, int precision) {
-  int defaultDigits = 3;
+void _updateVF(num n, int precision) {
+  var defaultDigits = 3;
 
   _v = precision ?? math.min(_decimals(n, precision), defaultDigits);
 
@@ -82,7 +85,7 @@
 ///     (https://unicode.org/reports/tr35/tr35-numbers.html#Plural_rules_syntax)
 /// @param v Calculated previously.
 /// @param f Calculated previously.
-_updateWT(int v, int f) {
+void _updateWT(int v, int f) {
   if (f == 0) {
     // Unused, for now _w = 0;
     _t = 0;
diff --git a/pubspec.yaml b/pubspec.yaml
index 0f57a18..4ab9cd5 100644
--- a/pubspec.yaml
+++ b/pubspec.yaml
@@ -1,5 +1,5 @@
 name: intl
-version: 0.16.0
+version: 0.16.1-dev
 author: Dart Team <misc@dartlang.org>
 homepage: https://github.com/dart-lang/intl
 description: >-
diff --git a/test/bidi_format_test.dart b/test/bidi_format_test.dart
index 2421c85..ca69e85 100644
--- a/test/bidi_format_test.dart
+++ b/test/bidi_format_test.dart
@@ -7,8 +7,10 @@
 import 'package:intl/intl.dart';
 import 'package:test/test.dart';
 
+// ignore_for_file: non_constant_identifier_names
+
 /// Tests the bidirectional text formatting library.
-main() {
+void main() {
   var LTR = TextDirection.LTR;
   var RTL = TextDirection.RTL;
   var LRM = Bidi.LRM;
@@ -21,9 +23,9 @@
   var en = 'abba';
   var html = '&lt;';
   var longEn = 'abba sabba gabba ';
-  var ltrFmt = new BidiFormatter.LTR(); // LTR context
-  var rtlFmt = new BidiFormatter.RTL(); // RTL context
-  var unkFmt = new BidiFormatter.UNKNOWN(); // unknown context
+  var ltrFmt = BidiFormatter.LTR(); // LTR context
+  var rtlFmt = BidiFormatter.RTL(); // RTL context
+  var unkFmt = BidiFormatter.UNKNOWN(); // unknown context
 
   test('estimateDirection', () {
     expect(ltrFmt.estimateDirection(''), equals(UNKNOWN));
@@ -86,8 +88,8 @@
     expect(ltrFmt.wrapWithSpan('<br>$en', isHtml: false, resetDir: false),
         equals('&lt;br&gt;$en'));
 
-    var ltrAlwaysSpanFmt = new BidiFormatter.LTR(true);
-    var rtlAlwaysSpanFmt = new BidiFormatter.RTL(true);
+    var ltrAlwaysSpanFmt = BidiFormatter.LTR(true);
+    var rtlAlwaysSpanFmt = BidiFormatter.RTL(true);
 
     // Test alwaysSpan, overall dir matches context dir (LTR), no dirReset.
     expect(ltrAlwaysSpanFmt.wrapWithSpan(en, isHtml: true, resetDir: false),
diff --git a/test/bidi_utils_test.dart b/test/bidi_utils_test.dart
index a6f0832..a0a2e95 100644
--- a/test/bidi_utils_test.dart
+++ b/test/bidi_utils_test.dart
@@ -7,8 +7,10 @@
 import 'package:intl/intl.dart';
 import 'package:test/test.dart';
 
+// ignore_for_file: non_constant_identifier_names
+
 /// Tests the bidi utilities library.
-main() {
+void main() {
   var LRE = '\u202A';
   var RLE = '\u202B';
   var PDF = '\u202C';
@@ -99,55 +101,55 @@
   });
 
   test('guardBracketInHtml', () {
-    var strWithRtl = "asc \u05d0 (\u05d0\u05d0\u05d0)";
+    var strWithRtl = 'asc \u05d0 (\u05d0\u05d0\u05d0)';
     expect(Bidi.guardBracketInHtml(strWithRtl),
-        equals("asc \u05d0 <span dir=rtl>(\u05d0\u05d0\u05d0)</span>"));
+        equals('asc \u05d0 <span dir=rtl>(\u05d0\u05d0\u05d0)</span>'));
     expect(Bidi.guardBracketInHtml(strWithRtl, true),
-        equals("asc \u05d0 <span dir=rtl>(\u05d0\u05d0\u05d0)</span>"));
+        equals('asc \u05d0 <span dir=rtl>(\u05d0\u05d0\u05d0)</span>'));
     expect(Bidi.guardBracketInHtml(strWithRtl, false),
-        equals("asc \u05d0 <span dir=ltr>(\u05d0\u05d0\u05d0)</span>"));
+        equals('asc \u05d0 <span dir=ltr>(\u05d0\u05d0\u05d0)</span>'));
 
-    var strWithRtl2 = "\u05d0 a (asc:))";
+    var strWithRtl2 = '\u05d0 a (asc:))';
     expect(Bidi.guardBracketInHtml(strWithRtl2),
-        equals("\u05d0 a <span dir=rtl>(asc:))</span>"));
+        equals('\u05d0 a <span dir=rtl>(asc:))</span>'));
     expect(Bidi.guardBracketInHtml(strWithRtl2, true),
-        equals("\u05d0 a <span dir=rtl>(asc:))</span>"));
+        equals('\u05d0 a <span dir=rtl>(asc:))</span>'));
     expect(Bidi.guardBracketInHtml(strWithRtl2, false),
-        equals("\u05d0 a <span dir=ltr>(asc:))</span>"));
+        equals('\u05d0 a <span dir=ltr>(asc:))</span>'));
 
-    var strWithoutRtl = "a (asc) {{123}}";
+    var strWithoutRtl = 'a (asc) {{123}}';
     expect(Bidi.guardBracketInHtml(strWithoutRtl),
-        equals("a <span dir=ltr>(asc)</span> <span dir=ltr>{{123}}</span>"));
+        equals('a <span dir=ltr>(asc)</span> <span dir=ltr>{{123}}</span>'));
     expect(Bidi.guardBracketInHtml(strWithoutRtl, true),
-        equals("a <span dir=rtl>(asc)</span> <span dir=rtl>{{123}}</span>"));
+        equals('a <span dir=rtl>(asc)</span> <span dir=rtl>{{123}}</span>'));
     expect(Bidi.guardBracketInHtml(strWithoutRtl, false),
-        equals("a <span dir=ltr>(asc)</span> <span dir=ltr>{{123}}</span>"));
+        equals('a <span dir=ltr>(asc)</span> <span dir=ltr>{{123}}</span>'));
   });
 
   test('guardBracketInText', () {
-    var strWithRtl = "asc \u05d0 (\u05d0\u05d0\u05d0)";
+    var strWithRtl = 'asc \u05d0 (\u05d0\u05d0\u05d0)';
     expect(Bidi.guardBracketInText(strWithRtl),
-        equals("asc \u05d0 \u200f(\u05d0\u05d0\u05d0)\u200f"));
+        equals('asc \u05d0 \u200f(\u05d0\u05d0\u05d0)\u200f'));
     expect(Bidi.guardBracketInText(strWithRtl, true),
-        equals("asc \u05d0 \u200f(\u05d0\u05d0\u05d0)\u200f"));
+        equals('asc \u05d0 \u200f(\u05d0\u05d0\u05d0)\u200f'));
     expect(Bidi.guardBracketInText(strWithRtl, false),
-        equals("asc \u05d0 \u200e(\u05d0\u05d0\u05d0)\u200e"));
+        equals('asc \u05d0 \u200e(\u05d0\u05d0\u05d0)\u200e'));
 
-    var strWithRtl2 = "\u05d0 a (asc:))";
+    var strWithRtl2 = '\u05d0 a (asc:))';
     expect(Bidi.guardBracketInText(strWithRtl2),
-        equals("\u05d0 a \u200f(asc:))\u200f"));
+        equals('\u05d0 a \u200f(asc:))\u200f'));
     expect(Bidi.guardBracketInText(strWithRtl2, true),
-        equals("\u05d0 a \u200f(asc:))\u200f"));
+        equals('\u05d0 a \u200f(asc:))\u200f'));
     expect(Bidi.guardBracketInText(strWithRtl2, false),
-        equals("\u05d0 a \u200e(asc:))\u200e"));
+        equals('\u05d0 a \u200e(asc:))\u200e'));
 
-    var strWithoutRtl = "a (asc) {{123}}";
+    var strWithoutRtl = 'a (asc) {{123}}';
     expect(Bidi.guardBracketInText(strWithoutRtl),
-        equals("a \u200e(asc)\u200e \u200e{{123}}\u200e"));
+        equals('a \u200e(asc)\u200e \u200e{{123}}\u200e'));
     expect(Bidi.guardBracketInText(strWithoutRtl, true),
-        equals("a \u200f(asc)\u200f \u200f{{123}}\u200f"));
+        equals('a \u200f(asc)\u200f \u200f{{123}}\u200f'));
     expect(Bidi.guardBracketInText(strWithoutRtl, false),
-        equals("a \u200e(asc)\u200e \u200e{{123}}\u200e"));
+        equals('a \u200e(asc)\u200e \u200e{{123}}\u200e'));
   });
 
   test('enforceRtlInHtml', () {
@@ -200,8 +202,7 @@
     expect(Bidi.estimateDirectionOfText('http://foo/bar/', isHtml: false).value,
         equals(TextDirection.LTR.value));
     expect(
-        Bidi
-            .estimateDirectionOfText(
+        Bidi.estimateDirectionOfText(
                 'http://foo/bar/?s=\u05d0\u05d0\u05d0\u05d0\u05d0\u05d0\u05d0\u05d0'
                 '\u05d0\u05d0\u05d0\u05d0\u05d0\u05d0\u05d0\u05d0\u05d0\u05d0\u05d0'
                 '\u05d0\u05d0\u05d0\u05d0\u05d0')
@@ -210,20 +211,17 @@
     expect(Bidi.estimateDirectionOfText('\u05d0', isHtml: false).value,
         equals(TextDirection.RTL.value));
     expect(
-        Bidi
-            .estimateDirectionOfText('9 \u05d0 -> 17.5, 23, 45, 19',
+        Bidi.estimateDirectionOfText('9 \u05d0 -> 17.5, 23, 45, 19',
                 isHtml: false)
             .value,
         equals(TextDirection.RTL.value));
     expect(
-        Bidi
-            .estimateDirectionOfText(
+        Bidi.estimateDirectionOfText(
                 'http://foo/bar/ \u05d0 http://foo2/bar2/ http://foo3/bar3/')
             .value,
         equals(TextDirection.RTL.value));
     expect(
-        Bidi
-            .estimateDirectionOfText(
+        Bidi.estimateDirectionOfText(
                 '\u05d0\u05d9\u05df \u05de\u05de\u05e9 \u05de\u05d4 \u05dc\u05e8\u05d0'
                 '\u05d5\u05ea: \u05dc\u05d0 \u05e6\u05d9\u05dc\u05de\u05ea\u05d9 \u05d4'
                 '\u05e8\u05d1\u05d4 \u05d5\u05d2\u05dd \u05d0\u05dd \u05d4\u05d9\u05d9'
@@ -232,8 +230,7 @@
             .value,
         equals(TextDirection.RTL.value));
     expect(
-        Bidi
-            .estimateDirectionOfText(
+        Bidi.estimateDirectionOfText(
                 '\u05db\u05d0 - http://geek.co.il/gallery/v/2007-06 - \u05d0\u05d9'
                 '\u05df \u05de\u05de\u05e9 \u05de\u05d4 \u05dc\u05e8\u05d0\u05d5\u05ea:'
                 ' \u05dc\u05d0 \u05e6\u05d9\u05dc\u05de\u05ea\u05d9 \u05d4\u05e8\u05d1 '
@@ -250,15 +247,13 @@
             .value,
         equals(TextDirection.RTL.value));
     expect(
-        Bidi
-            .estimateDirectionOfText(
+        Bidi.estimateDirectionOfText(
                 'CAPTCHA \u05de\u05e9\u05d5\u05db\u05dc\u05dc '
                 '\u05de\u05d3\u05d9?')
             .value,
         equals(TextDirection.RTL.value));
     expect(
-        Bidi
-            .estimateDirectionOfText(
+        Bidi.estimateDirectionOfText(
                 'Yes Prime Minister \u05e2\u05d3\u05db\u05d5\u05df. \u05e9\u05d0\u05dc'
                 '\u05d5 \u05d0\u05d5\u05ea\u05d9 \u05de\u05d4 \u05d0\u05e0\u05d9 '
                 '\u05e8\u05d5\u05e6\u05d4 \u05de\u05ea\u05e0\u05d4 \u05dc\u05d7'
@@ -266,47 +261,40 @@
             .value,
         equals(TextDirection.RTL.value));
     expect(
-        Bidi
-            .estimateDirectionOfText(
+        Bidi.estimateDirectionOfText(
                 '17.4.02 \u05e9\u05e2\u05d4:13-20 .15-00 .\u05dc\u05d0 \u05d4\u05d9'
                 '\u05d9\u05ea\u05d9 \u05db\u05d0\u05df.')
             .value,
         equals(TextDirection.RTL.value));
     expect(
-        Bidi
-            .estimateDirectionOfText(
+        Bidi.estimateDirectionOfText(
                 '5710 5720 5730. \u05d4\u05d3\u05dc\u05ea. \u05d4\u05e0\u05e9\u05d9'
                 '\u05e7\u05d4',
                 isHtml: false)
             .value,
         equals(TextDirection.RTL.value));
     expect(
-        Bidi
-            .estimateDirectionOfText(
+        Bidi.estimateDirectionOfText(
                 '\u05d4\u05d3\u05dc\u05ea http://www.google.com '
                 'http://www.gmail.com')
             .value,
         equals(TextDirection.RTL.value));
     expect(
-        Bidi
-            .estimateDirectionOfText(
+        Bidi.estimateDirectionOfText(
                 '\u05d4\u05d3\u05dc <some quite nasty html mark up>')
             .value,
         equals(TextDirection.LTR.value));
     expect(
-        Bidi
-            .estimateDirectionOfText(
+        Bidi.estimateDirectionOfText(
                 '\u05d4\u05d3\u05dc <some quite nasty html mark up>')
             .value,
         equals(TextDirection.LTR.value));
     expect(
-        Bidi
-            .estimateDirectionOfText('\u05d4\u05d3\u05dc\u05ea &amp; &lt; &gt;')
+        Bidi.estimateDirectionOfText('\u05d4\u05d3\u05dc\u05ea &amp; &lt; &gt;')
             .value,
         equals(TextDirection.LTR.value));
     expect(
-        Bidi
-            .estimateDirectionOfText('\u05d4\u05d3\u05dc\u05ea &amp; &lt; &gt;',
+        Bidi.estimateDirectionOfText('\u05d4\u05d3\u05dc\u05ea &amp; &lt; &gt;',
                 isHtml: true)
             .value,
         equals(TextDirection.RTL.value));
@@ -314,10 +302,10 @@
 
   test('detectRtlDirectionality', () {
     var bidiText = [];
-    var item = new SampleItem('Pure Ascii content');
+    var item = SampleItem('Pure Ascii content');
     bidiText.add(item);
 
-    item = new SampleItem(
+    item = SampleItem(
         '\u05d0\u05d9\u05df \u05de\u05de\u05e9 \u05de\u05d4'
         ' \u05dc\u05e8\u05d0\u05d5\u05ea: \u05dc\u05d0 \u05e6\u05d9\u05dc'
         '\u05de\u05ea\u05d9 \u05d4\u05e8\u05d1\u05d4 \u05d5\u05d2\u05dd '
@@ -326,7 +314,7 @@
         true);
     bidiText.add(item);
 
-    item = new SampleItem(
+    item = SampleItem(
         '\u05db\u05d0\u05df - http://geek.co.il/gallery/v/'
         '2007-06 - \u05d0\u05d9\u05df \u05de\u05de\u05e9 \u05de\u05d4 \u05dc'
         '\u05e8\u05d0\u05d5\u05ea: \u05dc\u05d0 \u05e6\u05d9\u05dc\u05de\u05ea'
@@ -343,13 +331,13 @@
         true);
     bidiText.add(item);
 
-    item = new SampleItem(
+    item = SampleItem(
         'CAPTCHA \u05de\u05e9\u05d5\u05db\u05dc\u05dc '
         '\u05de\u05d3\u05d9?',
         true);
     bidiText.add(item);
 
-    item = new SampleItem(
+    item = SampleItem(
         'Yes Prime Minister \u05e2\u05d3\u05db\u05d5\u05df. '
         '\u05e9\u05d0\u05dc\u05d5 \u05d0\u05d5\u05ea\u05d9 \u05de\u05d4 \u05d0'
         '\u05e0\u05d9 \u05e8\u05d5\u05e6\u05d4 \u05de\u05ea\u05e0\u05d4 '
@@ -357,28 +345,28 @@
         true);
     bidiText.add(item);
 
-    item = new SampleItem(
+    item = SampleItem(
         '17.4.02 \u05e9\u05e2\u05d4:13-20 .15-00 .\u05dc'
         '\u05d0 \u05d4\u05d9\u05d9\u05ea\u05d9 \u05db\u05d0\u05df.',
         true);
     bidiText.add(item);
 
-    item = new SampleItem(
+    item = SampleItem(
         '5710 5720 5730. \u05d4\u05d3\u05dc\u05ea. \u05d4'
         '\u05e0\u05e9\u05d9\u05e7\u05d4',
         true);
     bidiText.add(item);
 
-    item = new SampleItem(
+    item = SampleItem(
         '\u05d4\u05d3\u05dc\u05ea http://www.google.com '
         'http://www.gmail.com',
         true);
     bidiText.add(item);
 
-    item = new SampleItem('&gt;\u05d4&lt;', true, true);
+    item = SampleItem('&gt;\u05d4&lt;', true, true);
     bidiText.add(item);
 
-    item = new SampleItem('&gt;\u05d4&lt;', false);
+    item = SampleItem('&gt;\u05d4&lt;', false);
     bidiText.add(item);
 
     for (var i = 0; i < bidiText.length; i++) {
@@ -399,8 +387,5 @@
   String text;
   bool isRtl;
   bool isHtml;
-  SampleItem([someText = '', someIsRtl = false, isHtml = false])
-      : this.text = someText,
-        this.isRtl = someIsRtl,
-        this.isHtml = isHtml;
+  SampleItem([this.text = '', this.isRtl = false, this.isHtml = false]);
 }
diff --git a/test/brazil_timezone_test.dart b/test/brazil_timezone_test.dart
index 3032276..6fb5bd4 100644
--- a/test/brazil_timezone_test.dart
+++ b/test/brazil_timezone_test.dart
@@ -20,7 +20,7 @@
 import 'package:test/test.dart';
 import 'timezone_test_core.dart';
 
-main() {
+void main() {
   // The test date is Jan 1, so Brazilian Summer Time will be in effect.
   testTimezone('America/Sao_Paulo', expectedUtcOffset: -2);
 }
diff --git a/test/compact_number_test_data.dart b/test/compact_number_test_data.dart
index b90f119..0951c15 100755
--- a/test/compact_number_test_data.dart
+++ b/test/compact_number_test_data.dart
@@ -14,6 +14,9 @@
 /// significant digits and decimal digits. Manual edits were made to pair up
 /// CLDR ver. 35 formats with old digit handling.
 
+// MANUAL EDIT TO SUPPRESS WARNINGS IN GENERATED CODE
+// ignore_for_file: prefer_single_quotes
+
 /// The test data. A map, keyed by locale name, whose values
 /// are a list of [basic, shortform, longform] formatted data
 /// for different numbers.
diff --git a/test/data_directory.dart b/test/data_directory.dart
index 72e33c6..2bb9fa3 100644
--- a/test/data_directory.dart
+++ b/test/data_directory.dart
@@ -11,8 +11,8 @@
 ///   run things by default
 library data_directory;
 
-import "dart:io";
-import "package:path/path.dart" as path;
+import 'dart:io';
+import 'package:path/path.dart' as path;
 
 String get dataDirectory {
   return path.join(intlDirectory, datesRelativeToIntl);
@@ -21,13 +21,13 @@
 /// Returns whether [dir] is the root of the `intl` package. We validate that it
 /// is by looking for a pubspec file with the entry `name: intl`.
 bool _isIntlRoot(String dir) {
-  var file = new File(path.join(dir, 'pubspec.yaml'));
+  var file = File(path.join(dir, 'pubspec.yaml'));
   if (!file.existsSync()) return false;
   return file.readAsStringSync().contains('name: intl\n');
 }
 
 String get intlDirectory {
-  var dir;
+  String dir;
   if (Platform.script.scheme == 'file') {
     dir = path.fromUri(Platform.script);
   } else {
@@ -39,7 +39,7 @@
     if (_isIntlRoot(dir)) return dir;
     dir = path.dirname(dir);
   }
-  throw new UnsupportedError(
+  throw UnsupportedError(
       'Cannot find the root directory of the `intl` package.');
 }
 
diff --git a/test/date_time_format_custom_test.dart b/test/date_time_format_custom_test.dart
index ca1d0ae..6a1e64d 100644
--- a/test/date_time_format_custom_test.dart
+++ b/test/date_time_format_custom_test.dart
@@ -6,25 +6,27 @@
 /// from the local copy.
 
 import 'dart:async';
-import 'date_time_format_test_stub.dart';
-import 'package:intl/date_symbol_data_local.dart' as localSymbols;
-import 'package:intl/date_time_patterns.dart' as localPatterns;
+
+import 'package:intl/date_symbol_data_local.dart' as local_symbols;
+import 'package:intl/date_time_patterns.dart' as local_patterns;
 import 'package:intl/date_symbol_data_custom.dart';
 
-main() {
-  var symbols = localSymbols.dateTimeSymbolMap();
-  var patterns = localPatterns.dateTimePatternMap();
+import 'date_time_format_test_stub.dart';
+
+void main() {
+  var symbols = local_symbols.dateTimeSymbolMap();
+  var patterns = local_patterns.dateTimePatternMap();
   var locales = <String>[];
   symbols.keys.take(10).forEach(locales.add);
   // Force inclusion of locales that are hard-coded in tests.
-  var requiredLocales = ["en_US", "de", "fr", "ja", "el", "de_AT"];
+  var requiredLocales = ['en_US', 'de', 'fr', 'ja', 'el', 'de_AT'];
   locales.addAll(requiredLocales);
   for (var locale in locales) {
-    print("initializing $locale");
+    print('initializing $locale');
     initializeDateFormattingCustom(
         locale: locale, symbols: symbols[locale], patterns: patterns[locale]);
   }
   runWith(() => locales, null, nullInitialization);
 }
 
-Future nullInitialization(String a, String b) => new Future.value(null);
+Future<void> nullInitialization(String a, String b) => Future.value(null);
diff --git a/test/date_time_format_file_even_test.dart b/test/date_time_format_file_even_test.dart
index eb6a723..2e55022 100644
--- a/test/date_time_format_file_even_test.dart
+++ b/test/date_time_format_file_even_test.dart
@@ -6,15 +6,15 @@
 /// local file system. This tests one half the locales, since testing all
 /// of them takes long enough that it may cause timeouts in the test bots.
 
-@Timeout(const Duration(seconds: 60))
-@TestOn("vm")
+@Timeout(Duration(seconds: 60))
+@TestOn('vm')
 library date_time_format_file_test_2;
 
-import 'date_time_format_test_stub.dart';
-import 'data_directory.dart';
 import 'package:intl/date_symbol_data_file.dart';
 import 'package:test/test.dart';
+import 'data_directory.dart';
+import 'date_time_format_test_stub.dart';
 
-main() {
+void main() {
   runWith(evenLocales, dataDirectory, initializeDateFormatting);
 }
diff --git a/test/date_time_format_file_odd_test.dart b/test/date_time_format_file_odd_test.dart
index 3bb2d66..687b392 100644
--- a/test/date_time_format_file_odd_test.dart
+++ b/test/date_time_format_file_odd_test.dart
@@ -6,15 +6,15 @@
 /// local file system. This tests one half the locales, since testing all
 /// of them takes long enough that it may cause timeouts in the test bots.
 
-@Timeout(const Duration(seconds: 60))
-@TestOn("vm")
+@Timeout(Duration(seconds: 60))
+@TestOn('vm')
 library date_time_format_file_test_1;
 
-import 'date_time_format_test_stub.dart';
-import 'data_directory.dart';
 import 'package:intl/date_symbol_data_file.dart';
 import 'package:test/test.dart';
+import 'data_directory.dart';
+import 'date_time_format_test_stub.dart';
 
-main() {
+void main() {
   runWith(oddLocales, dataDirectory, initializeDateFormatting);
 }
diff --git a/test/date_time_format_local_even_test.dart b/test/date_time_format_local_even_test.dart
index cbeee35..e52cb31 100644
--- a/test/date_time_format_local_even_test.dart
+++ b/test/date_time_format_local_even_test.dart
@@ -9,9 +9,9 @@
 
 library date_time_format_test_2;
 
-import 'date_time_format_test_stub.dart';
 import 'package:intl/date_symbol_data_local.dart';
+import 'date_time_format_test_stub.dart';
 
-main() {
+void main() {
   runWith(evenLocales, null, initializeDateFormatting);
 }
diff --git a/test/date_time_format_local_odd_test.dart b/test/date_time_format_local_odd_test.dart
index 5102bcc..ecede2d 100644
--- a/test/date_time_format_local_odd_test.dart
+++ b/test/date_time_format_local_odd_test.dart
@@ -9,9 +9,9 @@
 
 library date_time_format_test_1;
 
-import 'date_time_format_test_stub.dart';
 import 'package:intl/date_symbol_data_local.dart';
+import 'date_time_format_test_stub.dart';
 
-main() {
+void main() {
   runWith(oddLocales, null, initializeDateFormatting);
 }
diff --git a/test/date_time_format_test_core.dart b/test/date_time_format_test_core.dart
index 951ef42..83982c0 100644
--- a/test/date_time_format_test_core.dart
+++ b/test/date_time_format_test_core.dart
@@ -8,9 +8,9 @@
 
 library date_time_format_tests;
 
+import 'package:intl/intl.dart';
 import 'package:test/test.dart';
 import 'date_time_format_test_data.dart';
-import 'package:intl/intl.dart';
 
 var formatsToTest = const [
   DateFormat.DAY,
@@ -66,50 +66,50 @@
 var icuFormatNamesToTest = const [
   // It would be really nice to not have to duplicate this and just be able
   // to use the names to get reflective access.
-  "DAY",
-  "ABBR_WEEKDAY",
-  "WEEKDAY",
-  "ABBR_STANDALONE_MONTH",
-  "STANDALONE_MONTH",
-  "NUM_MONTH",
-  "NUM_MONTH_DAY",
-  "NUM_MONTH_WEEKDAY_DAY",
-  "ABBR_MONTH",
-  "ABBR_MONTH_DAY",
-  "ABBR_MONTH_WEEKDAY_DAY",
-  "MONTH",
-  "MONTH_DAY",
-  "MONTH_WEEKDAY_DAY",
-  "ABBR_QUARTER",
-  "QUARTER",
-  "YEAR",
-  "YEAR_NUM_MONTH",
-  "YEAR_NUM_MONTH_DAY",
-  "YEAR_NUM_MONTH_WEEKDAY_DAY",
-  "YEAR_ABBR_MONTH",
-  "YEAR_ABBR_MONTH_DAY",
-  "YEAR_ABBR_MONTH_WEEKDAY_DAY",
-  "YEAR_MONTH",
-  "YEAR_MONTH_DAY",
-  "YEAR_MONTH_WEEKDAY_DAY",
+  'DAY',
+  'ABBR_WEEKDAY',
+  'WEEKDAY',
+  'ABBR_STANDALONE_MONTH',
+  'STANDALONE_MONTH',
+  'NUM_MONTH',
+  'NUM_MONTH_DAY',
+  'NUM_MONTH_WEEKDAY_DAY',
+  'ABBR_MONTH',
+  'ABBR_MONTH_DAY',
+  'ABBR_MONTH_WEEKDAY_DAY',
+  'MONTH',
+  'MONTH_DAY',
+  'MONTH_WEEKDAY_DAY',
+  'ABBR_QUARTER',
+  'QUARTER',
+  'YEAR',
+  'YEAR_NUM_MONTH',
+  'YEAR_NUM_MONTH_DAY',
+  'YEAR_NUM_MONTH_WEEKDAY_DAY',
+  'YEAR_ABBR_MONTH',
+  'YEAR_ABBR_MONTH_DAY',
+  'YEAR_ABBR_MONTH_WEEKDAY_DAY',
+  'YEAR_MONTH',
+  'YEAR_MONTH_DAY',
+  'YEAR_MONTH_WEEKDAY_DAY',
   // TODO(alanknight): CLDR and ICU appear to disagree on these for Japanese.
   // omit for the time being
-  //    "YEAR_ABBR_QUARTER",
-  //    "YEAR_QUARTER",
-  "HOUR24",
-  "HOUR24_MINUTE",
-  "HOUR24_MINUTE_SECOND",
-  "HOUR",
-  "HOUR_MINUTE",
-  "HOUR_MINUTE_SECOND",
+  //    'YEAR_ABBR_QUARTER',
+  //    'YEAR_QUARTER',
+  'HOUR24',
+  'HOUR24_MINUTE',
+  'HOUR24_MINUTE_SECOND',
+  'HOUR',
+  'HOUR_MINUTE',
+  'HOUR_MINUTE_SECOND',
   // TODO(alanknight): Time zone support
-  //    "HOUR_MINUTE_GENERIC_TZ",
-  //    "HOUR_MINUTE_TZ",
-  //    "HOUR_GENERIC_TZ",
-  //    "HOUR_TZ",
-  "MINUTE",
-  "MINUTE_SECOND",
-  "SECOND"
+  //    'HOUR_MINUTE_GENERIC_TZ',
+  //    'HOUR_MINUTE_TZ',
+  //    'HOUR_GENERIC_TZ',
+  //    'HOUR_TZ',
+  'MINUTE',
+  'MINUTE_SECOND',
+  'SECOND'
   // ABBR_GENERIC_TZ,
   // GENERIC_TZ,
   // ABBR_SPECIFIC_TZ,
@@ -121,19 +121,20 @@
 /// locale. [expectedResults] is a map from ICU format names to the
 /// expected result of formatting [date] according to that format in
 /// [localeName].
-testLocale(String localeName, Map expectedResults, DateTime date) {
-  var intl = new Intl(localeName);
-  for (int i = 0; i < formatsToTest.length; i++) {
+void testLocale(
+    String localeName, Map<String, String> expectedResults, DateTime date) {
+  var intl = Intl(localeName);
+  for (var i = 0; i < formatsToTest.length; i++) {
     var skeleton = formatsToTest[i];
     var format = intl.date(skeleton);
     var icuName = icuFormatNamesToTest[i];
     var actualResult = format.format(date);
     expect(expectedResults[icuName], equals(actualResult),
-        reason: "Mismatch in $localeName, testing skeleton '$skeleton'");
+        reason: 'Mismatch in $localeName, testing skeleton "$skeleton"');
   }
 }
 
-testRoundTripParsing(String localeName, DateTime date,
+void testRoundTripParsing(String localeName, DateTime date,
     [bool forceAscii = false]) {
   // In order to test parsing, we can't just read back the date, because
   // printing in most formats loses information. But we can test that
@@ -154,10 +155,10 @@
     DateFormat.NUM_MONTH_WEEKDAY_DAY,
     DateFormat.ABBR_MONTH_WEEKDAY_DAY
   ];
-  for (int i = 0; i < formatsToTest.length; i++) {
+  for (var i = 0; i < formatsToTest.length; i++) {
     var skeleton = formatsToTest[i];
     if (!badSkeletons.any((x) => x == skeleton)) {
-      var format = new DateFormat(skeleton, localeName);
+      var format = DateFormat(skeleton, localeName);
       if (forceAscii) format.useNativeDigits = false;
       var actualResult = format.format(date);
       var parsed = format.parseStrict(actualResult);
@@ -170,16 +171,13 @@
 /// A shortcut for returning all the locales we have available.
 List<String> allLocales() => DateFormat.allLocalesWithSymbols();
 
-typedef List<String> SubsetFuncType();
+typedef SubsetFuncType = List<String> Function();
 SubsetFuncType _subsetFunc;
 
 List<String> _subsetValue;
 
 List<String> get subset {
-  if (_subsetValue == null) {
-    _subsetValue = _subsetFunc();
-  }
-  return _subsetValue;
+  return _subsetValue ??= _subsetFunc();
 }
 
 // TODO(alanknight): Run specific tests for the en_ISO locale which isn't
@@ -190,56 +188,56 @@
   _subsetFunc = subsetFunc;
 
   test('Multiple patterns', () {
-    var date = new DateTime.now();
-    var multiple1 = new DateFormat.yMd().add_jms();
-    var multiple2 = new DateFormat("yMd").add_jms();
-    var separate1 = new DateFormat.yMd();
-    var separate2 = new DateFormat.jms();
-    var separateFormat = "${separate1.format(date)} ${separate2.format(date)}";
+    var date = DateTime.now();
+    var multiple1 = DateFormat.yMd().add_jms();
+    var multiple2 = DateFormat('yMd').add_jms();
+    var separate1 = DateFormat.yMd();
+    var separate2 = DateFormat.jms();
+    var separateFormat = '${separate1.format(date)} ${separate2.format(date)}';
     expect(multiple1.format(date), equals(multiple2.format(date)));
     expect(multiple1.format(date), equals(separateFormat));
-    var customPunctuation = new DateFormat("yMd").addPattern("jms", ":::");
-    var custom = "${separate1.format(date)}:::${separate2.format(date)}";
+    var customPunctuation = DateFormat('yMd').addPattern('jms', ':::');
+    var custom = '${separate1.format(date)}:::${separate2.format(date)}';
     expect(customPunctuation.format(date), equals(custom));
   });
 
   test('Basic date format parsing', () {
-    var date_format = new DateFormat("d");
-    expect(date_format.parsePattern("hh:mm:ss").map((x) => x.pattern).toList(),
-        orderedEquals(["hh", ":", "mm", ":", "ss"]));
-    expect(date_format.parsePattern("hh:mm:ss").map((x) => x.pattern).toList(),
-        orderedEquals(["hh", ":", "mm", ":", "ss"]));
+    var dateFormat = DateFormat('d');
+    expect(dateFormat.parsePattern('hh:mm:ss').map((x) => x.pattern).toList(),
+        orderedEquals(['hh', ':', 'mm', ':', 'ss']));
+    expect(dateFormat.parsePattern('hh:mm:ss').map((x) => x.pattern).toList(),
+        orderedEquals(['hh', ':', 'mm', ':', 'ss']));
   });
 
   test('Test ALL the supported formats on representative locales', () {
-    var aDate = new DateTime(2012, 1, 27, 20, 58, 59, 0);
-    testLocale("en_US", English, aDate);
+    var aDate = DateTime(2012, 1, 27, 20, 58, 59, 0);
+    testLocale('en_US', english, aDate);
     if (subset.length > 1) {
       // Don't run if we have just one locale, so some of these won't be there.
-      testLocale("de_DE", German, aDate);
-      testLocale("fr_FR", French, aDate);
-      testLocale("ja_JP", Japanese, aDate);
-      testLocale("el_GR", Greek, aDate);
-      testLocale("de_AT", Austrian, aDate);
+      testLocale('de_DE', german, aDate);
+      testLocale('fr_FR', french, aDate);
+      testLocale('ja_JP', japanese, aDate);
+      testLocale('el_GR', greek, aDate);
+      testLocale('de_AT', austrian, aDate);
     }
   });
 
   test('Test round-trip parsing of dates', () {
     var hours = [0, 1, 11, 12, 13, 23];
     var months = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
-    // For locales that use non-ascii digits, e.g. "ar", also test
+    // For locales that use non-ascii digits, e.g. 'ar', also test
     // forcing ascii digits.
     for (var locale in subset) {
-      var alsoForceAscii = new DateFormat.d(locale).usesNativeDigits;
+      var alsoForceAscii = DateFormat.d(locale).usesNativeDigits;
       for (var month in months) {
-        var aDate = new DateTime(2012, month, 27, 13, 58, 59, 012);
+        var aDate = DateTime(2012, month, 27, 13, 58, 59, 012);
         testRoundTripParsing(locale, aDate);
         if (alsoForceAscii) {
           testRoundTripParsing(locale, aDate, true);
         }
       }
       for (var hour in hours) {
-        var aDate = new DateTime(2012, 1, 27, hour, 58, 59, 123);
+        var aDate = DateTime(2012, 1, 27, hour, 58, 59, 123);
         testRoundTripParsing(locale, aDate);
         if (alsoForceAscii) {
           testRoundTripParsing(locale, aDate, true);
@@ -255,68 +253,68 @@
   test('Test malformed locales', () {
     // Don't run if we have just one locale, which may not include these.
     if (subset.length <= 1) return;
-    var aDate = new DateTime(2012, 1, 27, 20, 58, 59, 0);
+    var aDate = DateTime(2012, 1, 27, 20, 58, 59, 0);
     // Austrian is a useful test locale here because it differs slightly
-    // from the generic "de" locale so we can tell the difference between
-    // correcting to "de_AT" and falling back to just "de".
-    testLocale('de-AT', Austrian, aDate);
-    testLocale('de_at', Austrian, aDate);
-    testLocale('de-at', Austrian, aDate);
+    // from the generic 'de' locale so we can tell the difference between
+    // correcting to 'de_AT' and falling back to just 'de'.
+    testLocale('de-AT', austrian, aDate);
+    testLocale('de_at', austrian, aDate);
+    testLocale('de-at', austrian, aDate);
   });
 
   test('Test format creation via Intl', () {
     // Don't run if we have just one locale, which may not include these.
     if (subset.length <= 1) return;
-    var intl = new Intl('ja_JP');
+    var intl = Intl('ja_JP');
     var instanceJP = intl.date('jms');
     var instanceUS = intl.date('jms', 'en_US');
     var blank = intl.date('jms');
-    var date = new DateTime(2012, 1, 27, 20, 58, 59, 0);
-    expect(instanceJP.format(date), equals("20:58:59"));
-    expect(instanceUS.format(date), equals("8:58:59 PM"));
-    expect(blank.format(date), equals("20:58:59"));
+    var date = DateTime(2012, 1, 27, 20, 58, 59, 0);
+    expect(instanceJP.format(date), equals('20:58:59'));
+    expect(instanceUS.format(date), equals('8:58:59 PM'));
+    expect(blank.format(date), equals('20:58:59'));
   });
 
   test('Test explicit format string', () {
     // Don't run if we have just one locale, which may not include these.
     if (subset.length <= 1) return;
-    var aDate = new DateTime(2012, 1, 27, 20, 58, 59, 0);
+    var aDate = DateTime(2012, 1, 27, 20, 58, 59, 0);
     // An explicit format that doesn't conform to any skeleton
-    var us = new DateFormat(r'yy //// :W \\\\ dd:ss ^&@ M');
-    expect(us.format(aDate), equals(r"12 //// :W \\\\ 27:59 ^&@ 1"));
+    var us = DateFormat(r'yy //// :W \\\\ dd:ss ^&@ M');
+    expect(us.format(aDate), equals(r'12 //// :W \\\\ 27:59 ^&@ 1'));
     // The result won't change with locale unless we use fields that are words.
-    var greek = new DateFormat(r'yy //// :W \\\\ dd:ss ^&@ M', 'el_GR');
-    expect(greek.format(aDate), equals(r"12 //// :W \\\\ 27:59 ^&@ 1"));
-    var usWithWords = new DateFormat('yy / :W \\ dd:ss ^&@ MMM', 'en_US');
-    var greekWithWords = new DateFormat('yy / :W \\ dd:ss ^&@ MMM', 'el_GR');
-    expect(usWithWords.format(aDate), equals(r"12 / :W \ 27:59 ^&@ Jan"));
-    expect(greekWithWords.format(aDate), equals(r"12 / :W \ 27:59 ^&@ Ιαν"));
-    var escaped = new DateFormat(r"hh 'o''clock'");
+    var greek = DateFormat(r'yy //// :W \\\\ dd:ss ^&@ M', 'el_GR');
+    expect(greek.format(aDate), equals(r'12 //// :W \\\\ 27:59 ^&@ 1'));
+    var usWithWords = DateFormat('yy / :W \\ dd:ss ^&@ MMM', 'en_US');
+    var greekWithWords = DateFormat('yy / :W \\ dd:ss ^&@ MMM', 'el_GR');
+    expect(usWithWords.format(aDate), equals(r'12 / :W \ 27:59 ^&@ Jan'));
+    expect(greekWithWords.format(aDate), equals(r'12 / :W \ 27:59 ^&@ Ιαν'));
+    var escaped = DateFormat(r"hh 'o''clock'");
     expect(escaped.format(aDate), equals(r"08 o'clock"));
     var reParsed = escaped.parse(escaped.format(aDate));
     expect(escaped.format(reParsed), equals(escaped.format(aDate)));
-    var noSeparators = new DateFormat('HHmmss');
-    expect(noSeparators.format(aDate), equals("205859"));
+    var noSeparators = DateFormat('HHmmss');
+    expect(noSeparators.format(aDate), equals('205859'));
   });
 
   test('Test fractional seconds padding', () {
-    var one = new DateTime(2012, 1, 27, 20, 58, 59, 1);
-    var oneHundred = new DateTime(2012, 1, 27, 20, 58, 59, 100);
-    var fractional = new DateFormat('hh:mm:ss.SSS', 'en_US');
+    var one = DateTime(2012, 1, 27, 20, 58, 59, 1);
+    var oneHundred = DateTime(2012, 1, 27, 20, 58, 59, 100);
+    var fractional = DateFormat('hh:mm:ss.SSS', 'en_US');
     expect(fractional.format(one), equals('08:58:59.001'));
     expect(fractional.format(oneHundred), equals('08:58:59.100'));
-    var long = new DateFormat('ss.SSSSSSSS', 'en_US');
+    var long = DateFormat('ss.SSSSSSSS', 'en_US');
     expect(long.format(oneHundred), equals('59.10000000'));
     expect(long.format(one), equals('59.00100000'));
   });
 
   test('Test parseUTC', () {
-    var local = new DateTime(2012, 1, 27, 20, 58, 59, 1);
-    var utc = new DateTime.utc(2012, 1, 27, 20, 58, 59, 1);
+    var local = DateTime(2012, 1, 27, 20, 58, 59, 1);
+    var utc = DateTime.utc(2012, 1, 27, 20, 58, 59, 1);
     // Getting the offset as a duration via difference() would be simpler,
     // but doesn't work on dart2js in checked mode. See issue 4437.
     var offset = utc.millisecondsSinceEpoch - local.millisecondsSinceEpoch;
-    var format = new DateFormat('yyyy-MM-dd HH:mm:ss');
+    var format = DateFormat('yyyy-MM-dd HH:mm:ss');
     var localPrinted = format.format(local);
     var parsed = format.parse(localPrinted);
     var parsedUTC = format.parseUTC(format.format(utc));
@@ -328,22 +326,22 @@
   });
 
   test('Test 0-padding', () {
-    var someDate = new DateTime(123, 1, 2, 3, 4, 5);
-    var format = new DateFormat('yyyy-MM-dd HH:mm:ss');
+    var someDate = DateTime(123, 1, 2, 3, 4, 5);
+    var format = DateFormat('yyyy-MM-dd HH:mm:ss');
     expect(format.format(someDate), '0123-01-02 03:04:05');
   });
 
   test('Test default format', () {
-    var someDate = new DateTime(2012, 1, 27, 20, 58, 59, 1);
-    var emptyFormat = new DateFormat(null, "en_US");
-    var knownDefault = new DateFormat.yMMMMd("en_US").add_jms();
+    var someDate = DateTime(2012, 1, 27, 20, 58, 59, 1);
+    var emptyFormat = DateFormat(null, 'en_US');
+    var knownDefault = DateFormat.yMMMMd('en_US').add_jms();
     var result = emptyFormat.format(someDate);
     var knownResult = knownDefault.format(someDate);
     expect(result, knownResult);
   });
 
   test('Get symbols', () {
-    var emptyFormat = new DateFormat(null, "en_US");
+    var emptyFormat = DateFormat(null, 'en_US');
     var symbols = emptyFormat.dateSymbols;
     expect(symbols.NARROWWEEKDAYS, ['S', 'M', 'T', 'W', 'T', 'F', 'S']);
   });
@@ -363,17 +361,17 @@
       'Q4',
       'Q4'
     ];
-    var quarterFormat = new DateFormat.QQQ();
-    for (int i = 0; i < 12; i++) {
+    var quarterFormat = DateFormat.QQQ();
+    for (var i = 0; i < 12; i++) {
       var month = i + 1;
-      var aDate = new DateTime(2012, month, 27, 13, 58, 59, 012);
+      var aDate = DateTime(2012, month, 27, 13, 58, 59, 012);
       var formatted = quarterFormat.format(aDate);
       expect(formatted, quarters[i]);
     }
   });
 
   test('Quarter formatting', () {
-    var date = new DateTime(2012, 02, 27);
+    var date = DateTime(2012, 02, 27);
     var formats = {
       'Q': '1',
       'QQ': '01',
@@ -382,14 +380,14 @@
       'QQQQQ': '00001'
     };
     formats.forEach((pattern, result) {
-      expect(new DateFormat(pattern, 'en_US').format(date), result);
+      expect(DateFormat(pattern, 'en_US').format(date), result);
     });
 
     if (subset.contains('zh_CN')) {
       // Especially test zh_CN formatting for `QQQ` and `yQQQ` because it
       // contains a single `Q`.
-      expect(new DateFormat.QQQ('zh_CN').format(date), '1季度');
-      expect(new DateFormat.yQQQ('zh_CN').format(date), '2012年第1季度');
+      expect(DateFormat.QQQ('zh_CN').format(date), '1季度');
+      expect(DateFormat.yQQQ('zh_CN').format(date), '2012年第1季度');
     }
   });
 
@@ -397,23 +395,23 @@
   /// to a Date object. If [year] is a leap year, then pass 1 for
   /// [leapDay], otherwise pass 0.
   Map<int, DateTime> generateDates(int year, int leapDay) =>
-      new Iterable.generate(365 + leapDay, (n) => n + 1)
+      Iterable.generate(365 + leapDay, (n) => n + 1)
           .map((day) {
             // Typically a "date" would have a time value of zero, but we
             // give them an hour value, because they can get created with an
             // offset to the previous day in time zones where the daylight
             // savings transition happens at midnight (e.g. Brazil).
-            var result = new DateTime(year, 1, day, 3);
+            var result = DateTime(year, 1, day, 3);
             // TODO(alanknight): This is a workaround for dartbug.com/15560.
-            if (result.toUtc() == result) result = new DateTime(year, 1, day);
+            if (result.toUtc() == result) result = DateTime(year, 1, day);
             return result;
           })
           .toList()
           .asMap();
 
-  void verifyOrdinals(Map dates) {
-    var f = new DateFormat("D");
-    var withYear = new DateFormat("yyyy D");
+  void verifyOrdinals(Map<int, DateTime> dates) {
+    var f = DateFormat('D');
+    var withYear = DateFormat('yyyy D');
     dates.forEach((number, date) {
       var formatted = f.format(date);
       expect(formatted, (number + 1).toString());
@@ -429,24 +427,24 @@
   }
 
   test('Ordinal Date', () {
-    var f = new DateFormat("D");
+    var f = DateFormat('D');
     var dates = generateDates(2012, 1);
     var nonLeapDates = generateDates(2013, 0);
     verifyOrdinals(dates);
     verifyOrdinals(nonLeapDates);
     // Check one hard-coded just to be on the safe side.
-    var aDate = new DateTime(2012, 4, 27, 13, 58, 59, 012);
-    expect(f.format(aDate), "118");
+    var aDate = DateTime(2012, 4, 27, 13, 58, 59, 012);
+    expect(f.format(aDate), '118');
   });
 
   // There are some very odd off-by-one bugs when parsing dates. Put in
   // some very basic tests to try and get more information.
   test('Simple Date Creation', () {
-    var format = new DateFormat(DateFormat.NUM_MONTH);
-    var first = format.parse("7");
-    var second = format.parse("7");
-    var basic = new DateTime(1970, 7);
-    var basicAgain = new DateTime(1970, 7);
+    var format = DateFormat(DateFormat.NUM_MONTH);
+    var first = format.parse('7');
+    var second = format.parse('7');
+    var basic = DateTime(1970, 7);
+    var basicAgain = DateTime(1970, 7);
     expect(first, second);
     expect(first, basic);
     expect(basic, basicAgain);
@@ -455,13 +453,13 @@
 
   test('Native digit default', () {
     if (!subset.contains('ar')) return;
-    var nativeFormat = new DateFormat.yMd('ar');
-    var date = new DateTime(1974, 12, 30);
+    var nativeFormat = DateFormat.yMd('ar');
+    var date = DateTime(1974, 12, 30);
     var native = nativeFormat.format(date);
     expect(DateFormat.shouldUseNativeDigitsByDefaultFor('ar'), true);
     DateFormat.useNativeDigitsByDefaultFor('ar', false);
     expect(DateFormat.shouldUseNativeDigitsByDefaultFor('ar'), false);
-    var asciiFormat = new DateFormat.yMd('ar');
+    var asciiFormat = DateFormat.yMd('ar');
     var ascii = asciiFormat.format(date);
     // This prints with RTL markers before the slashes. That doesn't seem good,
     // but it's what the data says.
@@ -483,6 +481,5 @@
     expect(zeroToTwentyThree.format(late), '00');
     expect(oneToTwelve.format(late), '12');
     expect(zeroToEleven.format(late), '00');
-
   });
 }
diff --git a/test/date_time_format_test_data.dart b/test/date_time_format_test_data.dart
index f9382f8..a0a57f7 100644
--- a/test/date_time_format_test_data.dart
+++ b/test/date_time_format_test_data.dart
@@ -11,329 +11,329 @@
 
 library date_time_format_test_data;
 
-var English = const {
-  "DAY": "27",
-  "ABBR_WEEKDAY": "Fri",
-  "WEEKDAY": "Friday",
-  "ABBR_STANDALONE_MONTH": "Jan",
-  "STANDALONE_MONTH": "January",
-  "NUM_MONTH": "1",
-  "NUM_MONTH_DAY": "1/27",
-  "NUM_MONTH_WEEKDAY_DAY": "Fri, 1/27",
-  "ABBR_MONTH": "Jan",
-  "ABBR_MONTH_DAY": "Jan 27",
-  "ABBR_MONTH_WEEKDAY_DAY": "Fri, Jan 27",
-  "MONTH": "January",
-  "MONTH_DAY": "January 27",
-  "MONTH_WEEKDAY_DAY": "Friday, January 27",
-  "ABBR_QUARTER": "Q1",
-  "QUARTER": "1st quarter",
-  "YEAR": "2012",
-  "YEAR_NUM_MONTH": "1/2012",
-  "YEAR_NUM_MONTH_DAY": "1/27/2012",
-  "YEAR_NUM_MONTH_WEEKDAY_DAY": "Fri, 1/27/2012",
-  "YEAR_ABBR_MONTH": "Jan 2012",
-  "YEAR_ABBR_MONTH_DAY": "Jan 27, 2012",
-  "YEAR_ABBR_MONTH_WEEKDAY_DAY": "Fri, Jan 27, 2012",
-  "YEAR_MONTH": "January 2012",
-  "YEAR_MONTH_DAY": "January 27, 2012",
-  "YEAR_MONTH_WEEKDAY_DAY": "Friday, January 27, 2012",
-  "YEAR_ABBR_QUARTER": "Q1 2012",
-  "YEAR_QUARTER": "1st quarter 2012",
-  "HOUR24": "20",
-  "HOUR24_MINUTE": "20:58",
-  "HOUR24_MINUTE_SECOND": "20:58:59",
-  "HOUR": "8 PM",
-  "HOUR_MINUTE": "8:58 PM",
-  "HOUR_MINUTE_SECOND": "8:58:59 PM",
-  "MINUTE": "58",
-  "MINUTE_SECOND": "58:59",
-  "SECOND": "59",
-  "LOCATION_TZ": "United States Time (Los Angeles)",
-  "GENERIC_TZ": "Pacific Time",
-  "ABBR_GENERIC_TZ": "PT",
-  "SPECIFIC_TZ": "Pacific Standard Time",
-  "ABBR_SPECIFIC_TZ": "PST",
-  "ABBR_UTC_TZ": "GMT-08:00",
-  "YEAR_MONTH_WEEKDAY_DAY + HOUR_MINUTE_SECOND":
-      "Friday, January 27, 2012 8:58:59 PM",
-  "YEAR_MONTH_WEEKDAY_DAY + HOUR_MINUTE_SECOND + GENERIC_TZ":
-      "Friday, January 27, 2012 8:58:59 PM Pacific Time",
-  "YEAR_ABBR_MONTH_WEEKDAY_DAY + HOUR_MINUTE_SECOND + ABBR_SPECIFIC_TZ":
-      "Fri, Jan 27, 2012 8:58:59 PM PST",
-  "HOUR_MINUTE_SECOND + ABBR_GENERIC_TZ": "8:58:59 PM PT",
-  "HOUR_MINUTE + ABBR_SPECIFIC_TZ": "8:58 PM PST"
+const english = {
+  'DAY': '27',
+  'ABBR_WEEKDAY': 'Fri',
+  'WEEKDAY': 'Friday',
+  'ABBR_STANDALONE_MONTH': 'Jan',
+  'STANDALONE_MONTH': 'January',
+  'NUM_MONTH': '1',
+  'NUM_MONTH_DAY': '1/27',
+  'NUM_MONTH_WEEKDAY_DAY': 'Fri, 1/27',
+  'ABBR_MONTH': 'Jan',
+  'ABBR_MONTH_DAY': 'Jan 27',
+  'ABBR_MONTH_WEEKDAY_DAY': 'Fri, Jan 27',
+  'MONTH': 'January',
+  'MONTH_DAY': 'January 27',
+  'MONTH_WEEKDAY_DAY': 'Friday, January 27',
+  'ABBR_QUARTER': 'Q1',
+  'QUARTER': '1st quarter',
+  'YEAR': '2012',
+  'YEAR_NUM_MONTH': '1/2012',
+  'YEAR_NUM_MONTH_DAY': '1/27/2012',
+  'YEAR_NUM_MONTH_WEEKDAY_DAY': 'Fri, 1/27/2012',
+  'YEAR_ABBR_MONTH': 'Jan 2012',
+  'YEAR_ABBR_MONTH_DAY': 'Jan 27, 2012',
+  'YEAR_ABBR_MONTH_WEEKDAY_DAY': 'Fri, Jan 27, 2012',
+  'YEAR_MONTH': 'January 2012',
+  'YEAR_MONTH_DAY': 'January 27, 2012',
+  'YEAR_MONTH_WEEKDAY_DAY': 'Friday, January 27, 2012',
+  'YEAR_ABBR_QUARTER': 'Q1 2012',
+  'YEAR_QUARTER': '1st quarter 2012',
+  'HOUR24': '20',
+  'HOUR24_MINUTE': '20:58',
+  'HOUR24_MINUTE_SECOND': '20:58:59',
+  'HOUR': '8 PM',
+  'HOUR_MINUTE': '8:58 PM',
+  'HOUR_MINUTE_SECOND': '8:58:59 PM',
+  'MINUTE': '58',
+  'MINUTE_SECOND': '58:59',
+  'SECOND': '59',
+  'LOCATION_TZ': 'United States Time (Los Angeles)',
+  'GENERIC_TZ': 'Pacific Time',
+  'ABBR_GENERIC_TZ': 'PT',
+  'SPECIFIC_TZ': 'Pacific Standard Time',
+  'ABBR_SPECIFIC_TZ': 'PST',
+  'ABBR_UTC_TZ': 'GMT-08:00',
+  'YEAR_MONTH_WEEKDAY_DAY + HOUR_MINUTE_SECOND':
+      'Friday, January 27, 2012 8:58:59 PM',
+  'YEAR_MONTH_WEEKDAY_DAY + HOUR_MINUTE_SECOND + GENERIC_TZ':
+      'Friday, January 27, 2012 8:58:59 PM Pacific Time',
+  'YEAR_ABBR_MONTH_WEEKDAY_DAY + HOUR_MINUTE_SECOND + ABBR_SPECIFIC_TZ':
+      'Fri, Jan 27, 2012 8:58:59 PM PST',
+  'HOUR_MINUTE_SECOND + ABBR_GENERIC_TZ': '8:58:59 PM PT',
+  'HOUR_MINUTE + ABBR_SPECIFIC_TZ': '8:58 PM PST'
 };
 
-var German = const {
-  "DAY": "27",
-  "ABBR_WEEKDAY": "Fr",
-  "WEEKDAY": "Freitag",
-  "ABBR_STANDALONE_MONTH": "Jan",
-  "STANDALONE_MONTH": "Januar",
-  "NUM_MONTH": "1",
-  "NUM_MONTH_DAY": "27.1.",
-  "NUM_MONTH_WEEKDAY_DAY": "Fr., 27.1.",
-  "ABBR_MONTH": "Jan",
-  "ABBR_MONTH_DAY": "27. Jan.",
-  "ABBR_MONTH_WEEKDAY_DAY": "Fr., 27. Jan.",
-  "MONTH": "Januar",
-  "MONTH_DAY": "27. Januar",
-  "MONTH_WEEKDAY_DAY": "Freitag, 27. Januar",
-  "ABBR_QUARTER": "Q1",
-  "QUARTER": "1. Quartal",
-  "YEAR": "2012",
-  "YEAR_NUM_MONTH": "1.2012",
-  "YEAR_NUM_MONTH_DAY": "27.1.2012",
-  "YEAR_NUM_MONTH_WEEKDAY_DAY": "Fr., 27.1.2012",
-  "YEAR_ABBR_MONTH": "Jan. 2012",
-  "YEAR_ABBR_MONTH_DAY": "27. Jan. 2012",
-  "YEAR_ABBR_MONTH_WEEKDAY_DAY": "Fr., 27. Jan. 2012",
-  "YEAR_MONTH": "Januar 2012",
-  "YEAR_MONTH_DAY": "27. Januar 2012",
-  "YEAR_MONTH_WEEKDAY_DAY": "Freitag, 27. Januar 2012",
-  "YEAR_ABBR_QUARTER": "Q1 2012",
-  "YEAR_QUARTER": "1. Quartal 2012",
-  "HOUR24": "20 Uhr",
-  "HOUR24_MINUTE": "20:58",
-  "HOUR24_MINUTE_SECOND": "20:58:59",
-  "HOUR": "20 Uhr",
-  "HOUR_MINUTE": "20:58",
-  "HOUR_MINUTE_SECOND": "20:58:59",
-  "MINUTE": "58",
-  "MINUTE_SECOND": "58:59",
-  "SECOND": "59",
-  "LOCATION_TZ": "Vereinigte Staaten Zeit (Los Angeles)",
-  "GENERIC_TZ": "Nordamerikanische Westküstenzeit",
-  "ABBR_GENERIC_TZ": "Vereinigte Staaten Zeit (Los Angeles)",
-  "SPECIFIC_TZ": "Nordamerikanische Westküsten-Winterzeit",
-  "ABBR_SPECIFIC_TZ": "GMT-08:00",
-  "ABBR_UTC_TZ": "GMT-08:00",
-  "YEAR_MONTH_WEEKDAY_DAY + HOUR_MINUTE_SECOND":
-      "Freitag, 27. Januar 2012 20:58:59",
-  "YEAR_MONTH_WEEKDAY_DAY + HOUR_MINUTE_SECOND + GENERIC_TZ":
-      "Freitag, 27. Januar 2012 20:58:59 Nordamerikanische Westküstenzeit",
-  "YEAR_ABBR_MONTH_WEEKDAY_DAY + HOUR_MINUTE_SECOND + ABBR_SPECIFIC_TZ":
-      "Fr., 27. Jan 2012 20:58:59 GMT-08:00",
-  "HOUR_MINUTE_SECOND + ABBR_GENERIC_TZ":
-      "20:58:59 Vereinigte Staaten Zeit (Los Angeles)",
-  "HOUR_MINUTE + ABBR_SPECIFIC_TZ": "20:58 GMT-08:00"
+const german = {
+  'DAY': '27',
+  'ABBR_WEEKDAY': 'Fr',
+  'WEEKDAY': 'Freitag',
+  'ABBR_STANDALONE_MONTH': 'Jan',
+  'STANDALONE_MONTH': 'Januar',
+  'NUM_MONTH': '1',
+  'NUM_MONTH_DAY': '27.1.',
+  'NUM_MONTH_WEEKDAY_DAY': 'Fr., 27.1.',
+  'ABBR_MONTH': 'Jan',
+  'ABBR_MONTH_DAY': '27. Jan.',
+  'ABBR_MONTH_WEEKDAY_DAY': 'Fr., 27. Jan.',
+  'MONTH': 'Januar',
+  'MONTH_DAY': '27. Januar',
+  'MONTH_WEEKDAY_DAY': 'Freitag, 27. Januar',
+  'ABBR_QUARTER': 'Q1',
+  'QUARTER': '1. Quartal',
+  'YEAR': '2012',
+  'YEAR_NUM_MONTH': '1.2012',
+  'YEAR_NUM_MONTH_DAY': '27.1.2012',
+  'YEAR_NUM_MONTH_WEEKDAY_DAY': 'Fr., 27.1.2012',
+  'YEAR_ABBR_MONTH': 'Jan. 2012',
+  'YEAR_ABBR_MONTH_DAY': '27. Jan. 2012',
+  'YEAR_ABBR_MONTH_WEEKDAY_DAY': 'Fr., 27. Jan. 2012',
+  'YEAR_MONTH': 'Januar 2012',
+  'YEAR_MONTH_DAY': '27. Januar 2012',
+  'YEAR_MONTH_WEEKDAY_DAY': 'Freitag, 27. Januar 2012',
+  'YEAR_ABBR_QUARTER': 'Q1 2012',
+  'YEAR_QUARTER': '1. Quartal 2012',
+  'HOUR24': '20 Uhr',
+  'HOUR24_MINUTE': '20:58',
+  'HOUR24_MINUTE_SECOND': '20:58:59',
+  'HOUR': '20 Uhr',
+  'HOUR_MINUTE': '20:58',
+  'HOUR_MINUTE_SECOND': '20:58:59',
+  'MINUTE': '58',
+  'MINUTE_SECOND': '58:59',
+  'SECOND': '59',
+  'LOCATION_TZ': 'Vereinigte Staaten Zeit (Los Angeles)',
+  'GENERIC_TZ': 'Nordamerikanische Westküstenzeit',
+  'ABBR_GENERIC_TZ': 'Vereinigte Staaten Zeit (Los Angeles)',
+  'SPECIFIC_TZ': 'Nordamerikanische Westküsten-Winterzeit',
+  'ABBR_SPECIFIC_TZ': 'GMT-08:00',
+  'ABBR_UTC_TZ': 'GMT-08:00',
+  'YEAR_MONTH_WEEKDAY_DAY + HOUR_MINUTE_SECOND':
+      'Freitag, 27. Januar 2012 20:58:59',
+  'YEAR_MONTH_WEEKDAY_DAY + HOUR_MINUTE_SECOND + GENERIC_TZ':
+      'Freitag, 27. Januar 2012 20:58:59 Nordamerikanische Westküstenzeit',
+  'YEAR_ABBR_MONTH_WEEKDAY_DAY + HOUR_MINUTE_SECOND + ABBR_SPECIFIC_TZ':
+      'Fr., 27. Jan 2012 20:58:59 GMT-08:00',
+  'HOUR_MINUTE_SECOND + ABBR_GENERIC_TZ':
+      '20:58:59 Vereinigte Staaten Zeit (Los Angeles)',
+  'HOUR_MINUTE + ABBR_SPECIFIC_TZ': '20:58 GMT-08:00'
 };
 
-var Austrian = const {
-  "DAY": "27",
-  "ABBR_WEEKDAY": "Fr",
-  "WEEKDAY": "Freitag",
-  "ABBR_STANDALONE_MONTH": "Jän",
-  "STANDALONE_MONTH": "Jänner",
-  "NUM_MONTH": "1",
-  "NUM_MONTH_DAY": "27.1.",
-  "NUM_MONTH_WEEKDAY_DAY": "Fr., 27.1.",
-  "ABBR_MONTH": "Jän",
-  "ABBR_MONTH_DAY": "27. Jän.",
-  "ABBR_MONTH_WEEKDAY_DAY": "Fr., 27. Jän.",
-  "MONTH": "Jänner",
-  "MONTH_DAY": "27. Jänner",
-  "MONTH_WEEKDAY_DAY": "Freitag, 27. Jänner",
-  "ABBR_QUARTER": "Q1",
-  "QUARTER": "1. Quartal",
-  "YEAR": "2012",
-  "YEAR_NUM_MONTH": "1.2012",
-  "YEAR_NUM_MONTH_DAY": "27.1.2012",
-  "YEAR_NUM_MONTH_WEEKDAY_DAY": "Fr., 27.1.2012",
-  "YEAR_ABBR_MONTH": "Jän. 2012",
-  "YEAR_ABBR_MONTH_DAY": "27. Jän. 2012",
-  "YEAR_ABBR_MONTH_WEEKDAY_DAY": "Fr., 27. Jän. 2012",
-  "YEAR_MONTH": "Jänner 2012",
-  "YEAR_MONTH_DAY": "27. Jänner 2012",
-  "YEAR_MONTH_WEEKDAY_DAY": "Freitag, 27. Jänner 2012",
-  "YEAR_ABBR_QUARTER": "Q1 2012",
-  "YEAR_QUARTER": "1. Quartal 2012",
-  "HOUR24": "20 Uhr",
-  "HOUR24_MINUTE": "20:58",
-  "HOUR24_MINUTE_SECOND": "20:58:59",
-  "HOUR": "20 Uhr",
-  "HOUR_MINUTE": "20:58",
-  "HOUR_MINUTE_SECOND": "20:58:59",
-  "MINUTE": "58",
-  "MINUTE_SECOND": "58:59",
-  "SECOND": "59",
-  "LOCATION_TZ": "Vereinigte Staaten Zeit (Los Angeles)",
-  "GENERIC_TZ": "Nordamerikanische Westküstenzeit",
-  "ABBR_GENERIC_TZ": "Vereinigte Staaten Zeit (Los Angeles)",
-  "SPECIFIC_TZ": "Nordamerikanische Westküsten-Winterzeit",
-  "ABBR_SPECIFIC_TZ": "GMT-08:00",
-  "ABBR_UTC_TZ": "GMT-08:00",
-  "YEAR_MONTH_WEEKDAY_DAY + HOUR_MINUTE_SECOND":
-      "Freitag, 27. Jänner 2012 20:58:59",
-  "YEAR_MONTH_WEEKDAY_DAY + HOUR_MINUTE_SECOND + GENERIC_TZ":
-      "Freitag, 27. Jänner 2012 20:58:59 Nordamerikanische Westküstenzeit",
-  "YEAR_ABBR_MONTH_WEEKDAY_DAY + HOUR_MINUTE_SECOND + ABBR_SPECIFIC_TZ":
-      "Fr., 27. Jän 2012 20:58:59 GMT-08:00",
-  "HOUR_MINUTE_SECOND + ABBR_GENERIC_TZ":
-      "20:58:59 Vereinigte Staaten Zeit (Los Angeles)",
-  "HOUR_MINUTE + ABBR_SPECIFIC_TZ": "20:58 GMT-08:00"
+const austrian = {
+  'DAY': '27',
+  'ABBR_WEEKDAY': 'Fr',
+  'WEEKDAY': 'Freitag',
+  'ABBR_STANDALONE_MONTH': 'Jän',
+  'STANDALONE_MONTH': 'Jänner',
+  'NUM_MONTH': '1',
+  'NUM_MONTH_DAY': '27.1.',
+  'NUM_MONTH_WEEKDAY_DAY': 'Fr., 27.1.',
+  'ABBR_MONTH': 'Jän',
+  'ABBR_MONTH_DAY': '27. Jän.',
+  'ABBR_MONTH_WEEKDAY_DAY': 'Fr., 27. Jän.',
+  'MONTH': 'Jänner',
+  'MONTH_DAY': '27. Jänner',
+  'MONTH_WEEKDAY_DAY': 'Freitag, 27. Jänner',
+  'ABBR_QUARTER': 'Q1',
+  'QUARTER': '1. Quartal',
+  'YEAR': '2012',
+  'YEAR_NUM_MONTH': '1.2012',
+  'YEAR_NUM_MONTH_DAY': '27.1.2012',
+  'YEAR_NUM_MONTH_WEEKDAY_DAY': 'Fr., 27.1.2012',
+  'YEAR_ABBR_MONTH': 'Jän. 2012',
+  'YEAR_ABBR_MONTH_DAY': '27. Jän. 2012',
+  'YEAR_ABBR_MONTH_WEEKDAY_DAY': 'Fr., 27. Jän. 2012',
+  'YEAR_MONTH': 'Jänner 2012',
+  'YEAR_MONTH_DAY': '27. Jänner 2012',
+  'YEAR_MONTH_WEEKDAY_DAY': 'Freitag, 27. Jänner 2012',
+  'YEAR_ABBR_QUARTER': 'Q1 2012',
+  'YEAR_QUARTER': '1. Quartal 2012',
+  'HOUR24': '20 Uhr',
+  'HOUR24_MINUTE': '20:58',
+  'HOUR24_MINUTE_SECOND': '20:58:59',
+  'HOUR': '20 Uhr',
+  'HOUR_MINUTE': '20:58',
+  'HOUR_MINUTE_SECOND': '20:58:59',
+  'MINUTE': '58',
+  'MINUTE_SECOND': '58:59',
+  'SECOND': '59',
+  'LOCATION_TZ': 'Vereinigte Staaten Zeit (Los Angeles)',
+  'GENERIC_TZ': 'Nordamerikanische Westküstenzeit',
+  'ABBR_GENERIC_TZ': 'Vereinigte Staaten Zeit (Los Angeles)',
+  'SPECIFIC_TZ': 'Nordamerikanische Westküsten-Winterzeit',
+  'ABBR_SPECIFIC_TZ': 'GMT-08:00',
+  'ABBR_UTC_TZ': 'GMT-08:00',
+  'YEAR_MONTH_WEEKDAY_DAY + HOUR_MINUTE_SECOND':
+      'Freitag, 27. Jänner 2012 20:58:59',
+  'YEAR_MONTH_WEEKDAY_DAY + HOUR_MINUTE_SECOND + GENERIC_TZ':
+      'Freitag, 27. Jänner 2012 20:58:59 Nordamerikanische Westküstenzeit',
+  'YEAR_ABBR_MONTH_WEEKDAY_DAY + HOUR_MINUTE_SECOND + ABBR_SPECIFIC_TZ':
+      'Fr., 27. Jän 2012 20:58:59 GMT-08:00',
+  'HOUR_MINUTE_SECOND + ABBR_GENERIC_TZ':
+      '20:58:59 Vereinigte Staaten Zeit (Los Angeles)',
+  'HOUR_MINUTE + ABBR_SPECIFIC_TZ': '20:58 GMT-08:00'
 };
 
-var French = const {
-  "DAY": "27",
-  "ABBR_WEEKDAY": "ven.",
-  "WEEKDAY": "vendredi",
-  "ABBR_STANDALONE_MONTH": "janv.",
-  "STANDALONE_MONTH": "janvier",
-  "NUM_MONTH": "1",
-  "NUM_MONTH_DAY": "27/01",
-  "NUM_MONTH_WEEKDAY_DAY": "ven. 27/01",
-  "ABBR_MONTH": "janv.",
-  "ABBR_MONTH_DAY": "27 janv.",
-  "ABBR_MONTH_WEEKDAY_DAY": "ven. 27 janv.",
-  "MONTH": "janvier",
-  "MONTH_DAY": "27 janvier",
-  "MONTH_WEEKDAY_DAY": "vendredi 27 janvier",
-  "ABBR_QUARTER": "T1",
-  "QUARTER": "1er trimestre",
-  "YEAR": "2012",
-  "YEAR_NUM_MONTH": "01/2012",
-  "YEAR_NUM_MONTH_DAY": "27/01/2012",
-  "YEAR_NUM_MONTH_WEEKDAY_DAY": "ven. 27/01/2012",
-  "YEAR_ABBR_MONTH": "janv. 2012",
-  "YEAR_ABBR_MONTH_DAY": "27 janv. 2012",
-  "YEAR_ABBR_MONTH_WEEKDAY_DAY": "ven. 27 janv. 2012",
-  "YEAR_MONTH": "janvier 2012",
-  "YEAR_MONTH_DAY": "27 janvier 2012",
-  "YEAR_MONTH_WEEKDAY_DAY": "vendredi 27 janvier 2012",
-  "YEAR_ABBR_QUARTER": "T1 2012",
-  "YEAR_QUARTER": "1er trimestre 2012",
-  "HOUR24": "20 h",
-  "HOUR24_MINUTE": "20:58",
-  "HOUR24_MINUTE_SECOND": "20:58:59",
-  "HOUR": "20 h",
-  "HOUR_MINUTE": "20:58",
-  "HOUR_MINUTE_SECOND": "20:58:59",
-  "MINUTE": "58",
-  "MINUTE_SECOND": "58:59",
-  "SECOND": "59",
-  "LOCATION_TZ": "Heure : États-Unis (Los Angeles)",
-  "GENERIC_TZ": "heure du Pacifique",
-  "ABBR_GENERIC_TZ": "Heure : États-Unis (Los Angeles)",
-  "SPECIFIC_TZ": "heure normale du Pacifique",
-  "ABBR_SPECIFIC_TZ": "UTC-08:00",
-  "ABBR_UTC_TZ": "UTC-08:00",
-  "YEAR_MONTH_WEEKDAY_DAY + HOUR_MINUTE_SECOND":
-      "vendredi 27 janvier 2012 20:58:59",
-  "YEAR_MONTH_WEEKDAY_DAY + HOUR_MINUTE_SECOND + GENERIC_TZ":
-      "vendredi 27 janvier 2012 20:58:59 heure du Pacifique",
-  "YEAR_ABBR_MONTH_WEEKDAY_DAY + HOUR_MINUTE_SECOND + ABBR_SPECIFIC_TZ":
-      "ven. 27 janv. 2012 20:58:59 UTC-08:00",
-  "HOUR_MINUTE_SECOND + ABBR_GENERIC_TZ":
-      "20:58:59 Heure : États-Unis (Los Angeles)",
-  "HOUR_MINUTE + ABBR_SPECIFIC_TZ": "20:58 UTC-08:00"
+const french = {
+  'DAY': '27',
+  'ABBR_WEEKDAY': 'ven.',
+  'WEEKDAY': 'vendredi',
+  'ABBR_STANDALONE_MONTH': 'janv.',
+  'STANDALONE_MONTH': 'janvier',
+  'NUM_MONTH': '1',
+  'NUM_MONTH_DAY': '27/01',
+  'NUM_MONTH_WEEKDAY_DAY': 'ven. 27/01',
+  'ABBR_MONTH': 'janv.',
+  'ABBR_MONTH_DAY': '27 janv.',
+  'ABBR_MONTH_WEEKDAY_DAY': 'ven. 27 janv.',
+  'MONTH': 'janvier',
+  'MONTH_DAY': '27 janvier',
+  'MONTH_WEEKDAY_DAY': 'vendredi 27 janvier',
+  'ABBR_QUARTER': 'T1',
+  'QUARTER': '1er trimestre',
+  'YEAR': '2012',
+  'YEAR_NUM_MONTH': '01/2012',
+  'YEAR_NUM_MONTH_DAY': '27/01/2012',
+  'YEAR_NUM_MONTH_WEEKDAY_DAY': 'ven. 27/01/2012',
+  'YEAR_ABBR_MONTH': 'janv. 2012',
+  'YEAR_ABBR_MONTH_DAY': '27 janv. 2012',
+  'YEAR_ABBR_MONTH_WEEKDAY_DAY': 'ven. 27 janv. 2012',
+  'YEAR_MONTH': 'janvier 2012',
+  'YEAR_MONTH_DAY': '27 janvier 2012',
+  'YEAR_MONTH_WEEKDAY_DAY': 'vendredi 27 janvier 2012',
+  'YEAR_ABBR_QUARTER': 'T1 2012',
+  'YEAR_QUARTER': '1er trimestre 2012',
+  'HOUR24': '20 h',
+  'HOUR24_MINUTE': '20:58',
+  'HOUR24_MINUTE_SECOND': '20:58:59',
+  'HOUR': '20 h',
+  'HOUR_MINUTE': '20:58',
+  'HOUR_MINUTE_SECOND': '20:58:59',
+  'MINUTE': '58',
+  'MINUTE_SECOND': '58:59',
+  'SECOND': '59',
+  'LOCATION_TZ': 'Heure : États-Unis (Los Angeles)',
+  'GENERIC_TZ': 'heure du Pacifique',
+  'ABBR_GENERIC_TZ': 'Heure : États-Unis (Los Angeles)',
+  'SPECIFIC_TZ': 'heure normale du Pacifique',
+  'ABBR_SPECIFIC_TZ': 'UTC-08:00',
+  'ABBR_UTC_TZ': 'UTC-08:00',
+  'YEAR_MONTH_WEEKDAY_DAY + HOUR_MINUTE_SECOND':
+      'vendredi 27 janvier 2012 20:58:59',
+  'YEAR_MONTH_WEEKDAY_DAY + HOUR_MINUTE_SECOND + GENERIC_TZ':
+      'vendredi 27 janvier 2012 20:58:59 heure du Pacifique',
+  'YEAR_ABBR_MONTH_WEEKDAY_DAY + HOUR_MINUTE_SECOND + ABBR_SPECIFIC_TZ':
+      'ven. 27 janv. 2012 20:58:59 UTC-08:00',
+  'HOUR_MINUTE_SECOND + ABBR_GENERIC_TZ':
+      '20:58:59 Heure : États-Unis (Los Angeles)',
+  'HOUR_MINUTE + ABBR_SPECIFIC_TZ': '20:58 UTC-08:00'
 };
 
-var Japanese = const {
-  "DAY": "27日",
-  "ABBR_WEEKDAY": "金",
-  "WEEKDAY": "金曜日",
-  "ABBR_STANDALONE_MONTH": "1月",
-  "STANDALONE_MONTH": "1月",
-  "NUM_MONTH": "1月",
-  "NUM_MONTH_DAY": "1/27",
-  "NUM_MONTH_WEEKDAY_DAY": "1/27(金)",
-  "ABBR_MONTH": "1月",
-  "ABBR_MONTH_DAY": "1月27日",
-  "ABBR_MONTH_WEEKDAY_DAY": "1月27日(金)",
-  "MONTH": "1月",
-  "MONTH_DAY": "1月27日",
-  "MONTH_WEEKDAY_DAY": "1月27日金曜日",
-  "ABBR_QUARTER": "Q1",
-  "QUARTER": "第1四半期",
-  "YEAR": "2012年",
-  "YEAR_NUM_MONTH": "2012/1",
-  "YEAR_NUM_MONTH_DAY": "2012/1/27",
-  "YEAR_NUM_MONTH_WEEKDAY_DAY": "2012/1/27(金)",
-  "YEAR_ABBR_MONTH": "2012年1月",
-  "YEAR_ABBR_MONTH_DAY": "2012年1月27日",
-  "YEAR_ABBR_MONTH_WEEKDAY_DAY": "2012年1月27日(金)",
-  "YEAR_MONTH": "2012年1月",
-  "YEAR_MONTH_DAY": "2012年1月27日",
-  "YEAR_MONTH_WEEKDAY_DAY": "2012年1月27日金曜日",
-  "YEAR_ABBR_QUARTER": "2012/Q1",
-  "YEAR_QUARTER": "2012/第1四半期",
-  "HOUR24": "20時",
-  "HOUR24_MINUTE": "20:58",
-  "HOUR24_MINUTE_SECOND": "20:58:59",
-  "HOUR": "20時",
-  "HOUR_MINUTE": "20:58",
-  "HOUR_MINUTE_SECOND": "20:58:59",
-  "MINUTE": "58",
-  "MINUTE_SECOND": "58:59",
-  "SECOND": "59",
-  "LOCATION_TZ": "アメリカ合衆国時間（ロサンゼルス）",
-  "GENERIC_TZ": "アメリカ太平洋時間",
-  "ABBR_GENERIC_TZ": "アメリカ合衆国時間（ロサンゼルス）",
-  "SPECIFIC_TZ": "アメリカ太平洋標準時",
-  "ABBR_SPECIFIC_TZ": "GMT-08:00",
-  "ABBR_UTC_TZ": "GMT-08:00",
-  "YEAR_MONTH_WEEKDAY_DAY + HOUR_MINUTE_SECOND": "2012年1月27日(金曜日) 20:58:59",
-  "YEAR_MONTH_WEEKDAY_DAY + HOUR_MINUTE_SECOND + GENERIC_TZ":
-      "2012年1月27日(金曜日) 20時58分59秒 アメリカ太平洋時間",
-  "YEAR_ABBR_MONTH_WEEKDAY_DAY + HOUR_MINUTE_SECOND + ABBR_SPECIFIC_TZ":
-      "2012年1月27日(金) 20時58分59秒 GMT-08:00",
-  "HOUR_MINUTE_SECOND + ABBR_GENERIC_TZ": "20時58分59秒 アメリカ合衆国時間（ロサンゼルス）",
-  "HOUR_MINUTE + ABBR_SPECIFIC_TZ": "20:58 GMT-08:00"
+const japanese = {
+  'DAY': '27日',
+  'ABBR_WEEKDAY': '金',
+  'WEEKDAY': '金曜日',
+  'ABBR_STANDALONE_MONTH': '1月',
+  'STANDALONE_MONTH': '1月',
+  'NUM_MONTH': '1月',
+  'NUM_MONTH_DAY': '1/27',
+  'NUM_MONTH_WEEKDAY_DAY': '1/27(金)',
+  'ABBR_MONTH': '1月',
+  'ABBR_MONTH_DAY': '1月27日',
+  'ABBR_MONTH_WEEKDAY_DAY': '1月27日(金)',
+  'MONTH': '1月',
+  'MONTH_DAY': '1月27日',
+  'MONTH_WEEKDAY_DAY': '1月27日金曜日',
+  'ABBR_QUARTER': 'Q1',
+  'QUARTER': '第1四半期',
+  'YEAR': '2012年',
+  'YEAR_NUM_MONTH': '2012/1',
+  'YEAR_NUM_MONTH_DAY': '2012/1/27',
+  'YEAR_NUM_MONTH_WEEKDAY_DAY': '2012/1/27(金)',
+  'YEAR_ABBR_MONTH': '2012年1月',
+  'YEAR_ABBR_MONTH_DAY': '2012年1月27日',
+  'YEAR_ABBR_MONTH_WEEKDAY_DAY': '2012年1月27日(金)',
+  'YEAR_MONTH': '2012年1月',
+  'YEAR_MONTH_DAY': '2012年1月27日',
+  'YEAR_MONTH_WEEKDAY_DAY': '2012年1月27日金曜日',
+  'YEAR_ABBR_QUARTER': '2012/Q1',
+  'YEAR_QUARTER': '2012/第1四半期',
+  'HOUR24': '20時',
+  'HOUR24_MINUTE': '20:58',
+  'HOUR24_MINUTE_SECOND': '20:58:59',
+  'HOUR': '20時',
+  'HOUR_MINUTE': '20:58',
+  'HOUR_MINUTE_SECOND': '20:58:59',
+  'MINUTE': '58',
+  'MINUTE_SECOND': '58:59',
+  'SECOND': '59',
+  'LOCATION_TZ': 'アメリカ合衆国時間（ロサンゼルス）',
+  'GENERIC_TZ': 'アメリカ太平洋時間',
+  'ABBR_GENERIC_TZ': 'アメリカ合衆国時間（ロサンゼルス）',
+  'SPECIFIC_TZ': 'アメリカ太平洋標準時',
+  'ABBR_SPECIFIC_TZ': 'GMT-08:00',
+  'ABBR_UTC_TZ': 'GMT-08:00',
+  'YEAR_MONTH_WEEKDAY_DAY + HOUR_MINUTE_SECOND': '2012年1月27日(金曜日) 20:58:59',
+  'YEAR_MONTH_WEEKDAY_DAY + HOUR_MINUTE_SECOND + GENERIC_TZ':
+      '2012年1月27日(金曜日) 20時58分59秒 アメリカ太平洋時間',
+  'YEAR_ABBR_MONTH_WEEKDAY_DAY + HOUR_MINUTE_SECOND + ABBR_SPECIFIC_TZ':
+      '2012年1月27日(金) 20時58分59秒 GMT-08:00',
+  'HOUR_MINUTE_SECOND + ABBR_GENERIC_TZ': '20時58分59秒 アメリカ合衆国時間（ロサンゼルス）',
+  'HOUR_MINUTE + ABBR_SPECIFIC_TZ': '20:58 GMT-08:00'
 };
 
-var Greek = const {
-  "DAY": "27",
-  "ABBR_WEEKDAY": "Παρ",
-  "WEEKDAY": "Παρασκευή",
-  "ABBR_STANDALONE_MONTH": "Ιαν",
-  "STANDALONE_MONTH": "Ιανουαρίου",
-  "NUM_MONTH": "1",
-  "NUM_MONTH_DAY": "27/1",
-  "NUM_MONTH_WEEKDAY_DAY": "Παρ, 27/1",
-  "ABBR_MONTH": "Ιαν",
-  "ABBR_MONTH_DAY": "27 Ιαν",
-  "ABBR_MONTH_WEEKDAY_DAY": "Παρ, 27 Ιαν",
-  "MONTH": "Ιανουαρίου",
-  "MONTH_DAY": "27 Ιανουαρίου",
-  "MONTH_WEEKDAY_DAY": "Παρασκευή, 27 Ιανουαρίου",
-  "ABBR_QUARTER": "Τ1",
-  "QUARTER": "1ο τρίμηνο",
-  "YEAR": "2012",
-  "YEAR_NUM_MONTH": "1/2012",
-  "YEAR_NUM_MONTH_DAY": "27/1/2012",
-  "YEAR_NUM_MONTH_WEEKDAY_DAY": "Παρ, 27/1/2012",
-  "YEAR_ABBR_MONTH": "Ιαν 2012",
-  "YEAR_ABBR_MONTH_DAY": "27 Ιαν 2012",
-  "YEAR_ABBR_MONTH_WEEKDAY_DAY": "Παρ, 27 Ιαν 2012",
-  "YEAR_MONTH": "Ιανουάριος 2012",
-  "YEAR_MONTH_DAY": "27 Ιανουαρίου 2012",
-  "YEAR_MONTH_WEEKDAY_DAY": "Παρασκευή, 27 Ιανουαρίου 2012",
-  "YEAR_ABBR_QUARTER": "2012 Τ1",
-  "YEAR_QUARTER": "2012 1ο τρίμηνο",
-  "HOUR24": "20",
-  "HOUR24_MINUTE": "20:58",
-  "HOUR24_MINUTE_SECOND": "20:58:59",
-  "HOUR": "8 μ.μ.",
-  "HOUR_MINUTE": "8:58 μ.μ.",
-  "HOUR_MINUTE_SECOND": "8:58:59 μ.μ.",
-  "MINUTE": "58",
-  "MINUTE_SECOND": "58:59",
-  "SECOND": "59",
-  "LOCATION_TZ": "Ηνωμένες Πολιτείες της Αμερικής (Λος Άντζελες)",
-  "GENERIC_TZ": "Ώρα Ειρηνικού",
-  "ABBR_GENERIC_TZ": "Ηνωμένες Πολιτείες της Αμερικής (Λος Άντζελες)",
-  "SPECIFIC_TZ": "Χειμερινή ώρα Ειρηνικού",
-  "ABBR_SPECIFIC_TZ": "GMT-08:00",
-  "ABBR_UTC_TZ": "GMT-08:00",
-  "YEAR_MONTH_WEEKDAY_DAY + HOUR_MINUTE_SECOND":
-      "Παρασκευή, 27 Ιανουαρίου 2012 8:58:59 μ.μ.",
-  "YEAR_MONTH_WEEKDAY_DAY + HOUR_MINUTE_SECOND + GENERIC_TZ":
-      "Παρασκευή, 27 Ιανουαρίου 2012 8:58:59 μ.μ. Ώρα Ειρηνικού",
-  "YEAR_ABBR_MONTH_WEEKDAY_DAY + HOUR_MINUTE_SECOND + ABBR_SPECIFIC_TZ":
-      "Παρ, 27 Ιαν 2012 8:58:59 μ.μ. GMT-08:00",
-  "HOUR_MINUTE_SECOND + ABBR_GENERIC_TZ":
-      "8:58:59 μ.μ. Ηνωμένες Πολιτείες της Αμερικής (Λος Άντζελες)",
-  "HOUR_MINUTE + ABBR_SPECIFIC_TZ": "8:58 μ.μ. GMT-08:00"
+const greek = {
+  'DAY': '27',
+  'ABBR_WEEKDAY': 'Παρ',
+  'WEEKDAY': 'Παρασκευή',
+  'ABBR_STANDALONE_MONTH': 'Ιαν',
+  'STANDALONE_MONTH': 'Ιανουαρίου',
+  'NUM_MONTH': '1',
+  'NUM_MONTH_DAY': '27/1',
+  'NUM_MONTH_WEEKDAY_DAY': 'Παρ, 27/1',
+  'ABBR_MONTH': 'Ιαν',
+  'ABBR_MONTH_DAY': '27 Ιαν',
+  'ABBR_MONTH_WEEKDAY_DAY': 'Παρ, 27 Ιαν',
+  'MONTH': 'Ιανουαρίου',
+  'MONTH_DAY': '27 Ιανουαρίου',
+  'MONTH_WEEKDAY_DAY': 'Παρασκευή, 27 Ιανουαρίου',
+  'ABBR_QUARTER': 'Τ1',
+  'QUARTER': '1ο τρίμηνο',
+  'YEAR': '2012',
+  'YEAR_NUM_MONTH': '1/2012',
+  'YEAR_NUM_MONTH_DAY': '27/1/2012',
+  'YEAR_NUM_MONTH_WEEKDAY_DAY': 'Παρ, 27/1/2012',
+  'YEAR_ABBR_MONTH': 'Ιαν 2012',
+  'YEAR_ABBR_MONTH_DAY': '27 Ιαν 2012',
+  'YEAR_ABBR_MONTH_WEEKDAY_DAY': 'Παρ, 27 Ιαν 2012',
+  'YEAR_MONTH': 'Ιανουάριος 2012',
+  'YEAR_MONTH_DAY': '27 Ιανουαρίου 2012',
+  'YEAR_MONTH_WEEKDAY_DAY': 'Παρασκευή, 27 Ιανουαρίου 2012',
+  'YEAR_ABBR_QUARTER': '2012 Τ1',
+  'YEAR_QUARTER': '2012 1ο τρίμηνο',
+  'HOUR24': '20',
+  'HOUR24_MINUTE': '20:58',
+  'HOUR24_MINUTE_SECOND': '20:58:59',
+  'HOUR': '8 μ.μ.',
+  'HOUR_MINUTE': '8:58 μ.μ.',
+  'HOUR_MINUTE_SECOND': '8:58:59 μ.μ.',
+  'MINUTE': '58',
+  'MINUTE_SECOND': '58:59',
+  'SECOND': '59',
+  'LOCATION_TZ': 'Ηνωμένες Πολιτείες της Αμερικής (Λος Άντζελες)',
+  'GENERIC_TZ': 'Ώρα Ειρηνικού',
+  'ABBR_GENERIC_TZ': 'Ηνωμένες Πολιτείες της Αμερικής (Λος Άντζελες)',
+  'SPECIFIC_TZ': 'Χειμερινή ώρα Ειρηνικού',
+  'ABBR_SPECIFIC_TZ': 'GMT-08:00',
+  'ABBR_UTC_TZ': 'GMT-08:00',
+  'YEAR_MONTH_WEEKDAY_DAY + HOUR_MINUTE_SECOND':
+      'Παρασκευή, 27 Ιανουαρίου 2012 8:58:59 μ.μ.',
+  'YEAR_MONTH_WEEKDAY_DAY + HOUR_MINUTE_SECOND + GENERIC_TZ':
+      'Παρασκευή, 27 Ιανουαρίου 2012 8:58:59 μ.μ. Ώρα Ειρηνικού',
+  'YEAR_ABBR_MONTH_WEEKDAY_DAY + HOUR_MINUTE_SECOND + ABBR_SPECIFIC_TZ':
+      'Παρ, 27 Ιαν 2012 8:58:59 μ.μ. GMT-08:00',
+  'HOUR_MINUTE_SECOND + ABBR_GENERIC_TZ':
+      '8:58:59 μ.μ. Ηνωμένες Πολιτείες της Αμερικής (Λος Άντζελες)',
+  'HOUR_MINUTE + ABBR_SPECIFIC_TZ': '8:58 μ.μ. GMT-08:00'
 };
diff --git a/test/date_time_format_test_stub.dart b/test/date_time_format_test_stub.dart
index b6c3f9d..c8344ac 100644
--- a/test/date_time_format_test_stub.dart
+++ b/test/date_time_format_test_stub.dart
@@ -12,14 +12,15 @@
 import 'package:intl/intl.dart';
 import 'date_time_format_test_core.dart';
 
-typedef List<String> TestListFunc();
+typedef TestListFunc = List<String> Function();
 
-typedef Future InitializeDateFormattingFunc(String locale, String filePath);
+typedef InitializeDateFormattingFunc = Future<void> Function(
+    String locale, String filePath);
 
 /// Return only the odd-numbered locales. A simple way to divide the list into
 /// two roughly equal parts.
 List<String> oddLocales() {
-  int i = 1;
+  var i = 1;
   return allLocales().where((x) => (i++).isOdd).toList();
 }
 
@@ -31,8 +32,8 @@
 /// Return only the even-numbered locales. A simple way to divide the list into
 /// two roughly equal parts.
 List<String> evenLocales() {
-  int i = 1;
-  return allLocales().where((x) => !((i++).isOdd)).toList();
+  var i = 1;
+  return allLocales().where((x) => !(i++).isOdd).toList();
 }
 
 void runWith(TestListFunc getSubset, String dir,
@@ -41,13 +42,13 @@
   // Also, note that we take the list of locales as a function so that we don't
   // evaluate it until after we know that all the locales are available.
 
-  bool initialized = false;
+  var initialized = false;
 
   setUp(() {
     if (initialized) {
       return null;
     }
-    return initFunction("en_US", dir).then((_) {
+    return initFunction('en_US', dir).then((_) {
       return Future.forEach(DateFormat.allLocalesWithSymbols(), (locale) {
         return initFunction(locale, dir);
       });
diff --git a/test/date_time_format_uninitialized_test.dart b/test/date_time_format_uninitialized_test.dart
index 49c081b..79b09f9 100644
--- a/test/date_time_format_uninitialized_test.dart
+++ b/test/date_time_format_uninitialized_test.dart
@@ -8,6 +8,6 @@
 
 import 'date_time_format_test_core.dart';
 
-main() {
+void main() {
   runDateTests(() => ['en_US']);
 }
diff --git a/test/date_time_loose_parsing_test.dart b/test/date_time_loose_parsing_test.dart
index aa4fdf7..b0e000a 100644
--- a/test/date_time_loose_parsing_test.dart
+++ b/test/date_time_loose_parsing_test.dart
@@ -13,92 +13,92 @@
 import 'package:intl/intl.dart';
 import 'package:test/test.dart';
 
-main() {
-  var format;
+void main() {
+  DateFormat format;
 
-  var date = new DateTime(2014, 9, 3);
+  var date = DateTime(2014, 9, 3);
 
-  check(String s) {
+  void check(String s) {
     expect(() => format.parse(s), throwsFormatException);
     expect(format.parseLoose(s), date);
   }
 
-  test("Loose parsing yMMMd", () {
+  test('Loose parsing yMMMd', () {
     // Note: We can't handle e.g. Sept, we don't have those abbreviations
     // in our data.
-    // Also doesn't handle "sep3,2014", or "sep 3.2014"
-    format = new DateFormat.yMMMd("en_US");
-    check("Sep 3 2014");
-    check("sep 3 2014");
-    check("sep 3  2014");
-    check("sep  3 2014");
-    check("sep  3       2014");
-    check("sep3 2014");
-    check("september 3, 2014");
-    check("sEPTembER 3, 2014");
-    check("seP 3, 2014");
-    check("Sep 3,2014");
+    // Also doesn't handle 'sep3,2014', or 'sep 3.2014'
+    format = DateFormat.yMMMd('en_US');
+    check('Sep 3 2014');
+    check('sep 3 2014');
+    check('sep 3  2014');
+    check('sep  3 2014');
+    check('sep  3       2014');
+    check('sep3 2014');
+    check('september 3, 2014');
+    check('sEPTembER 3, 2014');
+    check('seP 3, 2014');
+    check('Sep 3,2014');
   });
 
-  test("Loose parsing yMMMd that parses strict", () {
-    expect(format.parseLoose("Sep 3, 2014"), date);
+  test('Loose parsing yMMMd that parses strict', () {
+    expect(format.parseLoose('Sep 3, 2014'), date);
   });
 
-  test("Loose parsing yMd", () {
-    format = new DateFormat.yMd("en_US");
-    check("09 3 2014");
-    check("09 00003    2014");
-    check("09/    03/2014");
-    check("09 / 03 / 2014");
+  test('Loose parsing yMd', () {
+    format = DateFormat.yMd('en_US');
+    check('09 3 2014');
+    check('09 00003    2014');
+    check('09/    03/2014');
+    check('09 / 03 / 2014');
   });
 
-  test("Loose parsing yMd that parses strict", () {
-    expect(format.parseLoose("09/03/2014"), date);
-    expect(format.parseLoose("09/3/2014"), date);
+  test('Loose parsing yMd that parses strict', () {
+    expect(format.parseLoose('09/03/2014'), date);
+    expect(format.parseLoose('09/3/2014'), date);
   });
 
-  test("Loose parsing should handle standalone month format", () {
+  test('Loose parsing should handle standalone month format', () {
     // This checks that LL actually sets the month.
     // The appended whitespace and extra d pattern are present to trigger the
     // loose parsing code path.
-    expect(new DateFormat('LL/d', 'en_US').parseLoose("05/ 2").month, 5);
+    expect(DateFormat('LL/d', 'en_US').parseLoose('05/ 2').month, 5);
   });
 
-  group("Loose parsing with year formats", () {
-    test("should fail when year is omitted (en_US)", () {
-      expect(() => new DateFormat('yyyy-MM-dd').parseLoose("1/11"),
+  group('Loose parsing with year formats', () {
+    test('should fail when year is omitted (en_US)', () {
+      expect(() => DateFormat('yyyy-MM-dd').parseLoose('1/11'),
           throwsFormatException);
     });
 
-    test("should fail when year is omitted (ja)", () {
+    test('should fail when year is omitted (ja)', () {
       initializeDateFormatting('ja', null);
-      expect(() => new DateFormat.yMMMd("ja").parseLoose('12月12日'),
+      expect(() => DateFormat.yMMMd('ja').parseLoose('12月12日'),
           throwsFormatException);
-      expect(() => new DateFormat.yMd("ja").parseLoose('12月12日'),
+      expect(() => DateFormat.yMd('ja').parseLoose('12月12日'),
           throwsFormatException);
-      expect(() => new DateFormat.yMEd("ja").parseLoose('12月12日'),
+      expect(() => DateFormat.yMEd('ja').parseLoose('12月12日'),
           throwsFormatException);
-      expect(() => new DateFormat.yMMMEd("ja").parseLoose('12月12日'),
+      expect(() => DateFormat.yMMMEd('ja').parseLoose('12月12日'),
           throwsFormatException);
-      expect(() => new DateFormat.yMMMMd("ja").parseLoose('12月12日'),
+      expect(() => DateFormat.yMMMMd('ja').parseLoose('12月12日'),
           throwsFormatException);
-      expect(() => new DateFormat.yMMMMEEEEd("ja").parseLoose('12月12日'),
+      expect(() => DateFormat.yMMMMEEEEd('ja').parseLoose('12月12日'),
           throwsFormatException);
     });
 
-    test("should fail when year is omitted (hu)", () {
+    test('should fail when year is omitted (hu)', () {
       initializeDateFormatting('hu', null);
-      expect(() => new DateFormat.yMMMd("hu").parseLoose('3. 17.'),
+      expect(() => DateFormat.yMMMd('hu').parseLoose('3. 17.'),
           throwsFormatException);
-      expect(() => new DateFormat.yMd("hu").parseLoose('3. 17.'),
+      expect(() => DateFormat.yMd('hu').parseLoose('3. 17.'),
           throwsFormatException);
-      expect(() => new DateFormat.yMEd("hu").parseLoose('3. 17.'),
+      expect(() => DateFormat.yMEd('hu').parseLoose('3. 17.'),
           throwsFormatException);
-      expect(() => new DateFormat.yMMMEd("hu").parseLoose('3. 17.'),
+      expect(() => DateFormat.yMMMEd('hu').parseLoose('3. 17.'),
           throwsFormatException);
-      expect(() => new DateFormat.yMMMMd("hu").parseLoose('3. 17.'),
+      expect(() => DateFormat.yMMMMd('hu').parseLoose('3. 17.'),
           throwsFormatException);
-      expect(() => new DateFormat.yMMMMEEEEd("hu").parseLoose('3. 17.'),
+      expect(() => DateFormat.yMMMMEEEEd('hu').parseLoose('3. 17.'),
           throwsFormatException);
     });
   });
diff --git a/test/date_time_strict_test.dart b/test/date_time_strict_test.dart
index cc5f597..e345d27 100644
--- a/test/date_time_strict_test.dart
+++ b/test/date_time_strict_test.dart
@@ -10,70 +10,69 @@
 import 'package:intl/intl.dart';
 import 'package:test/test.dart';
 
-main() {
-  test("All input consumed", () {
-    var format = new DateFormat.yMMMd();
-    var date = new DateTime(2014, 9, 3);
+void main() {
+  test('All input consumed', () {
+    var format = DateFormat.yMMMd();
+    var date = DateTime(2014, 9, 3);
     var formatted = 'Sep 3, 2014';
     expect(format.format(date), formatted);
     var parsed = format.parseStrict(formatted);
     expect(parsed, date);
 
-    check(String s) {
+    void check(String s) {
       expect(() => format.parseStrict(s), throwsFormatException);
       expect(format.parse(s), date);
     }
 
-    check(formatted + ",");
-    check(formatted + "abc");
-    check(formatted + "   ");
+    check('$formatted,');
+    check('${formatted}abc');
+    check('$formatted   ');
   });
 
-  test("Invalid dates", () {
-    var format = new DateFormat.yMd();
-    check(s) => expect(() => format.parseStrict(s), throwsFormatException);
-    check("0/3/2014");
-    check("13/3/2014");
-    check("9/0/2014");
-    check("9/31/2014");
-    check("09/31/2014");
-    check("10/32/2014");
-    check("2/29/2014");
-    expect(format.parseStrict("2/29/2016"), new DateTime(2016, 2, 29));
+  test('Invalid dates', () {
+    var format = DateFormat.yMd();
+    void check(s) => expect(() => format.parseStrict(s), throwsFormatException);
+    check('0/3/2014');
+    check('13/3/2014');
+    check('9/0/2014');
+    check('9/31/2014');
+    check('09/31/2014');
+    check('10/32/2014');
+    check('2/29/2014');
+    expect(format.parseStrict('2/29/2016'), DateTime(2016, 2, 29));
   });
 
-  test("Invalid times am/pm", () {
-    var format = new DateFormat.jms();
-    check(s) => expect(() => format.parseStrict(s), throwsFormatException);
-    check("-1:15:00 AM");
-    expect(format.parseStrict("0:15:00 AM"), new DateTime(1970, 1, 1, 0, 15));
-    check("24:00:00 PM");
-    check("24:00:00 AM");
-    check("25:00:00 PM");
-    check("0:-1:00 AM");
-    check("0:60:00 AM");
-    expect(format.parseStrict("0:59:00 AM"), new DateTime(1970, 1, 1, 0, 59));
-    check("0:0:-1 AM");
-    check("0:0:60 AM");
-    check("2:0:60 PM");
-    expect(
-        format.parseStrict("2:0:59 PM"), new DateTime(1970, 1, 1, 14, 0, 59));
+  test('Invalid times am/pm', () {
+    var format = DateFormat.jms();
+    void check(s) => expect(() => format.parseStrict(s), throwsFormatException);
+    check('-1:15:00 AM');
+    expect(format.parseStrict('0:15:00 AM'), DateTime(1970, 1, 1, 0, 15));
+    check('24:00:00 PM');
+    check('24:00:00 AM');
+    check('25:00:00 PM');
+    check('0:-1:00 AM');
+    check('0:60:00 AM');
+    expect(format.parseStrict('0:59:00 AM'), DateTime(1970, 1, 1, 0, 59));
+    check('0:0:-1 AM');
+    check('0:0:60 AM');
+    check('2:0:60 PM');
+    expect(format.parseStrict('2:0:59 PM'), DateTime(1970, 1, 1, 14, 0, 59));
   });
 
-  test("Invalid times 24 hour", () {
-    var format = new DateFormat.Hms();
+  test('Invalid times 24 hour', () {
+    var format = DateFormat.Hms();
     check(s) => expect(() => format.parseStrict(s), throwsFormatException);
-    check("-1:15:00");
-    expect(format.parseStrict("0:15:00"), new DateTime(1970, 1, 1, 0, 15));
-    check("24:00:00");
-    check("24:00:00");
-    check("25:00:00");
-    check("0:-1:00");
-    check("0:60:00");
-    expect(format.parseStrict("0:59:00"), new DateTime(1970, 1, 1, 0, 59));
-    check("0:0:-1");
-    check("0:0:60");
-    check("14:0:60");
-    expect(format.parseStrict("14:0:59"), new DateTime(1970, 1, 1, 14, 0, 59));
+    check('-1:15:00');
+    expect(format.parseStrict('0:15:00'), DateTime(1970, 1, 1, 0, 15));
+    check('24:00:00');
+    check('24:00:00');
+    check('25:00:00');
+    check('0:-1:00');
+    check('0:60:00');
+    expect(format.parseStrict('0:59:00'), DateTime(1970, 1, 1, 0, 59));
+    check('0:0:-1');
+    check('0:0:60');
+    check('14:0:60');
+    expect(format.parseStrict('14:0:59'), DateTime(1970, 1, 1, 14, 0, 59));
   });
 }
diff --git a/test/england_timezone_test.dart b/test/england_timezone_test.dart
index 8977deb..33e8901 100644
--- a/test/england_timezone_test.dart
+++ b/test/england_timezone_test.dart
@@ -17,6 +17,6 @@
 import 'package:test/test.dart';
 import 'timezone_test_core.dart';
 
-main() {
+void main() {
   testTimezone('Europe/London', expectedUtcOffset: 0);
 }
diff --git a/test/find_default_locale_browser_test.dart b/test/find_default_locale_browser_test.dart
index 818194e..cfc19f5 100644
--- a/test/find_default_locale_browser_test.dart
+++ b/test/find_default_locale_browser_test.dart
@@ -2,32 +2,30 @@
 // 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.
 
-@TestOn("browser")
+@TestOn('browser')
 library find_default_locale_browser_test;
 
 import 'package:intl/intl.dart';
 import 'package:intl/intl_browser.dart';
 import 'package:test/test.dart';
 
-main() {
-  test("Find system locale in browser", () {
+void main() {
+  test('Find system locale in browser', () {
     // TODO (alanknight): This only verifies that we found some locale. We
     // should find a way to force the system locale before the test is run
     // and then verify that it's actually the correct value.
     Intl.systemLocale = 'xx_YY';
-    ThenArgument callback = expectAsync1(verifyLocale);
+    var callback = expectAsync1(verifyLocale);
     findSystemLocale().then(callback);
   });
 }
 
-typedef ThenArgument(String _);
-
-verifyLocale(_) {
-  expect(Intl.systemLocale, isNot(equals("xx_YY")));
+void verifyLocale(_) {
+  expect(Intl.systemLocale, isNot(equals('xx_YY')));
   // Allow either en_US or just en type locales. Windows in particular may
   // give us just ru for ru_RU
-  var pattern = new RegExp(r"\w\w_[A-Z0-9]+");
-  var shortPattern = new RegExp(r"\w\w");
+  var pattern = RegExp(r'\w\w_[A-Z0-9]+');
+  var shortPattern = RegExp(r'\w\w');
   var match = pattern.hasMatch(Intl.systemLocale);
   var shortMatch = shortPattern.hasMatch(Intl.systemLocale);
   expect(match || shortMatch, isTrue);
diff --git a/test/find_default_locale_standalone_test.dart b/test/find_default_locale_standalone_test.dart
index 21bf17b..e212848 100644
--- a/test/find_default_locale_standalone_test.dart
+++ b/test/find_default_locale_standalone_test.dart
@@ -2,28 +2,27 @@
 // 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.
 
-@TestOn("vm")
+@TestOn('vm')
 import 'package:intl/intl.dart';
 import 'package:intl/intl_standalone.dart';
 import 'package:test/test.dart';
 
-main() {
-  test("Find system locale standalone", () {
+void main() {
+  test('Find system locale standalone', () {
     // TODO (alanknight): This only verifies that we found some locale. We
     // should find a way to force the system locale before the test is run
     // and then verify that it's actually the correct value.
     // We have no way of getting this reliably for Windows, so it will fail.
-    Intl.systemLocale = "xx_YY";
+    Intl.systemLocale = 'xx_YY';
     var callback = expectAsync1(verifyLocale);
     findSystemLocale().then(callback);
   });
 }
 
-typedef ThenArgument(String _);
-verifyLocale(_) {
-  expect(Intl.systemLocale, isNot(equals("xx_YY")));
-  var pattern = new RegExp(r"\w\w_[A-Z0-9]+");
-  var shortPattern = new RegExp(r"\w\w");
+void verifyLocale(_) {
+  expect(Intl.systemLocale, isNot(equals('xx_YY')));
+  var pattern = RegExp(r'\w\w_[A-Z0-9]+');
+  var shortPattern = RegExp(r'\w\w');
   var match = pattern.hasMatch(Intl.systemLocale);
   var shortMatch = shortPattern.hasMatch(Intl.systemLocale);
   expect(match || shortMatch, isTrue);
diff --git a/test/fixnum_test.dart b/test/fixnum_test.dart
index 17f5cc2..8f9f874 100644
--- a/test/fixnum_test.dart
+++ b/test/fixnum_test.dart
@@ -9,71 +9,71 @@
 import 'package:fixnum/fixnum.dart';
 
 var int64Values = {
-  new Int64(12345): ["USD12,345.00", "1,234,500%"],
-  new Int64(-12345): ["-USD12,345.00", "-1,234,500%"],
-  new Int64(0x7FFFFFFFFFFFF): [
-    "USD2,251,799,813,685,247.00",
-    "225,179,981,368,524,700%"
+  Int64(12345): ['USD12,345.00', '1,234,500%'],
+  Int64(-12345): ['-USD12,345.00', '-1,234,500%'],
+  Int64(0x7FFFFFFFFFFFF): [
+    'USD2,251,799,813,685,247.00',
+    '225,179,981,368,524,700%'
   ],
   Int64.parseHex('7FFFFFFFFFFFFFF'): [
-    "USD576,460,752,303,423,487.00",
-    "57,646,075,230,342,348,700%"
+    'USD576,460,752,303,423,487.00',
+    '57,646,075,230,342,348,700%'
   ],
   Int64.parseHex('8000000000000000'): [
-    "-USD9,223,372,036,854,775,808.00",
-    "-922,337,203,685,477,580,800%"
+    '-USD9,223,372,036,854,775,808.00',
+    '-922,337,203,685,477,580,800%'
   ]
 };
 
 var int32Values = {
-  new Int32(12345): ["USD12,345.00", "1,234,500%"],
-  new Int32(0x7FFFF): ["USD524,287.00", "52,428,700%"],
-  Int32.parseHex('7FFFFFF'): ["USD134,217,727.00", "13,421,772,700%"],
-  Int32.parseHex('7FFFFFFF'): ["USD2,147,483,647.00", "214,748,364,700%"],
-  Int32.parseHex('80000000'): ["-USD2,147,483,648.00", "-214,748,364,800%"]
+  Int32(12345): ['USD12,345.00', '1,234,500%'],
+  Int32(0x7FFFF): ['USD524,287.00', '52,428,700%'],
+  Int32.parseHex('7FFFFFF'): ['USD134,217,727.00', '13,421,772,700%'],
+  Int32.parseHex('7FFFFFFF'): ['USD2,147,483,647.00', '214,748,364,700%'],
+  Int32.parseHex('80000000'): ['-USD2,147,483,648.00', '-214,748,364,800%']
 };
 
 var microMoneyValues = {
-  new MicroMoney(new Int64(12345670000)): ["USD12,345.67", "1,234,567%"],
-  new MicroMoney(new Int64(12345671000)): ["USD12,345.67", "1,234,567%"],
-  new MicroMoney(new Int64(12345678000)): ["USD12,345.68", "1,234,568%"],
-  new MicroMoney(new Int64(-12345670000)): ["-USD12,345.67", "-1,234,567%"],
-  new MicroMoney(new Int64(-12345671000)): ["-USD12,345.67", "-1,234,567%"],
-  new MicroMoney(new Int64(-12345678000)): ["-USD12,345.68", "-1,234,568%"],
-  new MicroMoney(new Int64(12340000000)): ["USD12,340.00", "1,234,000%"],
-  new MicroMoney(new Int64(0x7FFFFFFFFFFFF)): [
-    "USD2,251,799,813.69",
-    "225,179,981,369%"
+  MicroMoney(Int64(12345670000)): ['USD12,345.67', '1,234,567%'],
+  MicroMoney(Int64(12345671000)): ['USD12,345.67', '1,234,567%'],
+  MicroMoney(Int64(12345678000)): ['USD12,345.68', '1,234,568%'],
+  MicroMoney(Int64(-12345670000)): ['-USD12,345.67', '-1,234,567%'],
+  MicroMoney(Int64(-12345671000)): ['-USD12,345.67', '-1,234,567%'],
+  MicroMoney(Int64(-12345678000)): ['-USD12,345.68', '-1,234,568%'],
+  MicroMoney(Int64(12340000000)): ['USD12,340.00', '1,234,000%'],
+  MicroMoney(Int64(0x7FFFFFFFFFFFF)): [
+    'USD2,251,799,813.69',
+    '225,179,981,369%'
   ],
-  new MicroMoney(Int64.parseHex('7FFFFFFFFFFFFFF')): [
-    "USD576,460,752,303.42",
-    "57,646,075,230,342%"
+  MicroMoney(Int64.parseHex('7FFFFFFFFFFFFFF')): [
+    'USD576,460,752,303.42',
+    '57,646,075,230,342%'
   ],
-  new MicroMoney(Int64.parseHex('7FFFFFFFFFFFFFFF')): [
-    "USD9,223,372,036,854.78",
-    "922,337,203,685,478%"
+  MicroMoney(Int64.parseHex('7FFFFFFFFFFFFFFF')): [
+    'USD9,223,372,036,854.78',
+    '922,337,203,685,478%'
   ],
-  new MicroMoney(Int64.parseHex('8000000000000000')): [
-    "-USD9,223,372,036,854.78",
-    "-922,337,203,685,478%"
+  MicroMoney(Int64.parseHex('8000000000000000')): [
+    '-USD9,223,372,036,854.78',
+    '-922,337,203,685,478%'
   ]
 };
 
-main() {
+void main() {
   test('int64', () {
     int64Values.forEach((number, expected) {
-      var currency = new NumberFormat.currency().format(number);
+      var currency = NumberFormat.currency().format(number);
       expect(currency, expected.first);
-      var percent = new NumberFormat.percentPattern().format(number);
+      var percent = NumberFormat.percentPattern().format(number);
       expect(percent, expected[1]);
     });
   });
 
   test('int32', () {
     int32Values.forEach((number, expected) {
-      var currency = new NumberFormat.currency().format(number);
+      var currency = NumberFormat.currency().format(number);
       expect(currency, expected.first);
-      var percent = new NumberFormat.percentPattern().format(number);
+      var percent = NumberFormat.percentPattern().format(number);
       expect(percent, expected[1]);
     });
   });
@@ -81,9 +81,9 @@
   test('micro money', () {
     microMoneyValues.forEach((number, expected) {
       // ignore: deprecated_member_use_from_same_package
-      var currency = new NumberFormat.currencyPattern().format(number);
+      var currency = NumberFormat.currencyPattern().format(number);
       expect(currency, expected.first);
-      var percent = new NumberFormat.percentPattern().format(number);
+      var percent = NumberFormat.percentPattern().format(number);
       expect(percent, expected[1]);
     });
   });
diff --git a/test/gmt_timezone_test.dart b/test/gmt_timezone_test.dart
index 338c41e..f8374ce 100644
--- a/test/gmt_timezone_test.dart
+++ b/test/gmt_timezone_test.dart
@@ -16,6 +16,6 @@
 import 'package:test/test.dart';
 import 'timezone_test_core.dart';
 
-main() {
+void main() {
   testTimezone('GMT', expectedUtcOffset: 0);
 }
diff --git a/test/intl_test.dart b/test/intl_test.dart
index e19ed5a..77f10c5 100644
--- a/test/intl_test.dart
+++ b/test/intl_test.dart
@@ -8,9 +8,9 @@
 import 'package:test/test.dart';
 import 'package:intl/date_symbol_data_local.dart';
 
-main() {
+void main() {
   test("Locale setting doesn't verify the core locale", () {
-    var de = new Intl('de_DE');
+    var de = Intl('de_DE');
     expect(de.locale, equals('de_DE'));
   });
 
@@ -20,13 +20,13 @@
     // locales covered for messages may be different from that for date
     // formatting.
     initializeDateFormatting('de_DE', null).then((_) {
-      var de = new Intl('de_DE');
+      var de = Intl('de_DE');
       var format = de.date().add_d();
       expect(format.locale, equals('de'));
     });
   });
 
-  test("Canonicalizing locales", () {
+  test('Canonicalizing locales', () {
     expect(Intl.canonicalizedLocale('en-us'), 'en_US');
     expect(Intl.canonicalizedLocale('en_us'), 'en_US');
     expect(Intl.canonicalizedLocale('en_US'), 'en_US');
@@ -35,7 +35,7 @@
     expect(Intl.canonicalizedLocale('C'), 'en_ISO');
   });
 
-  test("Verifying locale fallback for numbers", () {
+  test('Verifying locale fallback for numbers', () {
     expect(Intl.verifiedLocale('en-us', NumberFormat.localeExists), 'en_US');
     expect(Intl.verifiedLocale('en_us', NumberFormat.localeExists), 'en_US');
     expect(Intl.verifiedLocale('es-419', NumberFormat.localeExists), 'es_419');
@@ -45,7 +45,7 @@
     void checkAsNumberDefault(String locale, String expected) {
       var oldDefault = Intl.defaultLocale;
       Intl.defaultLocale = locale;
-      var format = new NumberFormat();
+      var format = NumberFormat();
       expect(format.locale, expected);
       Intl.defaultLocale = oldDefault;
     }
@@ -57,7 +57,7 @@
     checkAsNumberDefault('es-999', 'es');
   });
 
-  test("Verifying locale fallback for dates", () {
+  test('Verifying locale fallback for dates', () {
     expect(Intl.verifiedLocale('en-us', DateFormat.localeExists), 'en_US');
     expect(Intl.verifiedLocale('en_us', DateFormat.localeExists), 'en_US');
     expect(Intl.verifiedLocale('es-419', DateFormat.localeExists), 'es_419');
@@ -67,7 +67,7 @@
     void checkAsDateDefault(String locale, String expected) {
       var oldDefault = Intl.defaultLocale;
       Intl.defaultLocale = locale;
-      var format = new DateFormat();
+      var format = DateFormat();
       expect(format.locale, expected);
       Intl.defaultLocale = oldDefault;
     }
@@ -79,16 +79,16 @@
     checkAsDateDefault('es-999', 'es');
   });
 
-  test("toBeginningOfSentenceCase", () {
+  test('toBeginningOfSentenceCase', () {
     expect(toBeginningOfSentenceCase(null), null);
-    expect(toBeginningOfSentenceCase(""), "");
-    expect(toBeginningOfSentenceCase("A"), "A");
-    expect(toBeginningOfSentenceCase("a"), "A");
-    expect(toBeginningOfSentenceCase("abc"), "Abc");
-    expect(toBeginningOfSentenceCase("[a]"), "[a]");
-    expect(toBeginningOfSentenceCase("ABc"), "ABc");
-    expect(toBeginningOfSentenceCase("ı"), "I");
-    expect(toBeginningOfSentenceCase("i"), "I");
-    expect(toBeginningOfSentenceCase("i", "tr"), "\u0130");
+    expect(toBeginningOfSentenceCase(''), '');
+    expect(toBeginningOfSentenceCase('A'), 'A');
+    expect(toBeginningOfSentenceCase('a'), 'A');
+    expect(toBeginningOfSentenceCase('abc'), 'Abc');
+    expect(toBeginningOfSentenceCase('[a]'), '[a]');
+    expect(toBeginningOfSentenceCase('ABc'), 'ABc');
+    expect(toBeginningOfSentenceCase('ı'), 'I');
+    expect(toBeginningOfSentenceCase('i'), 'I');
+    expect(toBeginningOfSentenceCase('i', 'tr'), '\u0130');
   });
 }
diff --git a/test/locale_test.dart b/test/locale_test.dart
index 774fa5a..9b37792 100644
--- a/test/locale_test.dart
+++ b/test/locale_test.dart
@@ -38,7 +38,8 @@
   });
 
   group('Locale.fromSubtags() FormatExceptions:', () {
-    testExceptionForSubtags(String language, String script, String region) {
+    void testExceptionForSubtags(
+        String language, String script, String region) {
       test('fromSubtags: "$language / $script / $region"', () {
         expect(
             () => Locale.fromSubtags(
@@ -108,15 +109,15 @@
       [], 'en-u-co-phonebk-cu-usd-z-abc-001-foo-fii-bar');
 
   group('Locale.parse() throws FormatException:', () {
-    testExceptionForId(String x) {
+    void testExceptionForId(String x) {
       test('"$x"', () {
         expect(() => Locale.parse(x), throwsFormatException);
       });
     }
 
-    invalidLocales.forEach((badLocaleIdentifier) {
+    for (var badLocaleIdentifier in invalidLocales) {
       testExceptionForId(badLocaleIdentifier);
-    });
+    }
 
     // ICU permits '', taking it as 'und', but it is not a valid Unicode Locale
     // Identifier: We reject it.
@@ -144,11 +145,11 @@
   });
 
   group('Locale.tryParse() returns null:', () {
-    invalidLocales.forEach((badLocaleIdentifier) {
+    for (var badLocaleIdentifier in invalidLocales) {
       test('"$badLocaleIdentifier"', () {
         expect(Locale.tryParse(badLocaleIdentifier), isNull);
       });
-    });
+    }
   });
 
   // TODO: determine appropriate behaviour for the following examples.
@@ -174,7 +175,7 @@
   test('Locale cannot be modified via the variants field', () {
     var l = Locale.parse('en-scotland');
     List<String> v = l.variants;
-    bool good = false;
+    var good = false;
     try {
       v.add('basiceng');
     } on Error {
@@ -201,7 +202,7 @@
   });
 }
 
-testFromSubtags(
+void testFromSubtags(
     String language,
     String script,
     String region,
@@ -210,7 +211,7 @@
     String expectedRegion,
     String expectedTag) {
   test('Locale.fromSubtags(...) with $language, $script, $region', () {
-    Locale l = Locale.fromSubtags(
+    var l = Locale.fromSubtags(
         languageCode: language, scriptCode: script, countryCode: region);
     expect(l.languageCode, expectedLanguage);
     expect(l.scriptCode, expectedScript);
@@ -220,7 +221,7 @@
   });
 }
 
-testParse(
+void testParse(
     String bcp47Tag,
     String expectedLanguage,
     String expectedScript,
@@ -228,7 +229,7 @@
     Iterable<String> expectedVariants,
     String expectedTag) {
   test('Locale.parse("$bcp47Tag");', () {
-    Locale l = Locale.parse(bcp47Tag);
+    var l = Locale.parse(bcp47Tag);
     expect(l.languageCode, expectedLanguage);
     expect(l.scriptCode, expectedScript);
     expect(l.countryCode, expectedRegion);
diff --git a/test/number_closure_test.dart b/test/number_closure_test.dart
index 4f965c3..558b2dc 100644
--- a/test/number_closure_test.dart
+++ b/test/number_closure_test.dart
@@ -1,56 +1,57 @@
-// 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.
+/// Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
+/// 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.
 
 /// Tests based on the closure number formatting tests.
 library number_closure_test;
 
 import 'dart:async';
-import "package:intl/intl.dart";
-import "package:test/test.dart";
+import 'package:intl/intl.dart';
+import 'package:test/test.dart';
 
-main() {
-  test("testVeryBigNumber", testVeryBigNumber);
-  test("testStandardFormat", testStandardFormat);
-  test("testNegativePercentage", testNegativePercentage);
-  test("testCustomPercentage", testCustomPercentage);
-  test("testBasicFormat", testBasicFormat);
-  test("testGrouping", testGrouping);
-  test("testPerMill", testPerMill);
-  test("testQuotes", testQuotes);
-  test("testZeros", testZeros);
-  test("testExponential", testExponential);
-  test("testPlusSignInExponentPart", testPlusSignInExponentPart);
-  test("testApis", testApis);
-  test("testLocaleSwitch", testLocaleSwitch);
-  test("testLocaleSwitchAsync", testLocaleSwitchAsync);
+void main() {
+  test('testVeryBigNumber', testVeryBigNumber);
+  test('testStandardFormat', testStandardFormat);
+  test('testNegativePercentage', testNegativePercentage);
+  test('testCustomPercentage', testCustomPercentage);
+  test('testBasicFormat', testBasicFormat);
+  test('testGrouping', testGrouping);
+  test('testPerMill', testPerMill);
+  test('testQuotes', testQuotes);
+  test('testZeros', testZeros);
+  test('testExponential', testExponential);
+  test('testPlusSignInExponentPart', testPlusSignInExponentPart);
+  test('testApis', testApis);
+  test('testLocaleSwitch', testLocaleSwitch);
+  test('testLocaleSwitchAsync', testLocaleSwitchAsync);
 }
 
 /// Test two large numbers for equality, assuming that there may be some
 /// loss of precision in the less significant digits.
-veryBigNumberCompare(str1, str2) {
+bool veryBigNumberCompare(str1, str2) {
   return str1.length == str2.length &&
       str1.substring(0, 8) == str2.substring(0, 8);
 }
 
-testVeryBigNumber() {
-  var str;
-  var fmt;
+void testVeryBigNumber() {
+  String str;
+  NumberFormat fmt;
 
-  fmt = new NumberFormat.decimalPattern();
+  fmt = NumberFormat.decimalPattern();
   str = fmt.format(1.3456E20);
   expect(veryBigNumberCompare('134,560,000,000,000,000,000', str), isTrue);
 
-  fmt = new NumberFormat.percentPattern();
+  fmt = NumberFormat.percentPattern();
   str = fmt.format(1.3456E20);
   expect(veryBigNumberCompare('13,456,000,000,000,000,000,000%', str), isTrue);
 
   // TODO(alanknight): Note that this disagrees with what ICU would print
   // for this. We need significant digit support to do this properly.
-  fmt = new NumberFormat.scientificPattern();
+  fmt = NumberFormat.scientificPattern();
   str = fmt.format(1.3456E20);
   expect('1E20', str);
 
-  fmt = new NumberFormat.decimalPattern();
+  fmt = NumberFormat.decimalPattern();
   str = fmt.format(-1.234567890123456e306);
   expect(1 + 1 + 306 + 306 / 3, str.length);
   expect('-1,234,567,890,123,45', str.substring(0, 21));
@@ -62,32 +63,32 @@
 }
 
 void testStandardFormat() {
-  var str;
-  var fmt;
-  fmt = new NumberFormat.decimalPattern();
+  String str;
+  NumberFormat fmt;
+  fmt = NumberFormat.decimalPattern();
   str = fmt.format(1234.579);
   expect('1,234.579', str);
-  fmt = new NumberFormat.percentPattern();
+  fmt = NumberFormat.percentPattern();
   str = fmt.format(1234.579);
   expect('123,458%', str);
-  fmt = new NumberFormat.scientificPattern();
+  fmt = NumberFormat.scientificPattern();
   str = fmt.format(1234.579);
   expect('1E3', str);
 }
 
 void testNegativePercentage() {
-  var str;
-  var fmt = new NumberFormat('#,##0.00%');
+  String str;
+  var fmt = NumberFormat('#,##0.00%');
   str = fmt.format(-1234.56);
   expect('-123,456.00%', str);
 
-  fmt = new NumberFormat.percentPattern();
+  fmt = NumberFormat.percentPattern();
   str = fmt.format(-1234.579);
   expect('-123,458%', str);
 }
 
 void testCustomPercentage() {
-  var fmt = new NumberFormat.percentPattern();
+  var fmt = NumberFormat.percentPattern();
   fmt.maximumFractionDigits = 1;
   fmt.minimumFractionDigits = 1;
   var str = fmt.format(0.1291);
@@ -107,289 +108,281 @@
 }
 
 void testBasicFormat() {
-  var fmt = new NumberFormat('0.0000');
+  var fmt = NumberFormat('0.0000');
   var str = fmt.format(123.45789179565757);
   expect('123.4579', str);
 }
 
 void testGrouping() {
-  var str;
+  String str;
 
-  var fmt = new NumberFormat('#,###');
+  var fmt = NumberFormat('#,###');
   str = fmt.format(1234567890);
   expect('1,234,567,890', str);
-  fmt = new NumberFormat('#,####');
+  fmt = NumberFormat('#,####');
   str = fmt.format(1234567890);
   expect('12,3456,7890', str);
 
-  fmt = new NumberFormat('#');
+  fmt = NumberFormat('#');
   str = fmt.format(1234567890);
   expect('1234567890', str);
 }
 
 void testPerMill() {
-  var str;
+  String str;
 
-  var fmt = new NumberFormat('###.###\u2030');
+  var fmt = NumberFormat('###.###\u2030');
   str = fmt.format(0.4857);
   expect('485.7\u2030', str);
 }
 
 void testQuotes() {
-  var str;
+  String str;
 
-  var fmt = new NumberFormat('a\'fo\'\'o\'b#');
+  var fmt = NumberFormat('a\'fo\'\'o\'b#');
   str = fmt.format(123);
   expect('afo\'ob123', str);
 
-  fmt = new NumberFormat('a\'\'b#');
+  fmt = NumberFormat('a\'\'b#');
   str = fmt.format(123);
   expect('a\'b123', str);
 
-  fmt = new NumberFormat('a\'fo\'\'o\'b#');
+  fmt = NumberFormat('a\'fo\'\'o\'b#');
   str = fmt.format(-123);
   expect('-afo\'ob123', str);
 
-  fmt = new NumberFormat('a\'\'b#');
+  fmt = NumberFormat('a\'\'b#');
   str = fmt.format(-123);
   expect('-a\'b123', str);
 }
 
 void testZeros() {
-  var str;
-  var fmt;
+  String str;
 
-  fmt = new NumberFormat('#.#');
+  var fmt = NumberFormat('#.#');
   str = fmt.format(0);
   expect('0', str);
-  fmt = new NumberFormat('#.');
+  fmt = NumberFormat('#.');
   str = fmt.format(0);
   expect('0.', str);
-  fmt = new NumberFormat('.#');
+  fmt = NumberFormat('.#');
   str = fmt.format(0);
   expect('.0', str);
-  fmt = new NumberFormat('#');
+  fmt = NumberFormat('#');
   str = fmt.format(0);
   expect('0', str);
 
-  fmt = new NumberFormat('#0.#');
+  fmt = NumberFormat('#0.#');
   str = fmt.format(0);
   expect('0', str);
-  fmt = new NumberFormat('#0.');
+  fmt = NumberFormat('#0.');
   str = fmt.format(0);
   expect('0.', str);
-  fmt = new NumberFormat('#.0');
+  fmt = NumberFormat('#.0');
   str = fmt.format(0);
   expect('.0', str);
-  fmt = new NumberFormat('#');
+  fmt = NumberFormat('#');
   str = fmt.format(0);
   expect('0', str);
-  fmt = new NumberFormat('000');
+  fmt = NumberFormat('000');
   str = fmt.format(0);
   expect('000', str);
 }
 
 void testExponential() {
-  var str;
-  var fmt;
-
-  fmt = new NumberFormat('0.####E0');
+  String str;
+  var fmt = NumberFormat('0.####E0');
   str = fmt.format(0.01234);
   expect('1.234E-2', str);
-  fmt = new NumberFormat('00.000E00');
+  fmt = NumberFormat('00.000E00');
   str = fmt.format(0.01234);
   expect('12.340E-03', str);
-  fmt = new NumberFormat('##0.######E000');
+  fmt = NumberFormat('##0.######E000');
   str = fmt.format(0.01234);
   expect('12.34E-003', str);
-  fmt = new NumberFormat('0.###E0;[0.###E0]');
+  fmt = NumberFormat('0.###E0;[0.###E0]');
   str = fmt.format(0.01234);
   expect('1.234E-2', str);
 
-  fmt = new NumberFormat('0.####E0');
+  fmt = NumberFormat('0.####E0');
   str = fmt.format(123456789);
   expect('1.2346E8', str);
-  fmt = new NumberFormat('00.000E00');
+  fmt = NumberFormat('00.000E00');
   str = fmt.format(123456789);
   expect('12.346E07', str);
-  fmt = new NumberFormat('##0.######E000');
+  fmt = NumberFormat('##0.######E000');
   str = fmt.format(123456789);
   expect('123.456789E006', str);
-  fmt = new NumberFormat('0.###E0;[0.###E0]');
+  fmt = NumberFormat('0.###E0;[0.###E0]');
   str = fmt.format(123456789);
   expect('1.235E8', str);
 
-  fmt = new NumberFormat('0.####E0');
+  fmt = NumberFormat('0.####E0');
   str = fmt.format(1.23e300);
   expect('1.23E300', str);
-  fmt = new NumberFormat('00.000E00');
+  fmt = NumberFormat('00.000E00');
   str = fmt.format(1.23e300);
   expect('12.300E299', str);
-  fmt = new NumberFormat('##0.######E000');
+  fmt = NumberFormat('##0.######E000');
   str = fmt.format(1.23e300);
   expect('1.23E300', str);
-  fmt = new NumberFormat('0.###E0;[0.###E0]');
+  fmt = NumberFormat('0.###E0;[0.###E0]');
   str = fmt.format(1.23e300);
   expect('1.23E300', str);
 
-  fmt = new NumberFormat('0.####E0');
+  fmt = NumberFormat('0.####E0');
   str = fmt.format(-3.141592653e-271);
   expect('-3.1416E-271', str);
-  fmt = new NumberFormat('00.000E00');
+  fmt = NumberFormat('00.000E00');
   str = fmt.format(-3.141592653e-271);
   expect('-31.416E-272', str);
-  fmt = new NumberFormat('##0.######E000');
+  fmt = NumberFormat('##0.######E000');
   str = fmt.format(-3.141592653e-271);
   expect('-314.159265E-273', str);
-  fmt = new NumberFormat('0.###E0;[0.###E0]');
+  fmt = NumberFormat('0.###E0;[0.###E0]');
   str = fmt.format(-3.141592653e-271);
   expect('[3.142E-271]', str);
 
-  fmt = new NumberFormat('0.####E0');
+  fmt = NumberFormat('0.####E0');
   str = fmt.format(0);
   expect('0E0', str);
-  fmt = new NumberFormat('00.000E00');
+  fmt = NumberFormat('00.000E00');
   str = fmt.format(0);
   expect('00.000E00', str);
-  fmt = new NumberFormat('##0.######E000');
+  fmt = NumberFormat('##0.######E000');
   str = fmt.format(0);
   expect('0E000', str);
-  fmt = new NumberFormat('0.###E0;[0.###E0]');
+  fmt = NumberFormat('0.###E0;[0.###E0]');
   str = fmt.format(0);
   expect('0E0', str);
 
-  fmt = new NumberFormat('0.####E0');
+  fmt = NumberFormat('0.####E0');
   str = fmt.format(-1);
   expect('-1E0', str);
-  fmt = new NumberFormat('00.000E00');
+  fmt = NumberFormat('00.000E00');
   str = fmt.format(-1);
   expect('-10.000E-01', str);
-  fmt = new NumberFormat('##0.######E000');
+  fmt = NumberFormat('##0.######E000');
   str = fmt.format(-1);
   expect('-1E000', str);
-  fmt = new NumberFormat('0.###E0;[0.###E0]');
+  fmt = NumberFormat('0.###E0;[0.###E0]');
   str = fmt.format(-1);
   expect('[1E0]', str);
 
-  fmt = new NumberFormat('0.####E0');
+  fmt = NumberFormat('0.####E0');
   str = fmt.format(1);
   expect('1E0', str);
-  fmt = new NumberFormat('00.000E00');
+  fmt = NumberFormat('00.000E00');
   str = fmt.format(1);
   expect('10.000E-01', str);
-  fmt = new NumberFormat('##0.######E000');
+  fmt = NumberFormat('##0.######E000');
   str = fmt.format(1);
   expect('1E000', str);
-  fmt = new NumberFormat('0.###E0;[0.###E0]');
+  fmt = NumberFormat('0.###E0;[0.###E0]');
   str = fmt.format(1);
   expect('1E0', str);
 
-  fmt = new NumberFormat('#E0');
+  fmt = NumberFormat('#E0');
   str = fmt.format(12345.0);
   expect('1E4', str);
-  fmt = new NumberFormat('0E0');
+  fmt = NumberFormat('0E0');
   str = fmt.format(12345.0);
   expect('1E4', str);
-  fmt = new NumberFormat('##0.###E0');
+  fmt = NumberFormat('##0.###E0');
   str = fmt.format(12345.0);
   expect('12.345E3', str);
-  fmt = new NumberFormat('##0.###E0');
+  fmt = NumberFormat('##0.###E0');
   str = fmt.format(12345.00001);
   expect('12.345E3', str);
-  fmt = new NumberFormat('##0.###E0');
+  fmt = NumberFormat('##0.###E0');
   str = fmt.format(12345);
   expect('12.345E3', str);
 
-  fmt = new NumberFormat('##0.####E0');
+  fmt = NumberFormat('##0.####E0');
   str = fmt.format(789.12345e-9);
-  fmt = new NumberFormat('##0.####E0');
+  fmt = NumberFormat('##0.####E0');
   str = fmt.format(780e-9);
   expect('780E-9', str);
-  fmt = new NumberFormat('.###E0');
+  fmt = NumberFormat('.###E0');
   str = fmt.format(45678.0);
   expect('.457E5', str);
-  fmt = new NumberFormat('.###E0');
+  fmt = NumberFormat('.###E0');
   str = fmt.format(0);
   expect('.0E0', str);
 
-  fmt = new NumberFormat('#E0');
+  fmt = NumberFormat('#E0');
   str = fmt.format(45678000);
   expect('5E7', str);
-  fmt = new NumberFormat('##E0');
+  fmt = NumberFormat('##E0');
   str = fmt.format(45678000);
   expect('46E6', str);
-  fmt = new NumberFormat('####E0');
+  fmt = NumberFormat('####E0');
   str = fmt.format(45678000);
   expect('4568E4', str);
-  fmt = new NumberFormat('0E0');
+  fmt = NumberFormat('0E0');
   str = fmt.format(45678000);
   expect('5E7', str);
-  fmt = new NumberFormat('00E0');
+  fmt = NumberFormat('00E0');
   str = fmt.format(45678000);
   expect('46E6', str);
-  fmt = new NumberFormat('000E0');
+  fmt = NumberFormat('000E0');
   str = fmt.format(45678000);
   expect('457E5', str);
-  fmt = new NumberFormat('###E0');
+  fmt = NumberFormat('###E0');
   str = fmt.format(0.0000123);
   expect('12E-6', str);
-  fmt = new NumberFormat('###E0');
+  fmt = NumberFormat('###E0');
   str = fmt.format(0.000123);
   expect('123E-6', str);
-  fmt = new NumberFormat('###E0');
+  fmt = NumberFormat('###E0');
   str = fmt.format(0.00123);
   expect('1E-3', str);
-  fmt = new NumberFormat('###E0');
+  fmt = NumberFormat('###E0');
   str = fmt.format(0.0123);
   expect('12E-3', str);
-  fmt = new NumberFormat('###E0');
+  fmt = NumberFormat('###E0');
   str = fmt.format(0.123);
   expect('123E-3', str);
-  fmt = new NumberFormat('###E0');
+  fmt = NumberFormat('###E0');
   str = fmt.format(1.23);
   expect('1E0', str);
-  fmt = new NumberFormat('###E0');
+  fmt = NumberFormat('###E0');
   str = fmt.format(12.3);
   expect('12E0', str);
-  fmt = new NumberFormat('###E0');
+  fmt = NumberFormat('###E0');
   str = fmt.format(123.0);
   expect('123E0', str);
-  fmt = new NumberFormat('###E0');
+  fmt = NumberFormat('###E0');
   str = fmt.format(1230.0);
   expect('1E3', str);
 }
 
 void testPlusSignInExponentPart() {
-  var fmt;
-  fmt = new NumberFormat('0E+0');
+  var fmt = NumberFormat('0E+0');
   var str = fmt.format(45678000);
   expect('5E+7', str);
 }
 
 void testApis() {
-  var fmt;
-  var str;
-
-  fmt = new NumberFormat('#,###');
-  str = fmt.format(1234567890);
+  var fmt = NumberFormat('#,###');
+  var str = fmt.format(1234567890);
   expect('1,234,567,890', str);
 }
 
-testLocaleSwitch() {
-  Intl.withLocale("fr", verifyFrenchLocale);
+void testLocaleSwitch() {
+  Intl.withLocale('fr', verifyFrenchLocale);
 }
 
-typedef void TimerArgument();
-testLocaleSwitchAsync() {
-  Intl.withLocale("fr", () {
-    new Timer(new Duration(milliseconds: 10), expectAsync0(verifyFrenchLocale));
+void testLocaleSwitchAsync() {
+  Intl.withLocale('fr', () {
+    Timer(const Duration(milliseconds: 10), expectAsync0(verifyFrenchLocale));
   });
   // Verify that things running outside the zone still get en_US.
   testStandardFormat();
 }
 
 void verifyFrenchLocale() {
-  var fmt = new NumberFormat('#,###');
+  var fmt = NumberFormat('#,###');
   var str = fmt.format(1234567890);
   expect(str, '1\u202f234\u202f567\u202f890');
 }
diff --git a/test/number_format_compact_test.dart b/test/number_format_compact_test.dart
index 650c974..0c7ad5f 100644
--- a/test/number_format_compact_test.dart
+++ b/test/number_format_compact_test.dart
@@ -12,10 +12,10 @@
 /// A place to put a case that's causing a problem and have it run first when
 /// debugging
 var interestingCases = <String, List<List<String>>>{
-//  "mn" : [["4321", "4.32M", "whatever"]]
+//  'mn' : [['4321', '4.32M', 'whatever']]
 };
 
-main() {
+void main() {
   interestingCases.forEach(validate);
   testdata.compactNumberTestData.forEach(validate);
 
@@ -24,82 +24,83 @@
   // smoke test. JPY is a useful test because it has no decimalDigits and
   // different grouping than USD, as well as a different currency symbol and
   // suffixes.
-  testCurrency("ja", 1.2345, "¥1", "¥1");
-  testCurrency("ja", 1, "¥1", "¥1");
-  testCurrency("ja", 12, "¥12", "¥10");
-  testCurrency("ja", 123, "¥123", "¥100");
-  testCurrency("ja", 1234, "¥1230", "¥1000");
-  testCurrency("ja", 12345, "¥1.23\u4E07", "¥1\u4E07");
-  testCurrency("ja", 123456, "¥12.3\u4E07", "¥10\u4E07");
-  testCurrency("ja", 1234567, "¥123\u4e07", "¥100\u4e07");
-  testCurrency("ja", 12345678, "¥1230\u4e07", "¥1000\u4e07");
-  testCurrency("ja", 123456789, "¥1.23\u5104", "¥1\u5104");
+  testCurrency('ja', 1.2345, '¥1', '¥1');
+  testCurrency('ja', 1, '¥1', '¥1');
+  testCurrency('ja', 12, '¥12', '¥10');
+  testCurrency('ja', 123, '¥123', '¥100');
+  testCurrency('ja', 1234, '¥1230', '¥1000');
+  testCurrency('ja', 12345, '¥1.23\u4E07', '¥1\u4E07');
+  testCurrency('ja', 123456, '¥12.3\u4E07', '¥10\u4E07');
+  testCurrency('ja', 1234567, '¥123\u4e07', '¥100\u4e07');
+  testCurrency('ja', 12345678, '¥1230\u4e07', '¥1000\u4e07');
+  testCurrency('ja', 123456789, '¥1.23\u5104', '¥1\u5104');
 
-  testCurrency("ja", 0.9876, "¥1", "¥1");
-  testCurrency("ja", 9, "¥9", "¥9");
-  testCurrency("ja", 98, "¥98", "¥100");
-  testCurrency("ja", 987, "¥987", "¥1000");
-  testCurrency("ja", 9876, "¥9880", "¥1\u4E07");
-  testCurrency("ja", 98765, "¥9.88\u4E07", "¥10\u4E07");
-  testCurrency("ja", 987656, "¥98.8\u4E07", "¥100\u4E07");
-  testCurrency("ja", 9876567, "¥988\u4e07", "¥1000\u4e07");
-  testCurrency("ja", 98765678, "¥9880\u4e07", "¥1\u5104");
-  testCurrency("ja", 987656789, "¥9.88\u5104", "¥10\u5104");
+  testCurrency('ja', 0.9876, '¥1', '¥1');
+  testCurrency('ja', 9, '¥9', '¥9');
+  testCurrency('ja', 98, '¥98', '¥100');
+  testCurrency('ja', 987, '¥987', '¥1000');
+  testCurrency('ja', 9876, '¥9880', '¥1\u4E07');
+  testCurrency('ja', 98765, '¥9.88\u4E07', '¥10\u4E07');
+  testCurrency('ja', 987656, '¥98.8\u4E07', '¥100\u4E07');
+  testCurrency('ja', 9876567, '¥988\u4e07', '¥1000\u4e07');
+  testCurrency('ja', 98765678, '¥9880\u4e07', '¥1\u5104');
+  testCurrency('ja', 987656789, '¥9.88\u5104', '¥10\u5104');
 
-  testCurrency("en_US", 1.2345, r"$1.23", r"$1");
-  testCurrency("en_US", 1, r"$1.00", r"$1");
-  testCurrency("en_US", 12, r"$12.00", r"$10");
-  testCurrency("en_US", 12.3, r"$12.30", r"$10");
-  testCurrency("en_US", 123, r"$123", r"$100");
-  testCurrency("en_US", 1234, r"$1.23K", r"$1K");
-  testCurrency("en_US", 12345, r"$12.3K", r"$10K");
-  testCurrency("en_US", 123456, r"$123K", r"$100K");
-  testCurrency("en_US", 1234567, r"$1.23M", r"$1M");
+  testCurrency('en_US', 1.2345, r'$1.23', r'$1');
+  testCurrency('en_US', 1, r'$1.00', r'$1');
+  testCurrency('en_US', 12, r'$12.00', r'$10');
+  testCurrency('en_US', 12.3, r'$12.30', r'$10');
+  testCurrency('en_US', 123, r'$123', r'$100');
+  testCurrency('en_US', 1234, r'$1.23K', r'$1K');
+  testCurrency('en_US', 12345, r'$12.3K', r'$10K');
+  testCurrency('en_US', 123456, r'$123K', r'$100K');
+  testCurrency('en_US', 1234567, r'$1.23M', r'$1M');
 
   // Check for order of currency symbol when currency is a suffix.
-  testCurrency("ru", 4420, "4,42\u00A0тыс.\u00A0руб.", "4\u00A0тыс.\u00A0руб.");
+  testCurrency('ru', 4420, '4,42\u00A0тыс.\u00A0руб.', '4\u00A0тыс.\u00A0руб.');
 
   // Locales which don't have a suffix for thousands.
-  testCurrency("it", 442, "442\u00A0€", "400\u00A0€");
-  testCurrency("it", 4420, "4420\u00A0\$", "4000\u00A0\$", currency: 'CAD');
-  testCurrency("it", 4420000, "4,42\u00A0Mio\u00A0\$", "4\u00A0Mio\u00A0\$",
+  testCurrency('it', 442, '442\u00A0€', '400\u00A0€');
+  testCurrency('it', 4420, '4420\u00A0\$', '4000\u00A0\$', currency: 'CAD');
+  testCurrency('it', 4420000, '4,42\u00A0Mio\u00A0\$', '4\u00A0Mio\u00A0\$',
       currency: 'USD');
 
-  test("Explicit non-default symbol with compactCurrency", () {
-    var format = new NumberFormat.compactCurrency(locale: "ja", symbol: "()");
+  test('Explicit non-default symbol with compactCurrency', () {
+    var format = NumberFormat.compactCurrency(locale: 'ja', symbol: '()');
     var result = format.format(98765);
-    expect(result, "()9.88\u4e07");
+    expect(result, '()9.88\u4e07');
   });
 }
 
-testCurrency(String locale, num number, String expected, String expectedShort,
+void testCurrency(
+    String locale, num number, String expected, String expectedShort,
     {String currency}) {
-  test("Compact simple currency for $locale, $number", () {
+  test('Compact simple currency for $locale, $number', () {
     var format =
-        new NumberFormat.compactSimpleCurrency(locale: locale, name: currency);
+        NumberFormat.compactSimpleCurrency(locale: locale, name: currency);
     var result = format.format(number);
     expect(result, expected);
     var shortFormat =
-        new NumberFormat.compactSimpleCurrency(locale: locale, name: currency);
+        NumberFormat.compactSimpleCurrency(locale: locale, name: currency);
     shortFormat.significantDigits = 1;
     var shortResult = shortFormat.format(number);
     expect(shortResult, expectedShort);
   });
-  test("Compact currency for $locale, $number", () {
+  test('Compact currency for $locale, $number', () {
     var symbols = {
-      "ja": "¥",
-      "en_US": r"$",
-      "ru": "руб.",
-      "it": "€",
-      "CAD": r"$",
-      "USD": r"$"
+      'ja': '¥',
+      'en_US': r'$',
+      'ru': 'руб.',
+      'it': '€',
+      'CAD': r'$',
+      'USD': r'$'
     };
     var symbol = symbols[currency] ?? symbols[locale];
-    var format = new NumberFormat.compactCurrency(
+    var format = NumberFormat.compactCurrency(
         locale: locale, name: currency, symbol: symbol);
     var result = format.format(number);
     expect(result, expected);
-    var shortFormat = new NumberFormat.compactCurrency(
+    var shortFormat = NumberFormat.compactCurrency(
         locale: locale, name: currency, symbol: symbol);
     shortFormat.significantDigits = 1;
     var shortResult = shortFormat.format(number);
@@ -112,33 +113,33 @@
 // TODO(alanknight): Fix the problems, or at least figure out precisely where
 // the differences are.
 var problemLocalesShort = [
-  "am", // AM Suffixes differ, not sure why.
-  "ca", // For CA, CLDR rules are different. Jumps from 0000 to 00 prefix, so
+  'am', // AM Suffixes differ, not sure why.
+  'ca', // For CA, CLDR rules are different. Jumps from 0000 to 00 prefix, so
   // 11 digits prints as 11900.
-  "es_419", // Some odd formatting rules for these which seem to be different
+  'es_419', // Some odd formatting rules for these which seem to be different
   // from CLDR. wants e.g. '160000000000k' Actual: '160 B'
-  "es_ES", // The reverse of es_419 for a few cases. We're printing a longer
+  'es_ES', // The reverse of es_419 for a few cases. We're printing a longer
   // form.
-  "es_US", // Like es_419 but not as many of them. e.g. Expected: '87700k'
+  'es_US', // Like es_419 but not as many of them. e.g. Expected: '87700k'
   // Actual: '87.7 M'
-  "es_MX", // like es_419
-  "es",
-  "fa",
-  "fr_CA", // Several where PyICU isn't compacting. Expected: '988000000'
+  'es_MX', // like es_419
+  'es',
+  'fa',
+  'fr_CA', // Several where PyICU isn't compacting. Expected: '988000000'
   // Actual: '988 M'.
-  "gsw", // Suffixes disagree
-  "in", // IN not compacting 54321, looks similar to tr.
-  "id", // ID not compacting 54321, looks similar to tr.
-  "ka", // K Slight difference in the suffix
-  "kk", "mn", // We're picking the wrong pattern for 654321.
-  "lo", "mk", "my",
-  "pt_PT", // Seems to differ in appending mil or not after thousands. pt_BR
+  'gsw', // Suffixes disagree
+  'in', // IN not compacting 54321, looks similar to tr.
+  'id', // ID not compacting 54321, looks similar to tr.
+  'ka', // K Slight difference in the suffix
+  'kk', 'mn', // We're picking the wrong pattern for 654321.
+  'lo', 'mk', 'my',
+  'pt_PT', // Seems to differ in appending mil or not after thousands. pt_BR
   // does it.
-  "sd", // ICU considers this locale data questionable
-  "th", // TH Expected abbreviations as '1.09 พ.ล.' rather than '1.09 พ'
-  "tr", // TR Doesn't have a 0B format, goes directly to 00B, as a result 54321
+  'sd', // ICU considers this locale data questionable
+  'th', // TH Expected abbreviations as '1.09 พ.ล.' rather than '1.09 พ'
+  'tr', // TR Doesn't have a 0B format, goes directly to 00B, as a result 54321
   // just prints as 54321
-  "ur", // UR Fails one with Expected: '15 ٹریلین'  Actual: '150 کھرب'
+  'ur', // UR Fails one with Expected: '15 ٹریلین'  Actual: '150 کھرب'
 ];
 
 /// Locales that have problems in the long format.
@@ -151,27 +152,27 @@
 //TODO(alanknight): Narrow these down to particular numbers. Often it's just
 // 999999.
 var problemLocalesLong = [
-  "ar", "ar_DZ", "ar_EG",
-  "be", "bg", "bs",
-  "ca", "cs", "da", "de", "de_AT", "de_CH", "el", "es", "es_419", "es_ES",
-  "es_MX", "es_US", "et", "fi",
-  "fil", // FIL is different, seems like a genuine difference in suffixes
-  "fr", "fr_CA",
-  "fr_CH", // TODO(alanknight): million/millions, supported since CLDR 31.
-  "ga", "gl",
-  "gsw", // GSW seems like we have long forms and pyICU doesn't
-  "hr", "is", "it",
-  "it_CH", "lo", // LO seems to be picking up a different pattern.
-  "lt", "lv", "mk",
-  "my", // Seems to come out in the reverse order
-  "nb", "ne", "no", "no_NO", "pl",
-  "pt", // PT has some issues with scale as well, but I think it's differences
+  'ar', 'ar_DZ', 'ar_EG',
+  'be', 'bg', 'bs',
+  'ca', 'cs', 'da', 'de', 'de_AT', 'de_CH', 'el', 'es', 'es_419', 'es_ES',
+  'es_MX', 'es_US', 'et', 'fi',
+  'fil', // FIL is different, seems like a genuine difference in suffixes
+  'fr', 'fr_CA',
+  'fr_CH', // TODO(alanknight): million/millions, supported since CLDR 31.
+  'ga', 'gl',
+  'gsw', // GSW seems like we have long forms and pyICU doesn't
+  'hr', 'is', 'it',
+  'it_CH', 'lo', // LO seems to be picking up a different pattern.
+  'lt', 'lv', 'mk',
+  'my', // Seems to come out in the reverse order
+  'nb', 'ne', 'no', 'no_NO', 'pl',
+  'pt', // PT has some issues with scale as well, but I think it's differences
   // in the patterns.
-  "pt_BR", "pt_PT", "ro", "ru",
-  "sd", // ICU considers this locale data questionable
-  "sk", "sl", "sr", "sr_Latn", "sv", "te", "tl",
-  "ur",
-  "uk",
+  'pt_BR', 'pt_PT', 'ro', 'ru',
+  'sd', // ICU considers this locale data questionable
+  'sk', 'sl', 'sr', 'sr_Latn', 'sv', 'te', 'tl',
+  'ur',
+  'uk',
 ];
 
 void validate(String locale, List<List<String>> expected) {
@@ -186,12 +187,12 @@
     print("Skipping problem locale '$locale' for SHORT compact number tests");
     return;
   }
-  var shortFormat = new NumberFormat.compact(locale: locale);
-  test("Validate $locale SHORT", () {
+  var shortFormat = NumberFormat.compact(locale: locale);
+  test('Validate $locale SHORT', () {
     for (var data in expected) {
       var number = num.parse(data.first);
       validateNumber(number, shortFormat, data[1]);
-      var int64Number = new Int64(number);
+      var int64Number = Int64(number);
       validateNumber(int64Number, shortFormat, data[1]);
       // TODO(alanknight): Make this work for MicroMoney
     }
@@ -203,8 +204,8 @@
     print("Skipping problem locale '$locale' for LONG compact number tests");
     return;
   }
-  var longFormat = new NumberFormat.compactLong(locale: locale);
-  test("Validate $locale LONG", () {
+  var longFormat = NumberFormat.compactLong(locale: locale);
+  test('Validate $locale LONG', () {
     for (var data in expected) {
       var number = num.parse(data.first);
       validateNumber(number, longFormat, data[2]);
@@ -217,7 +218,7 @@
   var ok = closeEnough(formatted, expected);
   if (!ok) {
     expect(
-        "$formatted ${formatted.codeUnits}", "$expected ${expected.codeUnits}");
+        '$formatted ${formatted.codeUnits}', '$expected ${expected.codeUnits}');
   }
   var parsed = format.parse(formatted);
   var rounded = roundForPrinting(number, format);
@@ -228,7 +229,7 @@
 /// number that will round to print differently depending on the number
 /// of significant digits, we need to check that as well, e.g.
 /// 999999 may print as 1M.
-roundForPrinting(number, NumberFormat format) {
+num roundForPrinting(number, NumberFormat format) {
   var originalLength = NumberFormat.numberOfIntegerDigits(number);
   var additionalDigits = originalLength - format.significantDigits;
   if (additionalDigits > 0) {
@@ -241,7 +242,7 @@
 }
 
 final _nbsp = 0xa0;
-final _nbspString = new String.fromCharCode(_nbsp);
+final _nbspString = String.fromCharCode(_nbsp);
 
 /// Return true if the strings are close enough to what we
 /// expected to consider a pass.
@@ -275,12 +276,12 @@
 /// equal because that's checked first in the only caller.
 bool _oneSpaceOnlyDifference(String result, String expected) {
   var resultWithoutSpaces =
-      new String.fromCharCodes(result.codeUnits.where((x) => x != _nbsp));
+      String.fromCharCodes(result.codeUnits.where((x) => x != _nbsp));
   var expectedWithoutSpaces =
-      new String.fromCharCodes(expected.codeUnits.where((x) => x != _nbsp));
+      String.fromCharCodes(expected.codeUnits.where((x) => x != _nbsp));
   var resultDifference = result.length - resultWithoutSpaces.length;
   var expectedDifference = expected.length - expectedWithoutSpaces.length;
-  return (resultWithoutSpaces == expectedWithoutSpaces &&
+  return resultWithoutSpaces == expectedWithoutSpaces &&
       resultDifference <= 1 &&
-      expectedDifference <= 1);
+      expectedDifference <= 1;
 }
diff --git a/test/number_format_test_core.dart b/test/number_format_test_core.dart
index 9a54071..26fa95d 100644
--- a/test/number_format_test_core.dart
+++ b/test/number_format_test_core.dart
@@ -11,38 +11,38 @@
 
 /// Tests the Numeric formatting library in dart.
 var testNumbersWeCanReadBack = {
-  "-1": -1,
-  "-2": -2.0,
-  "-0.01": -0.01,
-  "-1.23": -1.23,
-  "0.001": 0.001,
-  "0.01": 0.01,
-  "0.1": 0.1,
-  "1": 1,
-  "2": 2.0,
-  "10": 10,
-  "100": 100,
-  "1,000": 1000,
-  "2,000,000,000,000": 2000000000000,
-  "0.123": 0.123,
-  "1,234": 1234.0,
-  "1.234": 1.234,
-  "1.23": 1.230,
-  "NaN": 0.0 / 0.0,
-  "∞": 1.0 / 0.0,
-  "-∞": -1.0 / 0.0,
+  '-1': -1,
+  '-2': -2.0,
+  '-0.01': -0.01,
+  '-1.23': -1.23,
+  '0.001': 0.001,
+  '0.01': 0.01,
+  '0.1': 0.1,
+  '1': 1,
+  '2': 2.0,
+  '10': 10,
+  '100': 100,
+  '1,000': 1000,
+  '2,000,000,000,000': 2000000000000,
+  '0.123': 0.123,
+  '1,234': 1234.0,
+  '1.234': 1.234,
+  '1.23': 1.230,
+  'NaN': 0.0 / 0.0,
+  '∞': 1.0 / 0.0,
+  '-∞': -1.0 / 0.0,
 };
 
 /// Test numbers that we can't parse because we lose precision in formatting.
 var testNumbersWeCannotReadBack = {
-  "3.142": 3.1415926535897932,
-  "-1.234": -1.2342,
-  "-1.235": -1.2348,
-  "1.234": 1.2342,
-  "1.235": 1.2348
+  '3.142': 3.1415926535897932,
+  '-1.234': -1.2342,
+  '-1.235': -1.2348,
+  '1.234': 1.2342,
+  '1.235': 1.2348
 };
 
-var testExponential = const {"1E-3": 0.001, "1E-2": 0.01, "1.23E0": 1.23};
+var testExponential = const {'1E-3': 0.001, '1E-2': 0.01, '1.23E0': 1.23};
 
 // TODO(alanknight): Test against currency, which requires generating data
 // for the three different forms that this now supports.
@@ -50,20 +50,20 @@
 // digit support.
 List<NumberFormat> standardFormats(String locale) {
   return [
-    new NumberFormat.decimalPattern(locale),
-    new NumberFormat.percentPattern(locale),
+    NumberFormat.decimalPattern(locale),
+    NumberFormat.percentPattern(locale),
   ];
 }
 
 Map<String, num> get testNumbers =>
-    new Map.from(testNumbersWeCanReadBack)..addAll(testNumbersWeCannotReadBack);
+    Map.from(testNumbersWeCanReadBack)..addAll(testNumbersWeCannotReadBack);
 
-runTests(Map<String, num> allTestNumbers) {
+void runTests(Map<String, num> allTestNumbers) {
   // For data from a list of locales, run each locale's data as a separate
   // test so we can see exactly which ones pass or fail. The test data is
   // hard-coded as printing 123, -12.3, %12,300, -1,230% in each locale.
   var mainList = numberTestData;
-  var sortedLocales = new List.from(numberFormatSymbols.keys);
+  var sortedLocales = List.from(numberFormatSymbols.keys);
   sortedLocales.sort((a, b) => a.compareTo(b));
   for (var locale in sortedLocales) {
     var testFormats = standardFormats(locale);
@@ -77,7 +77,7 @@
   }
 
   test('Simple set of numbers', () {
-    var number = new NumberFormat();
+    var number = NumberFormat();
     for (var x in allTestNumbers.keys) {
       var formatted = number.format(allTestNumbers[x]);
       expect(formatted, x);
@@ -105,14 +105,14 @@
       '0,000,001'
     ];
     for (var i = 0; i < 7; i++) {
-      var f = new NumberFormat.decimalPattern();
+      var f = NumberFormat.decimalPattern();
       f.minimumIntegerDigits = i;
       expect(f.format(1), expected[i]);
     }
   });
 
   test('Exponential form', () {
-    var number = new NumberFormat("#.###E0");
+    var number = NumberFormat('#.###E0');
     for (var x in testExponential.keys) {
       var formatted = number.format(testExponential[x]);
       expect(formatted, x);
@@ -122,9 +122,9 @@
   });
 
   test('Percent with no decimals and no integer part', () {
-    var number = new NumberFormat("#%");
+    var number = NumberFormat('#%');
     var formatted = number.format(0.12);
-    expect(formatted, "12%");
+    expect(formatted, '12%');
     var readBack = number.parse(formatted);
     expect(0.12, readBack);
   });
@@ -133,8 +133,8 @@
   // numbers and we're reading them in a format where they won't print
   // back the same way.
   test('Parsing modifiers,e.g. percent, in the base format', () {
-    var number = new NumberFormat();
-    var modified = {"12%": 0.12, "12\u2030": 0.012};
+    var number = NumberFormat();
+    var modified = {'12%': 0.12, '12\u2030': 0.012};
     modified.addAll(testExponential);
     for (var x in modified.keys) {
       var parsed = number.parse(x);
@@ -144,41 +144,48 @@
 
   test('Explicit currency name', () {
     var amount = 1000000.32;
-    var usConvention = new NumberFormat.currency(locale: 'en_US', symbol: '€');
+    var usConvention = NumberFormat.currency(locale: 'en_US', symbol: '€');
     var formatted = usConvention.format(amount);
     expect(formatted, '€1,000,000.32');
     var readBack = usConvention.parse(formatted);
     expect(readBack, amount);
     // ignore: deprecated_member_use_from_same_package
-    var swissConvention = new NumberFormat.currencyPattern('de_CH', r'$');
+    var swissConvention = NumberFormat.currencyPattern('de_CH', r'$');
     formatted = swissConvention.format(amount);
-    var nbsp = new String.fromCharCode(0xa0);
-    var backquote = new String.fromCharCode(0x2019);
-    expect(formatted,
-        r"$" + nbsp + "1" + backquote + "000" + backquote + "000.32");
+    var nbsp = String.fromCharCode(0xa0);
+    var backquote = String.fromCharCode(0x2019);
+    //ignore: prefer_interpolation_to_compose_strings
+    expect(
+        formatted,
+        //ignore: prefer_interpolation_to_compose_strings
+        r'$' + nbsp + '1' + backquote + '000' + backquote + '000.32');
     readBack = swissConvention.parse(formatted);
     expect(readBack, amount);
 
     // ignore: deprecated_member_use_from_same_package
-    var italianSwiss = new NumberFormat.currencyPattern('it_CH', r'$');
+    var italianSwiss = NumberFormat.currencyPattern('it_CH', r'$');
     formatted = italianSwiss.format(amount);
-    expect(formatted,
-        r"$" + nbsp + "1" + backquote + "000" + backquote + "000.32");
+    expect(
+        formatted,
+        //ignore: prefer_interpolation_to_compose_strings
+        r'$' + nbsp + '1' + backquote + '000' + backquote + '000.32');
     readBack = italianSwiss.parse(formatted);
     expect(readBack, amount);
 
     /// Verify we can leave off the currency and it gets filled in.
-    var plainSwiss = new NumberFormat.currency(locale: 'de_CH');
+    var plainSwiss = NumberFormat.currency(locale: 'de_CH');
     formatted = plainSwiss.format(amount);
-    expect(formatted,
-        r"CHF" + nbsp + "1" + backquote + "000" + backquote + "000.32");
+    expect(
+        formatted,
+        //ignore: prefer_interpolation_to_compose_strings
+        r'CHF' + nbsp + '1' + backquote + '000' + backquote + '000.32');
     readBack = plainSwiss.parse(formatted);
     expect(readBack, amount);
 
     // Verify that we can pass null in order to specify the currency symbol
     // but use the default locale.
     // ignore: deprecated_member_use_from_same_package
-    var defaultLocale = new NumberFormat.currencyPattern(null, 'Smurfs');
+    var defaultLocale = NumberFormat.currencyPattern(null, 'Smurfs');
     formatted = defaultLocale.format(amount);
     // We don't know what the exact format will be, but it should have Smurfs.
     expect(formatted.contains('Smurfs'), isTrue);
@@ -186,60 +193,59 @@
     expect(readBack, amount);
   });
 
-  test("Delta percent format", () {
-    var f = new NumberFormat("+#,##0%;-#,##0%");
-    expect(f.format(-0.07), "-7%");
-    expect(f.format(0.12), "+12%");
+  test('Delta percent format', () {
+    var f = NumberFormat('+#,##0%;-#,##0%');
+    expect(f.format(-0.07), '-7%');
+    expect(f.format(0.12), '+12%');
   });
 
   test('Unparseable', () {
-    var format = new NumberFormat.currency();
-    expect(() => format.parse("abcdefg"), throwsFormatException);
-    expect(() => format.parse(""), throwsFormatException);
-    expect(() => format.parse("1.0zzz"), throwsFormatException);
-    expect(() => format.parse("-∞+1"), throwsFormatException);
+    var format = NumberFormat.currency();
+    expect(() => format.parse('abcdefg'), throwsFormatException);
+    expect(() => format.parse(''), throwsFormatException);
+    expect(() => format.parse('1.0zzz'), throwsFormatException);
+    expect(() => format.parse('-∞+1'), throwsFormatException);
   });
 
   var digitsCheck = {
-    0: "@4",
-    1: "@4.3",
-    2: "@4.32",
-    3: "@4.322",
-    4: "@4.3220",
+    0: '@4',
+    1: '@4.3',
+    2: '@4.32',
+    3: '@4.322',
+    4: '@4.3220',
   };
 
   test('Decimal digits', () {
     var amount = 4.3219876;
     for (var digits in digitsCheck.keys) {
-      var f = new NumberFormat.currency(
+      var f = NumberFormat.currency(
           locale: 'en_US', symbol: '@', decimalDigits: digits);
       var formatted = f.format(amount);
       expect(formatted, digitsCheck[digits]);
     }
-    var defaultFormat = new NumberFormat.currency(locale: 'en_US', symbol: '@');
+    var defaultFormat = NumberFormat.currency(locale: 'en_US', symbol: '@');
     var formatted = defaultFormat.format(amount);
     expect(formatted, digitsCheck[2]);
 
     var jpyUs =
-        new NumberFormat.currency(locale: 'en_US', name: 'JPY', symbol: '@');
+        NumberFormat.currency(locale: 'en_US', name: 'JPY', symbol: '@');
     formatted = jpyUs.format(amount);
     expect(formatted, digitsCheck[0]);
 
-    var jpyJa =
-        new NumberFormat.currency(locale: 'ja', name: 'JPY', symbol: '@');
+    var jpyJa = NumberFormat.currency(locale: 'ja', name: 'JPY', symbol: '@');
     formatted = jpyJa.format(amount);
     expect(formatted, digitsCheck[0]);
 
-    var jpySimple = new NumberFormat.simpleCurrency(locale: 'ja', name: 'JPY');
+    var jpySimple = NumberFormat.simpleCurrency(locale: 'ja', name: 'JPY');
     formatted = jpySimple.format(amount);
-    expect(formatted, "¥4");
+    expect(formatted, '¥4');
 
     var jpyLower =
-        new NumberFormat.currency(locale: 'en_US', name: 'jpy', symbol: '@');
+        NumberFormat.currency(locale: 'en_US', name: 'jpy', symbol: '@');
     formatted = jpyLower.format(amount);
     expect(formatted, digitsCheck[0]);
 
-    var tnd = new NumberFormat.currency(name: 'TND', symbol: '@');
+    var tnd = NumberFormat.currency(name: 'TND', symbol: '@');
     formatted = tnd.format(amount);
     expect(formatted, digitsCheck[3]);
   });
@@ -247,7 +253,7 @@
   testSimpleCurrencySymbols();
 
   test('Padding digits with non-ascii zero', () {
-    var format = new NumberFormat('000', 'ar_EG');
+    var format = NumberFormat('000', 'ar_EG');
     var padded = format.format(0);
     expect(padded, '٠٠٠');
   });
@@ -255,8 +261,8 @@
   // Exercise a custom pattern. There's not actually much logic here, so just
   // validate that the custom pattern is in fact being used.
   test('Custom currency pattern', () {
-    var format = new NumberFormat.currency(
-        name: 'XYZZY', customPattern: '[\u00a4][#,##.#]');
+    var format =
+        NumberFormat.currency(name: 'XYZZY', customPattern: '[\u00a4][#,##.#]');
     var text = format.format(12345.67);
     expect(text, '[XYZZY][1,23,45.67]');
   });
@@ -268,14 +274,14 @@
   // which we don't want. We also treat the difference between Unicode
   // minus sign (2212) and hyphen-minus (45) as not significant.
   return input
-      .replaceAll("\u200e", "")
-      .replaceAll("\u200f", "")
-      .replaceAll("\u061c", "")
-      .replaceAll("\u2212", "-");
+      .replaceAll('\u200e', '')
+      .replaceAll('\u200f', '')
+      .replaceAll('\u061c', '')
+      .replaceAll('\u2212', '-');
 }
 
 void testAgainstIcu(locale, List<NumberFormat> testFormats, list) {
-  test("Test against ICU data for $locale", () {
+  test('Test against ICU data for $locale', () {
     for (var format in testFormats) {
       var formatted = format.format(123);
       var negative = format.format(-12.3);
@@ -296,35 +302,35 @@
   });
 }
 
-testSimpleCurrencySymbols() {
+void testSimpleCurrencySymbols() {
   var currencies = ['USD', 'CAD', 'EUR', 'CRC', null];
   //  Note that these print using the simple symbol as if we were in a
   // a locale where that currency symbol is well understood. So we
   // expect Canadian dollars printed as $, even though our locale is
   // en_US, and this would confuse users.
   var simple = currencies.map((currency) =>
-      new NumberFormat.simpleCurrency(locale: 'en_US', name: currency));
+      NumberFormat.simpleCurrency(locale: 'en_US', name: currency));
   var expectedSimple = [r'$', r'$', '\u20ac', '\u20a1', r'$'];
   // These will always print as the global name, regardless of locale
   var global = currencies.map(
-      (currency) => new NumberFormat.currency(locale: 'en_US', name: currency));
+      (currency) => NumberFormat.currency(locale: 'en_US', name: currency));
   var expectedGlobal = currencies.map((curr) => curr ?? 'USD').toList();
 
-  testCurrencySymbolsFor(expectedGlobal, global, "global");
-  testCurrencySymbolsFor(expectedSimple, simple, "simple");
+  testCurrencySymbolsFor(expectedGlobal, global, 'global');
+  testCurrencySymbolsFor(expectedSimple, simple, 'simple');
 }
 
-testCurrencySymbolsFor(expected, formats, name) {
+void testCurrencySymbolsFor(expected, formats, name) {
   var amount = 1000000.32;
-  new Map<Object, NumberFormat>.fromIterables(expected, formats)
+  Map<Object, NumberFormat>.fromIterables(expected, formats)
       .forEach((expected, NumberFormat format) {
-    test("Test $name ${format.currencyName}", () {
+    test('Test $name ${format.currencyName}', () {
       // Allow for currencies with different fraction digits, e.g. CRC.
       var maxDigits = format.maximumFractionDigits;
       var rounded = maxDigits == 0 ? amount.round() : amount;
       var fractionDigits = (amount - rounded) < 0.00001 ? '.32' : '';
       var formatted = format.format(rounded);
-      expect(formatted, "${expected}1,000,000$fractionDigits");
+      expect(formatted, '${expected}1,000,000$fractionDigits');
       var parsed = format.parse(formatted);
       expect(parsed, rounded);
     });
diff --git a/test/number_format_vm_test.dart b/test/number_format_vm_test.dart
index 4e383e9..8c04b58 100644
--- a/test/number_format_vm_test.dart
+++ b/test/number_format_vm_test.dart
@@ -4,7 +4,7 @@
 
 /// Number tests for the VM - includes numbers that can only be compiled for the
 /// VM.
-@TestOn("vm")
+@TestOn('vm')
 library number_format_vm_test;
 
 import 'package:test/test.dart';
@@ -12,10 +12,10 @@
 
 /// Test numbers that won't work in Javascript because they're too big.
 var testNumbersOnlyForTheVM = {
-  "9,000,000,000,000,000,000": 9000000000000000000,
-  "9,223,372,036,854,775,807": 9223372036854775807
+  '9,000,000,000,000,000,000': 9000000000000000000,
+  '9,223,372,036,854,775,807': 9223372036854775807
 };
 
-main() {
+void main() {
   core.runTests(core.testNumbers..addAll(testNumbersOnlyForTheVM));
 }
diff --git a/test/number_format_web_test.dart b/test/number_format_web_test.dart
index c626a4e..86db381 100644
--- a/test/number_format_web_test.dart
+++ b/test/number_format_web_test.dart
@@ -4,12 +4,12 @@
 
 /// Number format tests for the web - excludes numbers too big to compile for
 /// the web.
-@TestOn("browser")
+@TestOn('browser')
 library number_format_web_test;
 
 import 'package:test/test.dart';
 import 'number_format_test_core.dart' as core;
 
-main() {
+void main() {
   core.runTests(core.testNumbers);
 }
diff --git a/test/number_test_data.dart b/test/number_test_data.dart
index 981b289..7a0b60c 100644
--- a/test/number_test_data.dart
+++ b/test/number_test_data.dart
@@ -7,6 +7,9 @@
 /// DO NOT EDIT. This file is autogenerated from ICU data.
 /// File generated from CLDR ver. 35.0
 
+// MANUAL EDIT TO SUPPRESS WARNINGS IN GENERATED CODE
+// ignore_for_file: prefer_single_quotes
+
 library number_test_data;
 
 var numberTestData = const [
diff --git a/test/plural_test.dart b/test/plural_test.dart
index 9ab718e..5118064 100644
--- a/test/plural_test.dart
+++ b/test/plural_test.dart
@@ -160,7 +160,7 @@
 25:Other
 ''';
 
-plural(n, locale) => Intl.plural(n,
+String plural(n, locale) => Intl.plural(n,
     locale: locale,
     name: 'plural',
     desc: 'A simple plural test case',
@@ -172,7 +172,7 @@
     many: '$n:Many',
     other: '$n:Other');
 
-pluralNoZero(n, locale) => Intl.plural(n,
+String pluralNoZero(n, locale) => Intl.plural(n,
     locale: locale,
     name: 'plural',
     desc: 'A simple plural test case',
@@ -183,20 +183,20 @@
     many: '$n:Many',
     other: '$n:Other');
 
-main() {
+void main() {
   verify(expectedRu, 'ru', plural);
   verify(expectedRu, 'ru_RU', plural);
   verify(expectedEn, 'en', plural);
   verify(expectedRo, 'ro', pluralNoZero);
   verify(expectedSr, 'sr', pluralNoZero);
 
-  test("Check null howMany", () {
-    expect(plural(0, null), "0:Zero");
+  test('Check null howMany', () {
+    expect(plural(0, null), '0:Zero');
     expect(() => plural(null, null), throwsArgumentError);
-    expect(() => plural(null, "ru"), throwsArgumentError);
+    expect(() => plural(null, 'ru'), throwsArgumentError);
   });
 
-  verify_with_precision('1 dollar', 'en', 1, 0);
+  verifyWithPrecision('1 dollar', 'en', 1, 0);
   // This would not work in back-compatibility for one vs. =1 in plurals,
   // because of this test in intl.dart:
   //    if (howMany == 1 && one != null) return one;
@@ -204,14 +204,14 @@
   // test below requires the result to be 'other'
   // verify_with_precision('1.00 dollars', 'en', 1, 2);
 
-  verify_with_precision('1 dollar', 'en', 1.2, 0);
-  verify_with_precision('1.20 dollars', 'en', 1.2, 2);
+  verifyWithPrecision('1 dollar', 'en', 1.2, 0);
+  verifyWithPrecision('1.20 dollars', 'en', 1.2, 2);
 
-  verify_with_precision('3 dollars', 'en', 3.14, 0);
-  verify_with_precision('3.14 dollars', 'en', 3.14, 2);
+  verifyWithPrecision('3 dollars', 'en', 3.14, 0);
+  verifyWithPrecision('3.14 dollars', 'en', 3.14, 2);
 }
 
-verify(String expectedValues, String locale, pluralFunction) {
+void verify(String expectedValues, String locale, pluralFunction) {
   var lines = expectedValues.split('\n').where((x) => x.isNotEmpty).toList();
   for (var i = 0; i < lines.length; i++) {
     test(lines[i], () {
@@ -221,7 +221,7 @@
   }
 }
 
-verify_with_precision(String expected, String locale, num n, int precision) {
+void verifyWithPrecision(String expected, String locale, num n, int precision) {
   test('verify_with_precision(howMany: $n, precision: $precision)', () {
     var nString = n.toStringAsFixed(precision);
     var actual = Intl.plural(n,
diff --git a/test/scorbeysund_timezone_test.dart b/test/scorbeysund_timezone_test.dart
index 127dc1d..873b75d 100644
--- a/test/scorbeysund_timezone_test.dart
+++ b/test/scorbeysund_timezone_test.dart
@@ -17,6 +17,6 @@
 import 'package:test/test.dart';
 import 'timezone_test_core.dart';
 
-main() {
+void main() {
   testTimezone('America/Scoresbysund', expectedUtcOffset: -1);
 }
diff --git a/test/timezone_local_even_test_helper.dart b/test/timezone_local_even_test_helper.dart
index cd06423..7df4ea6 100644
--- a/test/timezone_local_even_test_helper.dart
+++ b/test/timezone_local_even_test_helper.dart
@@ -9,19 +9,20 @@
 
 import 'dart:io';
 
-import 'date_time_format_test_stub.dart';
 import 'package:intl/date_symbol_data_local.dart';
 import 'package:test/test.dart';
 
-main() {
+import 'date_time_format_test_stub.dart';
+
+void main() {
   var tzOffset = Platform.environment['EXPECTED_TZ_OFFSET_FOR_TEST'];
   var timezoneName = Platform.environment['TZ'];
   if (tzOffset != null) {
-    test("Actually running in the correct time zone: $timezoneName", () {
+    test('Actually running in the correct time zone: $timezoneName', () {
       // Pick a constant Date so that the offset is known.
-      var d = new DateTime(2012, 1, 1, 7, 6, 5);
-      print("Time zone offset is ${d.timeZoneOffset.inHours}");
-      print("Time zone name is ${d.timeZoneName}");
+      var d = DateTime(2012, 1, 1, 7, 6, 5);
+      print('Time zone offset is ${d.timeZoneOffset.inHours}');
+      print('Time zone name is ${d.timeZoneName}');
       expect(tzOffset, '${d.timeZoneOffset.inHours}');
     });
   }
diff --git a/test/timezone_test_core.dart b/test/timezone_test_core.dart
index 6b02564..14f3188 100644
--- a/test/timezone_test_core.dart
+++ b/test/timezone_test_core.dart
@@ -3,9 +3,9 @@
 // BSD-style license that can be found in the LICENSE file.
 
 /// Test date formatting and parsing while the system time zone is set.
-import 'package:test/test.dart';
-import 'dart:io';
 import 'dart:convert';
+import 'dart:io';
+import 'package:test/test.dart';
 
 /// The VM arguments we were given, most importantly package-root.
 final vmArgs = Platform.executableArguments;
@@ -15,8 +15,8 @@
 /// Test for a particular timezone. In order to verify that we are in fact
 /// running in that time zone, verify that the DateTime offset is one of the
 /// expected values.
-testTimezone(String timezoneName, {int expectedUtcOffset}) {
-  // Define the environment variable "PACKAGE_DIR=<directory>" to indicate the
+void testTimezone(String timezoneName, {int expectedUtcOffset}) {
+  // Define the environment variable 'PACKAGE_DIR=<directory>' to indicate the
   // root of the Intl package. If it is not provided, we assume that the root of
   // the Intl package is the current directory.
   var packageDir = Platform.environment['PACKAGE_DIR'];
@@ -24,8 +24,8 @@
   var fileToSpawn =
       packageDir == null ? packageRelative : '$packageDir/$packageRelative';
 
-  test("Run tests in $timezoneName time zone", () async {
-    List<String> args = []
+  test('Run tests in $timezoneName time zone', () async {
+    var args = <String>[]
       ..addAll(vmArgs)
       ..add(fileToSpawn);
     var environment = <String, String>{'TZ': timezoneName};
@@ -33,18 +33,18 @@
       environment['EXPECTED_TZ_OFFSET_FOR_TEST'] = '$expectedUtcOffset';
     }
     var result = await Process.run(dart, args,
-        stdoutEncoding: new Utf8Codec(),
-        stderrEncoding: new Utf8Codec(),
+        stdoutEncoding: const Utf8Codec(),
+        stderrEncoding: const Utf8Codec(),
         includeParentEnvironment: true,
         environment: environment);
     // Because the actual tests are run in a spawned parocess their output isn't
     // directly visible here. To debug, it's necessary to look at the output of
     // that test, so we print it here for convenience.
-    print("Spawning test to run in the $timezoneName time zone. Stderr is:");
+    print('Spawning test to run in the $timezoneName time zone. Stderr is:');
     print(result.stderr);
-    print("Spawned test in $timezoneName time zone has Stdout:");
+    print('Spawned test in $timezoneName time zone has Stdout:');
     print(result.stdout);
     expect(result.exitCode, 0,
-        reason: "Spawned test failed. See the test log from stderr to debug");
+        reason: 'Spawned test failed. See the test log from stderr to debug');
   }, testOn: 'linux && vm');
 }
diff --git a/test/utc_timezone_test.dart b/test/utc_timezone_test.dart
index 43d6fb5..7c7d494 100644
--- a/test/utc_timezone_test.dart
+++ b/test/utc_timezone_test.dart
@@ -14,6 +14,6 @@
 import 'package:test/test.dart';
 import 'timezone_test_core.dart';
 
-main() {
+void main() {
   testTimezone('UTC', expectedUtcOffset: 0);
 }
diff --git a/tool/generate_locale_data_files.dart b/tool/generate_locale_data_files.dart
index 498d405..2f6a575 100644
--- a/tool/generate_locale_data_files.dart
+++ b/tool/generate_locale_data_files.dart
@@ -6,27 +6,26 @@
 /// are locale names and write it into individual JSON files named by locale.
 /// This should be run any time the locale data changes.
 ///
-/// The files are written under "data/dates", in two subdirectories, "symbols"
-/// and "patterns". In "data/dates" it will also generate "locale_list.dart",
+/// The files are written under 'data/dates', in two subdirectories, 'symbols'
+/// and 'patterns'. In 'data/dates' it will also generate 'locale_list.dart',
 /// which is sourced by the date_symbol_data... files.
-
+import 'dart:convert';
+import 'dart:io';
 import 'package:intl/date_symbol_data_local.dart';
 import 'package:intl/date_time_patterns.dart';
 import 'package:intl/intl.dart';
-import 'dart:convert';
-import 'dart:io';
-import '../test/data_directory.dart';
 import 'package:path/path.dart' as path;
+import '../test/data_directory.dart';
 
-main() {
-  initializeDateFormatting("en_IGNORED", null);
+void main() {
+  initializeDateFormatting('en_IGNORED', null);
   writeSymbolData();
   writePatternData();
   writeLocaleList();
 }
 
 void writeLocaleList() {
-  var file = new File(path.join(dataDirectory, 'locale_list.dart'));
+  var file = File(path.join(dataDirectory, 'locale_list.dart'));
   var output = file.openWrite();
   output.write(
       '// Copyright (c) 2012, the Dart project authors.  Please see the '
@@ -35,42 +34,40 @@
       ' LICENSE file.\n\n'
       '/// Hard-coded list of all available locales for dates.\n');
   output.write('final availableLocalesForDateFormatting = const [');
-  List<String> allLocales = DateFormat.allLocalesWithSymbols();
-  allLocales.forEach((locale) {
-    output.write('"$locale"');
+  var allLocales = DateFormat.allLocalesWithSymbols();
+  for (var locale in allLocales) {
+    output.write("'$locale'");
     if (locale == allLocales.last) {
       output.write('];');
     } else {
       output.write(',\n    ');
     }
-  });
+  }
   output.close();
 }
 
 void writeSymbolData() {
-  dateTimeSymbolMap()
-      .forEach((locale, symbols) => writeSymbols(locale, symbols));
+  dateTimeSymbolMap().forEach(writeSymbols);
 }
 
 void writePatternData() {
-  dateTimePatternMap()
-      .forEach((locale, patterns) => writePatterns(locale, patterns));
+  dateTimePatternMap().forEach(writePatterns);
 }
 
 void writeSymbols(locale, symbols) {
-  var file = new File(path.join(dataDirectory, 'symbols', '${locale}.json'));
+  var file = File(path.join(dataDirectory, 'symbols', '$locale.json'));
   var output = file.openWrite();
   writeToJSON(symbols, output);
   output.close();
 }
 
 void writePatterns(locale, patterns) {
-  var file = new File(path.join(dataDirectory, 'patterns', '${locale}.json'));
+  var file = File(path.join(dataDirectory, 'patterns', '$locale.json'));
   file.openWrite()
-    ..write(new JsonCodec().encode(patterns))
+    ..write(json.encode(patterns))
     ..close();
 }
 
 void writeToJSON(dynamic data, IOSink out) {
-  out.write(new JsonCodec().encode(data.serializeToMap()));
+  out.write(json.encode(data.serializeToMap()));
 }