Make the construction of a ProcessResult public

sdk/lib/io/process.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.
 
 part of dart.io;
 
 // TODO(ager): The only reason for this class is that we
 // cannot patch a top-level at this point.
 class _ProcessUtils {
   external static void _exit(int status);
@@ skipping 413 matching lines @@
    * Returns `true` if the signal is successfully delivered to the
    * process. Otherwise the signal could not be sent, usually meaning
    * that the process is already dead.
    */
   bool kill([ProcessSignal signal = ProcessSignal.SIGTERM]);
 }
 
 
 /**
  * [ProcessResult] represents the result of running a non-interactive
  * process started with [:Process.run:].

[Lasse Reichstein Nielsen, 2015/04/07 12:38:44]

[:Process.run:] -> [Process.run] or [Process.runSync].

[Søren Gjesse, 2015/04/07 13:05:35]

Done.

  */
-abstract class ProcessResult {
+class ProcessResult {
   /**
    * Exit code for the process.
    *
    * See [Process.exitCode] for more information in the exit code
    * value.
    */
-  int get exitCode;
+  final int exitCode;
 
   /**
    * Standard output from the process. The value used for the
    * `stdoutEncoding` argument to `Process.run` determines the type. If
    * `null` was used this value is of type `List<int> otherwise it is
    * of type `String`.

[Lasse Reichstein Nielsen, 2015/04/07 12:38:45]

Make ProcessResult generic with the type of this and stderr as parameter.

Then the user can write:

 ProcessResult<String> result = Process.run(..., encoding: UTF8);

and work happily and typed forever after.

[Søren Gjesse, 2015/04/07 13:05:35]

One can specify different encodings for stdout and stderr, so that would require
two different type parameters:

  ProcessResult<String, List<int>> result =
      Process.run(..., stdoutEncoding: UTF8, stderrEncoding: null);

  ProcessResult<String, String> result =
      Process.run(..., stdoutEncoding: UTF8, stderrEncoding: UTF8);

which does not look that nice.

    */
-  get stdout;
+  final stdout;
 
   /**
    * Standard error from the process. The value used for the
    * `stderrEncoding` argument to `Process.run` determines the type. If
    * `null` was used this value is of type `List<int>
    * otherwise it is of type `String`.
    */
-  get stderr;
+  final stderr;
 
   /**
    * Process id from the process.

[Lasse Reichstein Nielsen, 2015/04/07 12:38:44]

Process id of the process
?

[Søren Gjesse, 2015/04/07 13:05:35]

Done.

    */
-  int get pid;
+  final int pid;
+
+  /**
+   * Construct an instance of [ProcessResult].
+   *
+   * The main use of `ProcessResult is as return value from
+   * `Process.run` and `Process.runSync`. However for some applications

[Lasse Reichstein Nielsen, 2015/04/07 12:38:44]

Comma after "however". Maybe rewrite to something more direct.
Maybe just remove the comment. The use of a class belongs in the class
description, not the constructor. The constructor is completely transparently
named and hardly needs a comment at all.

[Søren Gjesse, 2015/04/07 13:05:35]

I removed the comment.

+   * constructing it directly might be useful.
+   */
+  const ProcessResult(int this.pid,

[Lasse Reichstein Nielsen, 2015/04/07 12:38:44]

Remove the `const` if possible. It makes little-to-no sense that the result of
running a computation can be known at compile time.

If you use it as "const" somewhere, then just make those final and lazily
created instead.

[Søren Gjesse, 2015/04/07 13:05:35]

Done.

+                      int this.exitCode,
+                      this.stdout,
+                      this.stderr);
 }
 
 
 /**
  * On Posix systems, [ProcessSignal] is used to send a specific signal
  * to a child process, see [:Process.kill:].
  *
  * Some [ProcessSignal]s can also be watched, as a way to intercept the default
  * signal handler and implement another. See [ProcessSignal.watch] for more
  * information.
@@ skipping 95 matching lines @@
   final int errorCode;
 
   const ProcessException(this.executable, this.arguments, [this.message = "",
                          this.errorCode = 0]);
   String toString() {
     var msg = (message == null) ? 'OS error code: $errorCode' : message;
     var args = arguments.join(' ');
     return "ProcessException: $msg\n  Command: $executable $args";
   }
 }