Formalizing the hacks letting the angular analyzer plugin run for now.

pkg/analysis_server/lib/src/server/driver.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.
 
 library driver;
 
 import 'dart:async';
 import 'dart:io';
 import 'dart:math';
 
@@ skipping 330 matching lines @@
 
   /**
    * Set the [plugins] that are defined outside the analysis_server package.
    */
   void set userDefinedPlugins(List<Plugin> plugins) {
     _userDefinedPlugins = plugins ?? <Plugin>[];
   }
 
   /**
    * Use the given command-line [arguments] to start this server.
+   *
+   * At least temporarily returns AnalysisServer so that consumers of the
+   * starter API can then use the server, this is done as a stopgap for the
+   * angular plugin until the official plugin API is finished.
    */
-  void start(List<String> arguments) {
+  AnalysisServer start(List<String> arguments) {
     CommandLineParser parser = _createArgParser();
     ArgResults results = parser.parse(arguments, <String, String>{});
     if (results[HELP_OPTION]) {
       _printUsage(parser.parser);
-      return;
+      return null;
     }
 
     // TODO (danrubel) Remove this workaround
     // once the underlying VM and dart:io issue has been fixed.
     if (results[INTERNAL_DELAY_FREQUENCY] != null) {
       AnalysisServer.performOperationDelayFrequency =
           int.parse(results[INTERNAL_DELAY_FREQUENCY], onError: (_) => 0);
     }
 
     int port;
     bool serve_http = false;
     if (results[PORT_OPTION] != null) {
       try {
         port = int.parse(results[PORT_OPTION]);
         serve_http = true;
       } on FormatException {
         print('Invalid port number: ${results[PORT_OPTION]}');
         print('');
         _printUsage(parser.parser);
         exitCode = 1;
-        return;
+        return null;
       }
     }
 
     AnalysisServerOptions analysisServerOptions = new AnalysisServerOptions();
     analysisServerOptions.enableIncrementalResolutionApi =
         results[ENABLE_INCREMENTAL_RESOLUTION_API];
     analysisServerOptions.enableIncrementalResolutionValidation =
         results[INCREMENTAL_RESOLUTION_VALIDATION];
     analysisServerOptions.enableNewAnalysisDriver =
         !results[DISABLE_NEW_ANALYSIS_DRIVER];
@@ skipping 88 matching lines @@
       stdioServer.serveStdio().then((_) async {
         if (serve_http) {
           httpServer.close();
         }
         await instrumentationService.shutdown();
         exit(0);
       });
     },
         print:
             results[INTERNAL_PRINT_TO_CONSOLE] ? null : httpServer.recordPrint);
+
+    return socketServer.analysisServer;
   }
 
   /**
    * Execute the given [callback] within a zone that will capture any unhandled
    * exceptions and both report them to the client and send them to the given
    * instrumentation [service]. If a [print] function is provided, then also
    * capture any data printed by the callback and redirect it to the function.
    */
   dynamic _captureExceptions(InstrumentationService service, dynamic callback(),
       {void print(String line)}) {
@@ skipping 163 matching lines @@
 
   _DiagnosticServerImpl();
 
   Future startOnPort(int port) {
     return httpServer.serveHttp(port);
   }
 
   @override
   Future<int> getServerPort() => httpServer.serveHttp();
 }