Consolidate analyzer dependencies.

pkg/front_end/lib/src/fasta/source/source_loader.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 file.
 
 library fasta.source_loader;
 
 import 'dart:async' show Future;
 
 import 'dart:io' show FileSystemException;
 
 import '../scanner/io.dart' show readBytesFromFile;
 
 import '../scanner.dart' show ErrorToken, ScannerResult, Token, scan;
 
 import '../parser/class_member_parser.dart' show ClassMemberParser;
 
 import 'package:kernel/ast.dart' show Program;
 
 import 'package:kernel/class_hierarchy.dart' show ClassHierarchy;
 
 import 'package:kernel/core_types.dart' show CoreTypes;
 
 import '../errors.dart' show inputError, printUnexpected;
 
 import '../messages.dart' show warning;
 
 import '../export.dart' show Export;
 
-import '../analyzer/element_store.dart' show ElementStore;
-
 import '../builder/builder.dart' show Builder, ClassBuilder, LibraryBuilder;
 
 import 'outline_builder.dart' show OutlineBuilder;
 
 import '../loader.dart' show Loader;
 
 import '../target_implementation.dart' show TargetImplementation;
 
 import 'diet_listener.dart' show DietListener;
 
 import 'diet_parser.dart' show DietParser;
 
 import 'source_library_builder.dart' show SourceLibraryBuilder;
 
-import '../ast_kind.dart' show AstKind;
-
 class SourceLoader<L> extends Loader<L> {
   final Map<Uri, List<int>> sourceBytes = <Uri, List<int>>{};
 
   // Used when building directly to kernel.
   ClassHierarchy hierarchy;
   CoreTypes coreTypes;
 
-  // Used when building analyzer ASTs.
-  ElementStore elementStore;
-
   SourceLoader(TargetImplementation target) : super(target);
 
   Future<Token> tokenize(SourceLibraryBuilder library,
       {bool suppressLexicalErrors: false}) async {
     Uri uri = library.fileUri;
     if (uri == null || uri.scheme != "file") {
       return inputError(library.uri, -1, "Not found: ${library.uri}.");
     }
     try {
       List<int> bytes = sourceBytes[uri];
@@ skipping 24 matching lines @@
     }
   }
 
   Future<Null> buildOutline(SourceLibraryBuilder library) async {
     Token tokens = await tokenize(library);
     if (tokens == null) return;
     OutlineBuilder listener = new OutlineBuilder(library);
     new ClassMemberParser(listener).parseUnit(tokens);
   }
 
-  Future<Null> buildBody(LibraryBuilder library, AstKind astKind) async {
+  Future<Null> buildBody(LibraryBuilder library) async {
     if (library is SourceLibraryBuilder) {
       // We tokenize source files twice to keep memory usage low. This is the
       // second time, and the first time was in [buildOutline] above. So this
       // time we suppress lexical errors.
       Token tokens = await tokenize(library, suppressLexicalErrors: true);
       if (tokens == null) return;
-      DietListener listener = new DietListener(
-          library, elementStore, hierarchy, coreTypes, astKind);
+      DietListener listener = createDietListener(library);
       DietParser parser = new DietParser(listener);
       parser.parseUnit(tokens);
       for (SourceLibraryBuilder part in library.parts) {
         Token tokens = await tokenize(part);
         if (tokens != null) {
           listener.uri = part.fileUri;
           parser.parseUnit(tokens);
         }
       }
     }
   }
 
+  DietListener createDietListener(LibraryBuilder library) {
+    return new DietListener(library, hierarchy, coreTypes);
+  }
+
   void resolveParts() {
     List<Uri> parts = <Uri>[];
     builders.forEach((Uri uri, LibraryBuilder library) {
       if (library is SourceLibraryBuilder) {
         if (library.isPart) {
           library.validatePart();
           parts.add(uri);
         } else {
           library.includeParts();
         }
@@ skipping 200 matching lines @@
 
   void buildProgram() {
     builders.forEach((Uri uri, LibraryBuilder library) {
       if (library is SourceLibraryBuilder) {
         libraries.add(library.build());
       }
     });
     ticker.logMs("Built program");
   }
 
-  void buildElementStore() {
-    elementStore = new ElementStore(coreLibrary, builders);
-    ticker.logMs("Built analyzer element model.");
-  }
-
   void computeHierarchy(Program program) {
     hierarchy = new ClassHierarchy(program);
     ticker.logMs("Computed class hierarchy");
     coreTypes = new CoreTypes(program);
     ticker.logMs("Computed core types");
   }
 }