Make it strong mode clean.

lib/command_runner.dart

 // Copyright (c) 2014, 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.
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:math' as math;
 
 import 'src/arg_parser.dart';
 import 'src/arg_results.dart';
@@ skipping 22 matching lines @@
   /// Generates a string displaying usage information for the executable.
   ///
   /// This includes usage for the global arguments as well as a list of
   /// top-level commands.
   String get usage => "$description\n\n$_usageWithoutDescription";
 
   /// An optional footer for [usage].
   ///
   /// If a subclass overrides this to return a string, it will automatically be
   /// added to the end of [usage].
-  final String usageFooter = null;
+  String get usageFooter => null;

[nweiz, 2016/03/02 23:58:54]

I thought we agreed to stop arguing about finals versus getters for values like
this.

[Bob Nystrom, 2016/03/03 00:19:08]

This is being overridden in subclasses, so making it a getter avoids the error
for overriding a field.

 
   /// Returns [usage] with [description] removed from the beginning.
   String get _usageWithoutDescription {
     var usage = '''
 Usage: $invocation
 
 Global options:
 ${argParser.usage}
 
 ${_getCommandUsage(_commands)}
 
 Run "$executableName help <command>" for more information about a command.''';
 
     if (usageFooter != null) usage += "\n$usageFooter";
     return usage;
   }
 
   /// An unmodifiable view of all top-level commands defined for this runner.
   Map<String, Command> get commands => new UnmodifiableMapView(_commands);
-  final _commands = new Map<String, Command>();
+  final _commands = <String, Command>{};
 
   /// The top-level argument parser.
   ///
   /// Global options should be registered with this parser; they'll end up
   /// available via [Command.globalResults]. Commands should be registered with
   /// [addCommand] rather than directly on the parser.
   final argParser = new ArgParser();
 
   CommandRunner(this.executableName, this.description) {
     argParser.addFlag('help',
@@ skipping 48 matching lines @@
   /// This is notionally a protected method. It may be overridden or called from
   /// subclasses, but it shouldn't be called externally.
   ///
   /// It's useful to override this to handle global flags and/or wrap the entire
   /// command in a block. For example, you might handle the `--verbose` flag
   /// here to enable verbose logging before running the command.
   Future runCommand(ArgResults topLevelResults) {
     return new Future.sync(() {
       var argResults = topLevelResults;
       var commands = _commands;
-      var command;
+      Command command;
       var commandString = executableName;
 
       while (commands.isNotEmpty) {
         if (argResults.command == null) {
           if (argResults.rest.isEmpty) {
             if (command == null) {
               // No top-level command was chosen.
               printUsage();
               return new Future.value();
             }
@@ skipping 105 matching lines @@
   /// Generates a string displaying usage information for this command.
   ///
   /// This includes usage for the command's arguments as well as a list of
   /// subcommands, if there are any.
   String get usage => "$description\n\n$_usageWithoutDescription";
 
   /// An optional footer for [usage].
   ///
   /// If a subclass overrides this to return a string, it will automatically be
   /// added to the end of [usage].
-  final String usageFooter = null;
+  String get usageFooter => null;
 
   /// Returns [usage] with [description] removed from the beginning.
   String get _usageWithoutDescription {
     var buffer = new StringBuffer()
       ..writeln('Usage: $invocation')
       ..writeln(argParser.usage);
 
     if (_subcommands.isNotEmpty) {
       buffer.writeln();
       buffer.writeln(_getCommandUsage(_subcommands, isSubcommand: true));
     }
 
     buffer.writeln();
     buffer.write('Run "${runner.executableName} help" to see global options.');
 
     if (usageFooter != null) {
       buffer.writeln();
       buffer.write(usageFooter);
     }
 
     return buffer.toString();
   }
 
   /// An unmodifiable view of all sublevel commands of this command.
   Map<String, Command> get subcommands => new UnmodifiableMapView(_subcommands);
-  final _subcommands = new Map<String, Command>();
+  final _subcommands = <String, Command>{};
 
   /// Whether or not this command should be hidden from help listings.
   ///
   /// This is intended to be overridden by commands that want to mark themselves
   /// hidden.
   ///
   /// By default, leaf commands are always visible. Branch commands are visible
   /// as long as any of their leaf commands are visible.
   bool get hidden {
     // Leaf commands are visible by default.
     if (_subcommands.isEmpty) return false;
 
     // Otherwise, a command is hidden if all of its subcommands are.
     return _subcommands.values.every((subcommand) => subcommand.hidden);
   }
 
   /// Whether or not this command takes positional arguments in addition to
   /// options.
   ///
   /// If false, [CommandRunner.run] will throw a [UsageException] if arguments
   /// are provided. Defaults to true.
   ///
   /// This is intended to be overridden by commands that don't want to receive
   /// arguments. It has no effect for branch commands.
-  final takesArguments = true;
+  bool get takesArguments => true;
 
   /// Alternate names for this command.
   ///
   /// These names won't be used in the documentation, but they will work when
   /// invoked on the command line.
   ///
   /// This is intended to be overridden.
-  final aliases = const <String>[];
+  List<String> get aliases => const [];
 
   Command() {
     argParser.addFlag('help',
         abbr: 'h', negatable: false, help: 'Print this usage information.');
   }
 
   /// Runs this command.
   ///
   /// If this returns a [Future], [CommandRunner.run] won't complete until the
   /// returned [Future] does. Otherwise, the return value is ignored.
@@ skipping 49 matching lines @@
 
     for (var line in lines.skip(1)) {
       buffer.writeln();
       buffer.write(' ' * (length + 5));
       buffer.write(line);
     }
   }
 
   return buffer.toString();
 }