diff --git a/packages/flutter_tools/lib/src/android/adb.dart b/packages/flutter_tools/lib/src/android/adb.dart
index 9d35daa2..afaf6a8 100644
--- a/packages/flutter_tools/lib/src/android/adb.dart
+++ b/packages/flutter_tools/lib/src/android/adb.dart
@@ -214,6 +214,7 @@
   /// Device product; can be null. `peregrine_retus`, `nakasi`
   String get productID => _info['product'];
 
+  @override
   bool operator ==(dynamic other) {
     if (identical(this, other))
       return true;
@@ -223,8 +224,10 @@
     return id == typedOther.id;
   }
 
+  @override
   int get hashCode => id.hashCode;
 
+  @override
   String toString() {
     if (modelID == null) {
       return '$id ($status)';
diff --git a/packages/flutter_tools/lib/src/android/android_device.dart b/packages/flutter_tools/lib/src/android/android_device.dart
index b1b1d50..bf9515d 100644
--- a/packages/flutter_tools/lib/src/android/android_device.dart
+++ b/packages/flutter_tools/lib/src/android/android_device.dart
@@ -32,7 +32,10 @@
 class AndroidDevices extends PollingDeviceDiscovery {
   AndroidDevices() : super('AndroidDevices');
 
+  @override
   bool get supportsPlatform => true;
+
+  @override
   List<Device> pollingGetDevices() => getAdbDevices();
 }
 
@@ -50,6 +53,7 @@
 
   bool _isLocalEmulator;
 
+  @override
   bool get isLocalEmulator {
     if (_isLocalEmulator == null) {
       // http://developer.android.com/ndk/guides/abis.html (x86, armeabi-v7a, ...)
@@ -152,6 +156,7 @@
     return shaFile.existsSync() ? shaFile.readAsStringSync() : '';
   }
 
+  @override
   String get name => modelID;
 
   @override
@@ -279,6 +284,7 @@
     }
   }
 
+  @override
   Future<bool> stopApp(ApplicationPackage app) {
     List<String> command = adbCommandForDevice(<String>['shell', 'am', 'force-stop', app.id]);
     return runCommandAndStreamOutput(command).then((int exitCode) => exitCode == 0);
@@ -288,16 +294,19 @@
   @override
   TargetPlatform get platform => TargetPlatform.android_arm;
 
+  @override
   void clearLogs() {
     runSync(adbCommandForDevice(<String>['logcat', '-c']));
   }
 
+  @override
   DeviceLogReader get logReader {
     if (_logReader == null)
       _logReader = new _AdbLogReader(this);
     return _logReader;
   }
 
+  @override
   DevicePortForwarder get portForwarder {
     if (_portForwarder == null)
       _portForwarder = new _AndroidDevicePortForwarder(this);
@@ -382,6 +391,7 @@
     return null;
   }
 
+  @override
   bool isSupported() => true;
 
   Future<bool> refreshSnapshot(AndroidApk apk, String snapshotPath) async {
@@ -488,14 +498,19 @@
   StreamSubscription<String> _stdoutSubscription;
   StreamSubscription<String> _stderrSubscription;
 
+  @override
   Stream<String> get lines => _linesStreamController.stream;
 
+  @override
   String get name => device.name;
 
+  @override
   bool get isReading => _process != null;
 
+  @override
   Future<int> get finished => _process != null ? _process.exitCode : new Future<int>.value(0);
 
+  @override
   Future<Null> start() async {
     if (_process != null)
       throw new StateError('_AdbLogReader must be stopped before it can be started.');
@@ -516,6 +531,7 @@
     _process.exitCode.then(_onExit);
   }
 
+  @override
   Future<Null> stop() async {
     if (_process == null)
       throw new StateError('_AdbLogReader must be started before it can be stopped.');
@@ -540,8 +556,10 @@
     _linesStreamController.add(line);
   }
 
+  @override
   int get hashCode => name.hashCode;
 
+  @override
   bool operator ==(dynamic other) {
     if (identical(this, other))
       return true;
@@ -560,6 +578,7 @@
     return int.parse(portString.trim(), onError: (_) => null);
   }
 
+  @override
   List<ForwardedPort> get forwardedPorts {
     final List<ForwardedPort> ports = <ForwardedPort>[];
 
@@ -591,6 +610,7 @@
     return ports;
   }
 
+  @override
   Future<int> forward(int devicePort, { int hostPort }) async {
     if ((hostPort == null) || (hostPort == 0)) {
       // Auto select host port.
@@ -604,6 +624,7 @@
     return hostPort;
   }
 
+  @override
   Future<Null> unforward(ForwardedPort forwardedPort) async {
     runCheckedSync(device.adbCommandForDevice(
       <String>['forward', '--remove', 'tcp:${forwardedPort.hostPort}']
diff --git a/packages/flutter_tools/lib/src/android/android_sdk.dart b/packages/flutter_tools/lib/src/android/android_sdk.dart
index 819f64f..0e605f4 100644
--- a/packages/flutter_tools/lib/src/android/android_sdk.dart
+++ b/packages/flutter_tools/lib/src/android/android_sdk.dart
@@ -175,6 +175,7 @@
     _latestVersion = _sdkVersions.isEmpty ? null : _sdkVersions.last;
   }
 
+  @override
   String toString() => 'AndroidSdk: $directory';
 }
 
@@ -211,10 +212,12 @@
     return path.join(sdk.directory, 'build-tools', buildToolsVersion, binaryName);
   }
 
+  @override
   int compareTo(AndroidSdkVersion other) {
     return sdkLevel - other.sdkLevel;
   }
 
+  @override
   String toString() => '[${sdk.directory}, SDK version $sdkLevel, build-tools $buildToolsVersion]';
 
   bool _exists(String path, { bool complain: false }) {
diff --git a/packages/flutter_tools/lib/src/android/android_workflow.dart b/packages/flutter_tools/lib/src/android/android_workflow.dart
index 21a912b..9bccb0a 100644
--- a/packages/flutter_tools/lib/src/android/android_workflow.dart
+++ b/packages/flutter_tools/lib/src/android/android_workflow.dart
@@ -7,14 +7,19 @@
 import 'android_sdk.dart';
 
 class AndroidWorkflow extends Workflow {
+  @override
   String get label => 'Android toolchain';
 
+  @override
   bool get appliesToHostPlatform => true;
 
+  @override
   bool get canListDevices => getAdbPath(androidSdk) != null;
 
+  @override
   bool get canLaunchDevices => androidSdk != null && androidSdk.validateSdkWellFormed(complain: false);
 
+  @override
   ValidationResult validate() {
     Validator androidValidator = new Validator(
       label,
@@ -36,5 +41,6 @@
     return androidValidator.validate();
   }
 
+  @override
   void diagnose() => validate().print();
 }
diff --git a/packages/flutter_tools/lib/src/application_package.dart b/packages/flutter_tools/lib/src/application_package.dart
index 1b233b6..d376905 100644
--- a/packages/flutter_tools/lib/src/application_package.dart
+++ b/packages/flutter_tools/lib/src/application_package.dart
@@ -31,6 +31,7 @@
 
   String get displayName => name;
 
+  @override
   String toString() => displayName;
 }
 
@@ -95,6 +96,7 @@
     return new IOSApp(iosProjectDir: projectDir, iosProjectBundleId: value);
   }
 
+  @override
   String get displayName => id;
 }
 
diff --git a/packages/flutter_tools/lib/src/base/logger.dart b/packages/flutter_tools/lib/src/base/logger.dart
index 46a3791..7f2842c 100644
--- a/packages/flutter_tools/lib/src/base/logger.dart
+++ b/packages/flutter_tools/lib/src/base/logger.dart
@@ -26,22 +26,28 @@
 }
 
 class StdoutLogger implements Logger {
+  @override
   bool get isVerbose => false;
 
+  @override
   void printError(String message, [StackTrace stackTrace]) {
     stderr.writeln(message);
     if (stackTrace != null)
       stderr.writeln(stackTrace);
   }
 
+  @override
   void printStatus(String message) => print(message);
 
+  @override
   void printTrace(String message) { }
 
+  @override
   void flush() { }
 }
 
 class BufferLogger implements Logger {
+  @override
   bool get isVerbose => false;
 
   StringBuffer _error = new StringBuffer();
@@ -52,33 +58,44 @@
   String get statusText => _status.toString();
   String get traceText => _trace.toString();
 
+  @override
   void printError(String message, [StackTrace stackTrace]) => _error.writeln(message);
+
+  @override
   void printStatus(String message) => _status.writeln(message);
+
+  @override
   void printTrace(String message) => _trace.writeln(message);
 
+  @override
   void flush() { }
 }
 
 class VerboseLogger implements Logger {
   _LogMessage lastMessage;
 
+  @override
   bool get isVerbose => true;
 
+  @override
   void printError(String message, [StackTrace stackTrace]) {
     _emit();
     lastMessage = new _LogMessage(_LogType.error, message, stackTrace);
   }
 
+  @override
   void printStatus(String message) {
     _emit();
     lastMessage = new _LogMessage(_LogType.status, message);
   }
 
+  @override
   void printTrace(String message) {
     _emit();
     lastMessage = new _LogMessage(_LogType.trace, message);
   }
 
+  @override
   void flush() => _emit();
 
   void _emit() {
diff --git a/packages/flutter_tools/lib/src/base/os.dart b/packages/flutter_tools/lib/src/base/os.dart
index 973b421..99be5a8 100644
--- a/packages/flutter_tools/lib/src/base/os.dart
+++ b/packages/flutter_tools/lib/src/base/os.dart
@@ -38,12 +38,14 @@
 class _PosixUtils extends OperatingSystemUtils {
   _PosixUtils() : super._private();
 
+  @override
   ProcessResult makeExecutable(File file) {
     return Process.runSync('chmod', ['u+x', file.path]);
   }
 
   /// Return the path (with symlinks resolved) to the given executable, or `null`
   /// if `which` was not able to locate the binary.
+  @override
   File which(String execName) {
     ProcessResult result = Process.runSync('which', <String>[execName]);
     if (result.exitCode != 0)
@@ -57,10 +59,12 @@
   _WindowsUtils() : super._private();
 
   // This is a no-op.
+  @override
   ProcessResult makeExecutable(File file) {
     return new ProcessResult(0, 0, null, null);
   }
 
+  @override
   File which(String execName) {
     throw new UnimplementedError('_WindowsUtils.which');
   }
diff --git a/packages/flutter_tools/lib/src/base/process.dart b/packages/flutter_tools/lib/src/base/process.dart
index db37581..25b8bb3 100644
--- a/packages/flutter_tools/lib/src/base/process.dart
+++ b/packages/flutter_tools/lib/src/base/process.dart
@@ -136,8 +136,12 @@
 }
 
 class ProcessExit implements Exception {
-  final int exitCode;
   ProcessExit(this.exitCode);
+
+  final int exitCode;
+
   String get message => 'ProcessExit: $exitCode';
+
+  @override
   String toString() => message;
 }
diff --git a/packages/flutter_tools/lib/src/commands/analyze.dart b/packages/flutter_tools/lib/src/commands/analyze.dart
index f1326c3..b0a2ab3 100644
--- a/packages/flutter_tools/lib/src/commands/analyze.dart
+++ b/packages/flutter_tools/lib/src/commands/analyze.dart
@@ -118,8 +118,13 @@
     argParser.addFlag('watch', help: 'Run analysis continuously, watching the filesystem for changes.', negatable: false);
   }
 
+  @override
   String get name => 'analyze';
+
+  @override
   String get description => 'Analyze the project\'s Dart code.';
+
+  @override
   bool get requiresProjectRoot => false;
 
   bool get isFlutterRepo {
@@ -760,6 +765,7 @@
   int get startColumn => json['location']['startColumn'];
   int get offset => json['location']['offset'];
 
+  @override
   int compareTo(AnalysisError other) {
     // Sort in order of file path, error location, severity, and message.
     if (file != other.file)
@@ -775,6 +781,7 @@
     return message.compareTo(other.message);
   }
 
+  @override
   String toString() {
     String relativePath = path.relative(file);
     return '${severity.toLowerCase().padLeft(7)} • $message • $relativePath:$startLine:$startColumn';
diff --git a/packages/flutter_tools/lib/src/commands/apk.dart b/packages/flutter_tools/lib/src/commands/apk.dart
index d6dc01b..6b13c7e 100644
--- a/packages/flutter_tools/lib/src/commands/apk.dart
+++ b/packages/flutter_tools/lib/src/commands/apk.dart
@@ -136,7 +136,10 @@
 }
 
 class ApkCommand extends FlutterCommand {
+  @override
   final String name = 'apk';
+
+  @override
   final String description = 'Build an Android APK package.';
 
   ApkCommand() {
diff --git a/packages/flutter_tools/lib/src/commands/build.dart b/packages/flutter_tools/lib/src/commands/build.dart
index 04d80ce..54a5447 100644
--- a/packages/flutter_tools/lib/src/commands/build.dart
+++ b/packages/flutter_tools/lib/src/commands/build.dart
@@ -11,7 +11,10 @@
 import '../toolchain.dart';
 
 class BuildCommand extends FlutterCommand {
+  @override
   final String name = 'build';
+
+  @override
   final String description = 'Package your Flutter app into an FLX.';
 
   BuildCommand() {
@@ -42,6 +45,7 @@
     return await super.run();
   }
 
+  @override
   Future<int> runInProject() async {
     String compilerPath = argResults['compiler'];
 
diff --git a/packages/flutter_tools/lib/src/commands/create.dart b/packages/flutter_tools/lib/src/commands/create.dart
index 4024580..0610177 100644
--- a/packages/flutter_tools/lib/src/commands/create.dart
+++ b/packages/flutter_tools/lib/src/commands/create.dart
@@ -16,8 +16,13 @@
 import '../template.dart';
 
 class CreateCommand extends Command {
+  @override
   final String name = 'create';
+
+  @override
   final String description = 'Create a new Flutter project.';
+
+  @override
   final List<String> aliases = <String>['init'];
 
   CreateCommand() {
@@ -38,6 +43,7 @@
     );
   }
 
+  @override
   String get invocation => "${runner.executableName} $name <output directory>";
 
   @override
diff --git a/packages/flutter_tools/lib/src/commands/daemon.dart b/packages/flutter_tools/lib/src/commands/daemon.dart
index e2a477a..4f205e4 100644
--- a/packages/flutter_tools/lib/src/commands/daemon.dart
+++ b/packages/flutter_tools/lib/src/commands/daemon.dart
@@ -28,14 +28,20 @@
 class DaemonCommand extends FlutterCommand {
   DaemonCommand({ bool hideCommand: false }) : _hideCommand = hideCommand;
 
+  @override
   final String name = 'daemon';
+
+  @override
   final String description = 'Run a persistent, JSON-RPC based server to communicate with devices.';
   final bool _hideCommand;
 
+  @override
   bool get requiresProjectRoot => false;
 
+  @override
   bool get hidden => _hideCommand;
 
+  @override
   Future<int> runInProject() {
     printStatus('Starting device daemon...');
 
@@ -155,6 +161,7 @@
 
   FlutterCommand get command => daemon.daemonCommand;
 
+  @override
   String toString() => name;
 
   void handleCommand(String command, dynamic id, dynamic args) {
@@ -220,6 +227,7 @@
     return new Future<Null>.value();
   }
 
+  @override
   void dispose() {
     _subscription?.cancel();
   }
@@ -371,6 +379,7 @@
     return new Future<Null>.value();
   }
 
+  @override
   void dispose() {
     for (PollingDeviceDiscovery discoverer in _discoverers) {
       discoverer.dispose();
@@ -410,14 +419,17 @@
 
   Stream<LogMessage> get onMessage => _messageController.stream;
 
+  @override
   void printError(String message, [StackTrace stackTrace]) {
     _messageController.add(new LogMessage('error', message, stackTrace));
   }
 
+  @override
   void printStatus(String message) {
     _messageController.add(new LogMessage('status', message));
   }
 
+  @override
   void printTrace(String message) {
     // This is a lot of traffic to send over the wire.
   }
diff --git a/packages/flutter_tools/lib/src/commands/devices.dart b/packages/flutter_tools/lib/src/commands/devices.dart
index 1f3b071..dd94309 100644
--- a/packages/flutter_tools/lib/src/commands/devices.dart
+++ b/packages/flutter_tools/lib/src/commands/devices.dart
@@ -10,12 +10,19 @@
 import '../runner/flutter_command.dart';
 
 class DevicesCommand extends FlutterCommand {
+  @override
   final String name = 'devices';
+
+  @override
   final String description = 'List all connected devices.';
+
+  @override
   final List<String> aliases = <String>['list'];
 
+  @override
   bool get requiresProjectRoot => false;
 
+  @override
   Future<int> runInProject() async {
     if (!doctor.canListAnything) {
       printError("Unable to locate a development device; please run 'flutter doctor' for "
diff --git a/packages/flutter_tools/lib/src/commands/doctor.dart b/packages/flutter_tools/lib/src/commands/doctor.dart
index dd30c60..188024d 100644
--- a/packages/flutter_tools/lib/src/commands/doctor.dart
+++ b/packages/flutter_tools/lib/src/commands/doctor.dart
@@ -10,11 +10,16 @@
 import '../runner/version.dart';
 
 class DoctorCommand extends FlutterCommand {
+  @override
   final String name = 'doctor';
+
+  @override
   final String description = 'Show information about the installed tooling.';
 
+  @override
   bool get requiresProjectRoot => false;
 
+  @override
   Future<int> runInProject() async {
     // general info
     String flutterRoot = ArtifactStore.flutterRoot;
diff --git a/packages/flutter_tools/lib/src/commands/drive.dart b/packages/flutter_tools/lib/src/commands/drive.dart
index 5cbbe6f..72e4e70 100644
--- a/packages/flutter_tools/lib/src/commands/drive.dart
+++ b/packages/flutter_tools/lib/src/commands/drive.dart
@@ -64,8 +64,13 @@
         help: 'Listen to the given port for a debug connection.');
   }
 
+  @override
   final String name = 'drive';
+
+  @override
   final String description = 'Runs Flutter Driver tests for the current project.';
+
+  @override
   final List<String> aliases = <String>['driver'];
 
   Device _device;
diff --git a/packages/flutter_tools/lib/src/commands/install.dart b/packages/flutter_tools/lib/src/commands/install.dart
index a801b22..3e68041 100644
--- a/packages/flutter_tools/lib/src/commands/install.dart
+++ b/packages/flutter_tools/lib/src/commands/install.dart
@@ -10,9 +10,13 @@
 import '../runner/flutter_command.dart';
 
 class InstallCommand extends FlutterCommand {
+  @override
   final String name = 'install';
+
+  @override
   final String description = 'Install a Flutter app on an attached device.';
 
+  @override
   bool get requiresDevice => true;
 
   @override
diff --git a/packages/flutter_tools/lib/src/commands/listen.dart b/packages/flutter_tools/lib/src/commands/listen.dart
index 14cc781..1550a08 100644
--- a/packages/flutter_tools/lib/src/commands/listen.dart
+++ b/packages/flutter_tools/lib/src/commands/listen.dart
@@ -10,9 +10,14 @@
 import 'run.dart';
 
 class ListenCommand extends RunCommandBase {
+  @override
   final String name = 'listen';
+
+  @override
   final String description =
     'Listen for changes to files and reload the running app (Android only).';
+
+  @override
   final String usageFooter =
     'By default, only listens to "./" and "./lib/". To listen to additional directories, list them on\n'
     'the command line.';
@@ -22,8 +27,10 @@
 
   ListenCommand({ this.singleRun: false });
 
+  @override
   bool get androidOnly => true;
 
+  @override
   bool get requiresDevice => true;
 
   @override
diff --git a/packages/flutter_tools/lib/src/commands/logs.dart b/packages/flutter_tools/lib/src/commands/logs.dart
index 9170c12..5190685 100644
--- a/packages/flutter_tools/lib/src/commands/logs.dart
+++ b/packages/flutter_tools/lib/src/commands/logs.dart
@@ -9,7 +9,10 @@
 import '../runner/flutter_command.dart';
 
 class LogsCommand extends FlutterCommand {
+  @override
   final String name = 'logs';
+
+  @override
   final String description = 'Show log output for running Flutter apps.';
 
   LogsCommand() {
@@ -20,10 +23,13 @@
     );
   }
 
+  @override
   bool get requiresProjectRoot => false;
 
+  @override
   bool get requiresDevice => true;
 
+  @override
   Future<int> runInProject() async {
     Device device = deviceForCommand;
 
diff --git a/packages/flutter_tools/lib/src/commands/refresh.dart b/packages/flutter_tools/lib/src/commands/refresh.dart
index 7f7ced0..1c4b54b 100644
--- a/packages/flutter_tools/lib/src/commands/refresh.dart
+++ b/packages/flutter_tools/lib/src/commands/refresh.dart
@@ -12,15 +12,20 @@
 import '../runner/flutter_command.dart';
 
 class RefreshCommand extends FlutterCommand {
+  @override
   final String name = 'refresh';
+
+  @override
   final String description = 'Build and deploy the Dart code in a Flutter app (Android only).';
 
   RefreshCommand() {
     addTargetOption();
   }
 
+  @override
   bool get androidOnly => true;
 
+  @override
   bool get requiresDevice => true;
 
   @override
diff --git a/packages/flutter_tools/lib/src/commands/run.dart b/packages/flutter_tools/lib/src/commands/run.dart
index 09f627e..eefe535 100644
--- a/packages/flutter_tools/lib/src/commands/run.dart
+++ b/packages/flutter_tools/lib/src/commands/run.dart
@@ -53,8 +53,13 @@
 }
 
 class RunCommand extends RunCommandBase {
+  @override
   final String name = 'run';
+
+  @override
   final String description = 'Run your Flutter app on an attached device.';
+
+  @override
   final List<String> aliases = <String>['start'];
 
   RunCommand() {
@@ -76,6 +81,7 @@
         help: 'Listen to the given port for a debug connection.');
   }
 
+  @override
   bool get requiresDevice => true;
 
   @override
diff --git a/packages/flutter_tools/lib/src/commands/run_mojo.dart b/packages/flutter_tools/lib/src/commands/run_mojo.dart
index 3f9bde4..d7e1642 100644
--- a/packages/flutter_tools/lib/src/commands/run_mojo.dart
+++ b/packages/flutter_tools/lib/src/commands/run_mojo.dart
@@ -18,7 +18,10 @@
 const String _kDefaultBundlePath = 'build/app.flx';
 
 class RunMojoCommand extends FlutterCommand {
+  @override
   final String name = 'run_mojo';
+
+  @override
   final String description = 'Run a Flutter app in mojo (from github.com/domokit/mojo).';
   final bool _hideCommand;
 
@@ -37,7 +40,10 @@
     argParser.addOption('devtools-path', help: 'Path to mojo devtools\' mojo_run command.');
   }
 
+  @override
   bool get requiresProjectRoot => false;
+
+  @override
   bool get hidden => _hideCommand;
 
   // TODO(abarth): Why not use path.absolute?
diff --git a/packages/flutter_tools/lib/src/commands/stop.dart b/packages/flutter_tools/lib/src/commands/stop.dart
index fd38f38..9a4ad86 100644
--- a/packages/flutter_tools/lib/src/commands/stop.dart
+++ b/packages/flutter_tools/lib/src/commands/stop.dart
@@ -10,9 +10,13 @@
 import '../runner/flutter_command.dart';
 
 class StopCommand extends FlutterCommand {
+  @override
   final String name = 'stop';
+
+  @override
   final String description = 'Stop your Flutter app on an attached device.';
 
+  @override
   bool get requiresDevice => true;
 
   @override
diff --git a/packages/flutter_tools/lib/src/commands/test.dart b/packages/flutter_tools/lib/src/commands/test.dart
index c50cece..50d1e8e 100644
--- a/packages/flutter_tools/lib/src/commands/test.dart
+++ b/packages/flutter_tools/lib/src/commands/test.dart
@@ -23,8 +23,13 @@
     );
   }
 
+  @override
   String get name => 'test';
+
+  @override
   String get description => 'Run Flutter unit tests for the current project (Linux only).';
+
+  @override
   bool get requiresProjectRoot => false;
 
   @override
diff --git a/packages/flutter_tools/lib/src/commands/trace.dart b/packages/flutter_tools/lib/src/commands/trace.dart
index 4387a60..fe6a54f 100644
--- a/packages/flutter_tools/lib/src/commands/trace.dart
+++ b/packages/flutter_tools/lib/src/commands/trace.dart
@@ -10,8 +10,13 @@
 import '../runner/flutter_command.dart';
 
 class TraceCommand extends FlutterCommand {
+  @override
   final String name = 'trace';
+
+  @override
   final String description = 'Start and stop tracing for a running Flutter app (Android only).';
+
+  @override
   final String usageFooter =
     '\`trace\` called with no arguments will automatically start tracing, delay a set amount of\n'
     'time (controlled by --duration), and stop tracing. To explicitly control tracing, call trace\n'
@@ -25,8 +30,10 @@
         defaultsTo: '10', abbr: 'd', help: 'Duration in seconds to trace.');
   }
 
+  @override
   bool get androidOnly => true;
 
+  @override
   bool get requiresDevice => true;
 
   @override
diff --git a/packages/flutter_tools/lib/src/commands/update_packages.dart b/packages/flutter_tools/lib/src/commands/update_packages.dart
index e89c3da..4f08273 100644
--- a/packages/flutter_tools/lib/src/commands/update_packages.dart
+++ b/packages/flutter_tools/lib/src/commands/update_packages.dart
@@ -32,12 +32,17 @@
     );
   }
 
+  @override
   final String name = 'update-packages';
+
+  @override
   final String description = 'Update the packages inside the Flutter repo.';
 
+  @override
   bool get hidden => _hideCommand;
   final bool _hideCommand;
 
+  @override
   bool get requiresProjectRoot => false;
 
   @override
diff --git a/packages/flutter_tools/lib/src/commands/upgrade.dart b/packages/flutter_tools/lib/src/commands/upgrade.dart
index fbe67ee..a4b327f 100644
--- a/packages/flutter_tools/lib/src/commands/upgrade.dart
+++ b/packages/flutter_tools/lib/src/commands/upgrade.dart
@@ -11,7 +11,10 @@
 import '../runner/version.dart';
 
 class UpgradeCommand extends FlutterCommand {
+  @override
   final String name = 'upgrade';
+
+  @override
   final String description = 'Upgrade your copy of Flutter.';
 
   @override
diff --git a/packages/flutter_tools/lib/src/device.dart b/packages/flutter_tools/lib/src/device.dart
index feacb2b..1764dc1 100644
--- a/packages/flutter_tools/lib/src/device.dart
+++ b/packages/flutter_tools/lib/src/device.dart
@@ -111,6 +111,7 @@
     _timer = null;
   }
 
+  @override
   List<Device> get devices {
     if (_items == null)
       _items = new ItemListNotifier<Device>.from(pollingGetDevices());
@@ -131,6 +132,7 @@
 
   void dispose() => stopPolling();
 
+  @override
   String toString() => '$name device discovery';
 }
 
@@ -189,8 +191,10 @@
   /// Stop an app package on the current device.
   Future<bool> stopApp(ApplicationPackage app);
 
+  @override
   int get hashCode => id.hashCode;
 
+  @override
   bool operator ==(dynamic other) {
     if (identical(this, other))
       return true;
@@ -199,6 +203,7 @@
     return id == other.id;
   }
 
+  @override
   String toString() => name;
 
   static void printDevices(List<Device> devices) {
@@ -225,6 +230,7 @@
   final int hostPort;
   final int devicePort;
 
+  @override
   String toString() => 'ForwardedPort HOST:$hostPort to DEVICE:$devicePort';
 }
 
@@ -266,8 +272,12 @@
   /// Completes when the log is finished.
   Future<int> get finished;
 
+  @override
   int get hashCode;
+
+  @override
   bool operator ==(dynamic other);
 
+  @override
   String toString() => name;
 }
diff --git a/packages/flutter_tools/lib/src/doctor.dart b/packages/flutter_tools/lib/src/doctor.dart
index cbd9b03..41c75cb 100644
--- a/packages/flutter_tools/lib/src/doctor.dart
+++ b/packages/flutter_tools/lib/src/doctor.dart
@@ -228,8 +228,10 @@
       : path.join(env['HOME'], '.atom');
   }
 
+  @override
   String get label => 'Atom development environment';
 
+  @override
   ValidationResult validate() {
     Validator atomValidator = new Validator(
       label,
@@ -263,5 +265,6 @@
     return atomValidator.validate();
   }
 
+  @override
   void diagnose() => validate().print();
 }
diff --git a/packages/flutter_tools/lib/src/ios/devices.dart b/packages/flutter_tools/lib/src/ios/devices.dart
index 6f91575..c7f84d3 100644
--- a/packages/flutter_tools/lib/src/ios/devices.dart
+++ b/packages/flutter_tools/lib/src/ios/devices.dart
@@ -25,7 +25,10 @@
 class IOSDevices extends PollingDeviceDiscovery {
   IOSDevices() : super('IOSDevices');
 
+  @override
   bool get supportsPlatform => Platform.isMacOS;
+
+  @override
   List<Device> pollingGetDevices() => IOSDevice.getAttachedDevices();
 }
 
@@ -62,14 +65,17 @@
   String _pusherPath;
   String get pusherPath => _pusherPath;
 
+  @override
   final String name;
 
   _IOSDeviceLogReader _logReader;
 
   _IOSDevicePortForwarder _portForwarder;
 
+  @override
   bool get isLocalEmulator => false;
 
+  @override
   bool get supportsStartPaused => false;
 
   static List<IOSDevice> getAttachedDevices([IOSDevice mockIOS]) {
@@ -226,6 +232,7 @@
   @override
   TargetPlatform get platform => TargetPlatform.ios_arm;
 
+  @override
   DeviceLogReader get logReader {
     if (_logReader == null)
       _logReader = new _IOSDeviceLogReader(this);
@@ -233,6 +240,7 @@
     return _logReader;
   }
 
+  @override
   DevicePortForwarder get portForwarder {
     if (_portForwarder == null)
       _portForwarder = new _IOSDevicePortForwarder(this);
@@ -240,6 +248,7 @@
     return _portForwarder;
   }
 
+  @override
   void clearLogs() {
   }
 }
@@ -256,16 +265,21 @@
   StreamSubscription<String> _stdoutSubscription;
   StreamSubscription<String> _stderrSubscription;
 
+  @override
   Stream<String> get lines => _linesStreamController.stream;
 
+  @override
   String get name => device.name;
 
+  @override
   bool get isReading => _process != null;
 
+  @override
   Future<int> get finished {
     return _process != null ? _process.exitCode : new Future<int>.value(0);
   }
 
+  @override
   Future<Null> start() async {
     if (_process != null) {
       throw new StateError(
@@ -282,6 +296,7 @@
     _process.exitCode.then(_onExit);
   }
 
+  @override
   Future<Null> stop() async {
     if (_process == null) {
       throw new StateError(
@@ -313,8 +328,10 @@
     _linesStreamController.add(line);
   }
 
+  @override
   int get hashCode => name.hashCode;
 
+  @override
   bool operator ==(dynamic other) {
     if (identical(this, other))
       return true;
@@ -329,12 +346,14 @@
 
   final IOSDevice device;
 
+  @override
   List<ForwardedPort> get forwardedPorts {
     final List<ForwardedPort> ports = <ForwardedPort>[];
     // TODO(chinmaygarde): Implement.
     return ports;
   }
 
+  @override
   Future<int> forward(int devicePort, {int hostPort: null}) async {
     if ((hostPort == null) || (hostPort == 0)) {
       // Auto select host port.
@@ -344,6 +363,7 @@
     return hostPort;
   }
 
+  @override
   Future<Null> unforward(ForwardedPort forwardedPort) async {
     // TODO(chinmaygarde): Implement.
   }
diff --git a/packages/flutter_tools/lib/src/ios/ios_workflow.dart b/packages/flutter_tools/lib/src/ios/ios_workflow.dart
index 67eda8d..10b1447 100644
--- a/packages/flutter_tools/lib/src/ios/ios_workflow.dart
+++ b/packages/flutter_tools/lib/src/ios/ios_workflow.dart
@@ -9,17 +9,22 @@
 import 'mac.dart';
 
 class IOSWorkflow extends Workflow {
+  @override
   String get label => 'iOS toolchain';
 
+  @override
   bool get appliesToHostPlatform => Platform.isMacOS;
 
   // We need xcode (+simctl) to list simulator devices, and idevice_id to list real devices.
+  @override
   bool get canListDevices => XCode.instance.isInstalledAndMeetsVersionCheck;
 
   // We need xcode to launch simulator devices, and ideviceinstaller and ios-deploy
   // for real devices.
+  @override
   bool get canLaunchDevices => XCode.instance.isInstalledAndMeetsVersionCheck;
 
+  @override
   ValidationResult validate() {
     Validator iosValidator = new Validator(
       label,
@@ -101,6 +106,7 @@
     return iosValidator.validate();
   }
 
+  @override
   void diagnose() => validate().print();
 
   bool get hasIdeviceId => exitsHappy(<String>['idevice_id', '-h']);
diff --git a/packages/flutter_tools/lib/src/ios/simulators.dart b/packages/flutter_tools/lib/src/ios/simulators.dart
index 7cf761d..9623642 100644
--- a/packages/flutter_tools/lib/src/ios/simulators.dart
+++ b/packages/flutter_tools/lib/src/ios/simulators.dart
@@ -27,7 +27,10 @@
 class IOSSimulators extends PollingDeviceDiscovery {
   IOSSimulators() : super('IOSSimulators');
 
+  @override
   bool get supportsPlatform => Platform.isMacOS;
+
+  @override
   List<Device> pollingGetDevices() => IOSSimulatorUtils.instance.getAttachedDevices();
 }
 
@@ -314,8 +317,10 @@
 class IOSSimulator extends Device {
   IOSSimulator(String id, { this.name }) : super(id);
 
+  @override
   final String name;
 
+  @override
   bool get isLocalEmulator => true;
 
   _IOSSimulatorLogReader _logReader;
@@ -536,6 +541,7 @@
   @override
   TargetPlatform get platform => TargetPlatform.ios_x64;
 
+  @override
   DeviceLogReader get logReader {
     if (_logReader == null)
       _logReader = new _IOSSimulatorLogReader(this);
@@ -543,6 +549,7 @@
     return _logReader;
   }
 
+  @override
   DevicePortForwarder get portForwarder {
     if (_portForwarder == null)
       _portForwarder = new _IOSSimulatorDevicePortForwarder(this);
@@ -550,6 +557,7 @@
     return _portForwarder;
   }
 
+  @override
   void clearLogs() {
     File logFile = new File(logFilePath);
     if (logFile.existsSync()) {
@@ -585,16 +593,21 @@
   StreamSubscription<String> _systemStdoutSubscription;
   StreamSubscription<String> _systemStderrSubscription;
 
+  @override
   Stream<String> get lines => _linesStreamController.stream;
 
+  @override
   String get name => device.name;
 
+  @override
   bool get isReading => (_deviceProcess != null) && (_systemProcess != null);
 
+  @override
   Future<int> get finished {
     return (_deviceProcess != null) ? _deviceProcess.exitCode : new Future<int>.value(0);
   }
 
+  @override
   Future<Null> start() async {
     if (isReading) {
       throw new StateError(
@@ -630,6 +643,7 @@
     _systemProcess.exitCode.then(_onSystemExit);
   }
 
+  @override
   Future<Null> stop() async {
     if (!isReading) {
       throw new StateError(
@@ -727,8 +741,10 @@
     _linesStreamController.add(filteredLine);
   }
 
+  @override
   int get hashCode => device.logFilePath.hashCode;
 
+  @override
   bool operator ==(dynamic other) {
     if (identical(this, other))
       return true;
@@ -789,10 +805,12 @@
 
   final List<ForwardedPort> _ports = <ForwardedPort>[];
 
+  @override
   List<ForwardedPort> get forwardedPorts {
     return _ports;
   }
 
+  @override
   Future<int> forward(int devicePort, {int hostPort: null}) async {
     if ((hostPort == null) || (hostPort == 0)) {
       hostPort = devicePort;
@@ -802,6 +820,7 @@
     return hostPort;
   }
 
+  @override
   Future<Null> unforward(ForwardedPort forwardedPort) async {
     _ports.remove(forwardedPort);
   }
diff --git a/packages/flutter_tools/lib/src/runner/flutter_command.dart b/packages/flutter_tools/lib/src/runner/flutter_command.dart
index b763f8e..d20c7b2 100644
--- a/packages/flutter_tools/lib/src/runner/flutter_command.dart
+++ b/packages/flutter_tools/lib/src/runner/flutter_command.dart
@@ -18,6 +18,7 @@
 typedef bool Validator();
 
 abstract class FlutterCommand extends Command {
+  @override
   FlutterCommandRunner get runner => super.runner;
 
   /// Whether this command needs to be run from the root of a project.
@@ -43,6 +44,7 @@
     applicationPackages ??= await ApplicationPackageStore.forConfigs(buildConfigurations);
   }
 
+  @override
   Future<int> run() {
     Stopwatch stopwatch = new Stopwatch()..start();
 
diff --git a/packages/flutter_tools/lib/src/runner/flutter_command_runner.dart b/packages/flutter_tools/lib/src/runner/flutter_command_runner.dart
index b89c9ec..630f01d 100644
--- a/packages/flutter_tools/lib/src/runner/flutter_command_runner.dart
+++ b/packages/flutter_tools/lib/src/runner/flutter_command_runner.dart
@@ -124,6 +124,7 @@
         defaultsTo: 'out/ios_sim_Release/');
   }
 
+  @override
   String get usageFooter {
     return 'Run "flutter -h -v" for verbose help output, including less commonly used options.\n'
            '\n'
@@ -165,6 +166,7 @@
     return '.';
   }
 
+  @override
   Future<dynamic> run(Iterable<String> args) {
     return super.run(args).then((dynamic result) {
       logger.flush();
@@ -172,6 +174,7 @@
     });
   }
 
+  @override
   Future<int> runCommand(ArgResults globalResults) {
     _globalResults = globalResults;
 
diff --git a/packages/flutter_tools/lib/src/test/flutter_platform.dart b/packages/flutter_tools/lib/src/test/flutter_platform.dart
index 61cbba0..f2db417 100644
--- a/packages/flutter_tools/lib/src/test/flutter_platform.dart
+++ b/packages/flutter_tools/lib/src/test/flutter_platform.dart
@@ -55,6 +55,7 @@
 }
 
 class FlutterPlatform extends PlatformPlugin {
+  @override
   StreamChannel<String> loadChannel(String mainPath, TestPlatform platform) {
     return StreamChannelCompleter.fromFuture(_startTest(mainPath));
   }
diff --git a/packages/flutter_tools/lib/src/zip.dart b/packages/flutter_tools/lib/src/zip.dart
index fb6c28e..f607ed9 100644
--- a/packages/flutter_tools/lib/src/zip.dart
+++ b/packages/flutter_tools/lib/src/zip.dart
@@ -48,6 +48,7 @@
 class _ArchiveZipBuilder extends ZipBuilder {
   _ArchiveZipBuilder() : super._();
 
+  @override
   void createZip(File outFile, Directory zipBuildDir) {
     Archive archive = new Archive();
 
@@ -69,6 +70,7 @@
 class _ZipToolBuilder extends ZipBuilder {
   _ZipToolBuilder() : super._();
 
+  @override
   void createZip(File outFile, Directory zipBuildDir) {
     if (outFile.existsSync())
       outFile.deleteSync();
