Add support for not generating a .dill file.

lib/src/options.dart

 // Copyright (c) 2016, 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.md file.
 
 library rasta.options;
 
 import 'dart:async' show
     Future;
 
 import 'dart:isolate' show
@@ skipping 13 matching lines @@
     "--batch": const OptionDescription(Option.batch),
 
     "--pattern": const OptionDescription(Option.pattern, hasArgument: true),
 
     "--target": const OptionDescription(Option.target, hasArgument: true),
 
     "--throw-on-error": const OptionDescription(
         Option.throwOnError, hasOptionalArgument: true),
 
     "--analyze": const OptionDescription(Option.analyze),
+
+    "--no-output": const OptionDescription(Option.noOutput),
 };
 
 const List<Option> supportedBatchOptions = const <Option>[
     Option.batch,
     Option.verbose,
     Option.target,
     Option.throwOnError,
     Option.analyze,
 
     // TODO(ahe): These options shouldn't be supported in batch server
@@ skipping 25 matching lines @@
 
   /// `--target`.
   target,
 
   /// `--throw-on-error`.
   throwOnError,
 
   /// `--analyze`.
   analyze,
 
+  /// `--no-output`.
+  noOutput,
+
   // `--` which signals option parsing should end (the rest are arguments).
   skip,
 
   // Non-option argument, for example, a file name.
   argument,
 }
 
 class OptionDescription {
   final Option option;
   final bool hasArgument;
@@ skipping 15 matching lines @@
   final Uri output;
   final Uri dependenciesFile;
   final Uri targetSpecification;
   final bool generateLibrary;
   final bool isVerbose;
   final bool isBatch;
   final Pattern pattern;
   final bool throwOnError;
   final int throwOnErrorCount;
   final bool analyze;
+  final bool noOutput;
 
   Options(this.input, this.output,
           {this.dependenciesFile, this.targetSpecification,
            this.generateLibrary, this.isVerbose, this.isBatch, this.pattern,
-           this.throwOnError, this.throwOnErrorCount, this.analyze});
+           this.throwOnError, this.throwOnErrorCount, this.analyze,
+           this.noOutput});
 }
 
 class OptionParser {
   final Iterator<String> arguments;
   final Uri base;
 
   OptionParser(Iterable<String> arguments, this.base)
       : arguments = arguments.iterator;
 
   Future<Options> parse() async {
     List<OptionValue> values = parseValues();
 
     // Null means not specified.
     bool generateLibrary;
     bool isVerbose;
     bool isBatch;
     bool throwOnError;
     int throwOnErrorCount = 1;
     bool analyze;
     Uri dependenciesFile;
     Uri targetSpecification;
     List<String> uris = <String>[];
     Pattern pattern;
+    bool noOutput;
     for (OptionValue value in values) {
       switch (value.option) {
         case Option.library:
           generateLibrary = true;
           break;
 
         case Option.program:
           generateLibrary = false;
           break;
 
@@ skipping 23 matching lines @@
           throwOnError = true;
           if (value.argument != null) {
             throwOnErrorCount = int.parse(value.argument);
           }
           break;
 
         case Option.analyze:
           analyze = true;
           break;
 
+        case Option.noOutput:
+          noOutput = true;
+          break;
+
         case Option.skip:
           throw "internal error";
 
         case Option.argument:
           uris.add(value.argument);
       }
     }
     if (targetSpecification == null) {
       Uri script = await Isolate.resolvePackageUri(
           Uri.parse("package:rasta/src/options.dart"));
@@ skipping 42 matching lines @@
       assert(uris.length > 2);
       String extraArguments = uris.join("' '");
       throw "Additional argument: '$extraArguments'.";
     }
     return new Options(
         input, output, dependenciesFile: dependenciesFile,
         targetSpecification: targetSpecification,
         generateLibrary: generateLibrary, isVerbose: isVerbose ?? false,
         isBatch: isBatch ?? false, pattern: pattern,
         throwOnError: throwOnError ?? false,
-        throwOnErrorCount: throwOnErrorCount, analyze: analyze ?? false);
+        throwOnErrorCount: throwOnErrorCount, analyze: analyze ?? false,
+        noOutput: noOutput ?? false);
   }
 
   List<OptionValue> parseValues() {
     OptionValue value;
     List<OptionValue> values = <OptionValue>[];
     while ((value = nextOptionValue()) != null) {
       if (value.option == Option.skip) break;
       values.add(value);
     }
     while (arguments.moveNext()) {
@@ skipping 32 matching lines @@
     return new OptionValue(description.option, argument);
   }
 
   String getArgument(String name) {
     if (!arguments.moveNext()) {
       throw "Missing argument to option '$name'";
     }
     return arguments.current;
   }
 }