Add FrontEndStrategy, ResolutionFrontEndStrategy and KernelFrontEndStrategy

pkg/compiler/lib/src/kernel/world_builder.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.
 
 library dart2js.kernel.world_builder;
 
 import 'package:kernel/ast.dart' as ir;
 
 import '../common.dart';
 import '../common/resolution.dart';
@@ skipping 31 matching lines @@
 class KernelWorldBuilder extends KernelElementAdapterMixin {
   CommonElements _commonElements;
   native.BehaviorBuilder _nativeBehaviorBuilder;
   final DiagnosticReporter reporter;
   ElementEnvironment _elementEnvironment;
   DartTypeConverter _typeConverter;
   KernelConstantEnvironment _constantEnvironment;
   _KernelDartTypes _types;
 
   /// Library environment. Used for fast lookup.
-  KEnv _env;
+  KEnv _env = new KEnv();
 
   /// List of library environments by `KLibrary.libraryIndex`. This is used for
   /// fast lookup into library classes and members.
   List<KLibraryEnv> _libraryEnvs = <KLibraryEnv>[];
 
   /// List of class environments by `KClass.classIndex`. This is used for
   /// fast lookup into class members.
   List<KClassEnv> _classEnvs = <KClassEnv>[];
 
   Map<ir.Library, KLibrary> _libraryMap = <ir.Library, KLibrary>{};
@@ skipping 11 matching lines @@
 
   Map<ir.Procedure, KFunction> _methodMap = <ir.Procedure, KFunction>{};
 
   Map<ir.Field, KField> _fieldMap = <ir.Field, KField>{};
   Map<KField, ConstantExpression> _fieldConstantMap =
       <KField, ConstantExpression>{};
 
   Map<ir.TreeNode, KLocalFunction> _localFunctionMap =
       <ir.TreeNode, KLocalFunction>{};
 
-  KernelWorldBuilder(this.reporter, ir.Program program)
-      : _env = new KEnv(program) {
+  KernelWorldBuilder(this.reporter) {
     _elementEnvironment = new KernelElementEnvironment(this);
     _commonElements = new CommonElements(_elementEnvironment);
     _constantEnvironment = new KernelConstantEnvironment(this);
     _nativeBehaviorBuilder =
         new KernelBehaviorBuilder(_commonElements, _constantEnvironment);
     _types = new _KernelDartTypes(this);
     _typeConverter = new DartTypeConverter(this);
   }
 
+  /// Adds libraries in [program] to the set of libraries.
+  ///
+  /// The main method of the first program is used as the main method for the
+  /// compilation.
+  void addProgram(ir.Program program) {
+    _env.addProgram(program);
+  }
+
   KMethod get _mainFunction {
-    return _env.program.mainMethod != null
-        ? _getMethod(_env.program.mainMethod)
+    return _env.mainMethod != null ? _getMethod(_env.mainMethod) : null;
+  }
+
+  KLibrary get _mainLibrary {
+    return _env.mainMethod != null
+        ? _getLibrary(_env.mainMethod.enclosingLibrary)
         : null;
   }
 
-  KLibrary get _mainLibrary {
-    return _env.program.mainMethod != null
-        ? _getLibrary(_env.program.mainMethod.enclosingLibrary)
-        : null;
-  }
-
   Iterable<LibraryEntity> get _libraries {
     if (_env.length != _libraryMap.length) {
       // Create a [KLibrary] for each library.
       _env.forEachLibrary((KLibraryEnv env) {
         _getLibrary(env.library, env);
       });
     }
     return _libraryMap.values;
   }
 
@@ skipping 473 matching lines @@
   }
 
   ResolutionImpact computeWorldImpact(KMember member) {
     ir.Member node = _memberList[member.memberIndex];
     return buildKernelImpact(node, this);
   }
 }
 
 /// Environment for fast lookup of program libraries.
 class KEnv {
-  final ir.Program program;
+  final Set<ir.Program> programs = new Set<ir.Program>();
 
   Map<Uri, KLibraryEnv> _libraryMap;
 
-  KEnv(this.program);
+  /// TODO(johnniwinther): Handle arbitrary load order if needed.
+  ir.Member get mainMethod => programs.first?.mainMethod;
+
+  void addProgram(ir.Program program) {
+    if (programs.add(program)) {
+      if (_libraryMap != null) {
+        _addLibraries(program);
+      }
+    }
+  }
+
+  void _addLibraries(ir.Program program) {
+    for (ir.Library library in program.libraries) {
+      _libraryMap[library.importUri] = new KLibraryEnv(library);
+    }
+  }
 
   void _ensureLibraryMap() {
     if (_libraryMap == null) {
       _libraryMap = <Uri, KLibraryEnv>{};
-      for (ir.Library library in program.libraries) {
-        _libraryMap[library.importUri] = new KLibraryEnv(library);
+      for (ir.Program program in programs) {
+        _addLibraries(program);
       }
     }
   }
 
   /// Return the [KLibraryEnv] for the library with the canonical [uri].
   KLibraryEnv lookupLibrary(Uri uri) {
     _ensureLibraryMap();
     return _libraryMap[uri];
   }
 
@@ skipping 568 matching lines @@
   }
 
   InterfaceType getMixinTypeForClass(KClass cls) {
     KClassEnv env = builder._classEnvs[cls.classIndex];
     ir.Supertype mixedInType = env.cls.mixedInType;
     if (mixedInType == null) return null;
     return builder.createInterfaceType(
         mixedInType.classNode, mixedInType.typeArguments);
   }
 }