Replace factory constructor with a static method for creating IncrementalKernelGenerator.

pkg/front_end/lib/incremental_kernel_generator.dart

 // Copyright (c) 2017, 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.
 
 import 'dart:async';
 
 import 'package:front_end/src/base/processed_options.dart';
 import 'package:front_end/src/incremental_kernel_generator_impl.dart';
 import 'package:kernel/kernel.dart';
 
@@ skipping 38 matching lines @@
 /// [computeDelta].
 ///
 /// Behavior is undefined if the client does not obey the following concurrency
 /// restrictions:
 /// - no two invocations of [computeDelta] may be outstanding at any given time.
 /// - neither [invalidate] nor [invalidateAll] may be called while an invocation
 ///   of [computeDelta] is outstanding.
 ///
 /// Not intended to be implemented or extended by clients.
 abstract class IncrementalKernelGenerator {
-  /// Creates an [IncrementalKernelGenerator] which is prepared to generate
-  /// kernel representations of the program whose main library is in the given
-  /// [source].
-  ///
-  /// No file system access is performed by this constructor; the initial
-  /// "previous program state" is an empty program containing no code, and the
-  /// initial set of valid sources is empty.  To obtain a kernel representation
-  /// of the program, call [computeDelta].
-  factory IncrementalKernelGenerator(Uri source, CompilerOptions options) =>
-      new IncrementalKernelGeneratorImpl(source, new ProcessedOptions(options));
-
   /// Generates a kernel representation of the changes to the program, assuming
   /// that all valid sources are unchanged since the last call to
   /// [computeDelta].
   ///
   /// Source files in the set of valid sources are guaranteed not to be re-read
   /// from disk; they are assumed to be unchanged regardless of the state of the
   /// filesystem.
   ///
   /// If [watch] is not `null`, then when a source file is first used
   /// by [computeDelta], [watch] is called with the Uri of that source
@@ skipping 21 matching lines @@
   void invalidate(Uri uri);
 
   /// Remove all source files from the set of valid sources.  This guarantees
   /// that all files will be re-read on the next call to [computeDelta].
   ///
   /// Note that this does not erase the previous program state; the next time
   /// [computeDelta] is called, if parts of the program are discovered to be
   /// unchanged, parts of the previous program state will still be re-used to
   /// speed up compilation.
   void invalidateAll();
+
+  /// Creates an [IncrementalKernelGenerator] which is prepared to generate
+  /// kernel representations of the program whose main library is in the given
+  /// [entryPoint].
+  ///
+  /// The initial "previous program state" is an empty program containing no
+  /// code, and the initial set of valid sources is empty.  To obtain a kernel
+  /// representation of the program, call [computeDelta].
+  static Future<IncrementalKernelGenerator> newInstance(
+      CompilerOptions options, Uri entryPoint) async {
+    var processedOptions = new ProcessedOptions(options);
+    var uriTranslator = await processedOptions.getUriTranslator();
+    return new IncrementalKernelGeneratorImpl(
+        processedOptions, uriTranslator, entryPoint);
+  }
 }