Switch from interfaces to abstract classes in dart:io.

runtime/bin/process.dart

 // 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.
 
 /** Exit the Dart VM process with the given [status] code. */
 void exit(int status) {
   if (status is !int) {
     throw new IllegalArgumentException("int status expected");
   }
   _exit(status);
@@ skipping 14 matching lines @@
    *
    * When the process has been successfully started [onStart] is
    * called on the returned Process object. If the process fails to
    * start [onError] is called on the returned Process object.
    *
    * No data can be written to the process stdin and the process
    * cannot be closed nor killed before [onStart] has been invoked.
    */
   static Process start(String executable,
                        List<String> arguments,
-                       [ProcessOptions options]) {
+                       [ProcessOptions options = null]) {

[Søren Gjesse, 2012/09/18 09:34:16]

Isn't null the default default value for optional arguments ("= null" is
redundant)?

[Mads Ager (google), 2012/09/18 10:46:39]

Yes, it is redundant. Removed.

     return new _Process.start(executable, arguments, options);
   }
 
   /**
    * Starts a process and runs it non-interactively to completion. The
    * process run is [executable] with the specified [arguments].
    *
    * An optional [ProcessOptions] object can be passed to specify
    * options other than the executable and the arguments.

[Søren Gjesse, 2012/09/18 09:34:16]

Maybe add these two lines on the options argument for start above as well.

[Mads Ager (google), 2012/09/18 10:46:39]

It is actually there already. The comment is just truncated in the code review
tool. :)

    *
    * Returns a [:Future<ProcessResult>:] that completes with the
    * result of running the process, i.e., exit code, standard out and
    * standard in.
    */
   static Future<ProcessResult> run(String executable,
                                    List<String> arguments,
-                                   [ProcessOptions options]) {
+                                   [ProcessOptions options = null]) {

[Søren Gjesse, 2012/09/18 09:34:16]

"= null" needed?

[Mads Ager (google), 2012/09/18 10:46:39]

Done.

     return _Process.run(executable, arguments, options);
   }
 
   /**
    * Returns an input stream of the process stdout.
    *
    * Throws an [UnsupportedOperationException] if the process is
    * non-interactive.
    */
   abstract InputStream get stdout;
@@ skipping 31 matching lines @@
 
   /**
    * Set an error handler which gets invoked if an operation on the process
    * fails.
    */
   abstract void set onError(void callback(e));
 
   /**
    * On Windows, [kill] kills the process, ignoring the [signal] flag. On
    * Posix systems, [kill] sends [signal] to the process. Depending on the
    * signal giving, it'll have different meanings. The default [signal] to

[Søren Gjesse, 2012/09/18 09:34:16]

No need for documentation of the default value.

[Mads Ager (google), 2012/09/18 10:46:39]

Done.

    * send is [:ProcessSignal.SIGTERM:]. When the process terminates as a result
    * of calling [kill] [onExit] is called. If the kill operation fails,
    * [onError] is called.
    */
-  abstract void kill([ProcessSignal signal]);
+  abstract void kill([ProcessSignal signal = ProcessSignal.SIGTERM]);
 
   /**
    * Terminates the streams of a process. [close] must be called on a
    * process to free the system resources associated with it if not all
    * data on the stdout and stderr streams have been read. Usually,
    * close should be called in [onExit], but care must be taken to actually
    * wait on the stderr and stdout streams to close if all data is required.
    * Once a process has been closed it can no longer be killed and [onExit]
    * is detached so the application is not notified of process termination.
    */
   abstract void close();
 }
 
 
 /**
  * [ProcessResult] represents the result of running a non-interactive
  * process started with [:Process.run:].
  */
-interface ProcessResult {
+abstract class ProcessResult {
   /**
    * Exit code for the process.
    */
   int get exitCode;
 
   /**
    * Standard output from the process as a string.
    */
   String get stdout;
 
@@ skipping 83 matching lines @@
   static const ProcessSignal SIGPROF = const ProcessSignal._signal(27);
   static const ProcessSignal SIGPOLL = const ProcessSignal._signal(29);
   static const ProcessSignal SIGSYS = const ProcessSignal._signal(31);
 
   const ProcessSignal._signal(int this._signalNumber);
   final int _signalNumber;
 }
 
 
 class ProcessException implements Exception {
-  const ProcessException([String this.message, int this.errorCode = 0]);
+  const ProcessException([String this.message = "", int this.errorCode = 0]);
   String toString() => "ProcessException: $message ($errorCode)";
 
   /**
    * Contains the system message for the process exception if any.
    */
   final String message;
 
   /**
    * Contains the OS error code for the process exception if any.
    */
   final int errorCode;
 }