Convert GeneratedContent to async and use AnalysisDriver for tasks graph.

pkg/analyzer/tool/task_dependency_graph/generate.dart

 // Copyright (c) 2015, 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.
 
 /**
  * This file contains code to output a description of tasks and their
  * dependencies in ".dot" format.  Prior to running, the user should run "pub
  * get" in the analyzer directory to ensure that a "packages" folder exists.
  *
  * TODO(paulberry):
  * - Add general.dart and html.dart for completeness.
  * - Use Graphviz's "record" feature to produce more compact output
  *   (http://www.graphviz.org/content/node-shapes#record)
  * - Produce a warning if a result descriptor is found which isn't the output
  *   of exactly one task.
  * - Convert this tool to use package_config to find the package map.
  */
 library analyzer.tool.task_dependency_graph.generate;
 
+import 'dart:async';
 import 'dart:io' hide File;
 import 'dart:io' as io;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/file_system/physical_file_system.dart';
 import 'package:analyzer/source/package_map_resolver.dart';
 import 'package:analyzer/src/context/builder.dart';
+import 'package:analyzer/src/dart/analysis/driver.dart';
+import 'package:analyzer/src/dart/analysis/file_state.dart';
 import 'package:analyzer/src/dart/sdk/sdk.dart';
 import 'package:analyzer/src/generated/constant.dart';
 import 'package:analyzer/src/generated/engine.dart';
+import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/generated/sdk.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/source_io.dart';
+import 'package:front_end/src/base/performace_logger.dart';
+import 'package:front_end/src/byte_store/byte_store.dart';
 import 'package:front_end/src/codegen/tools.dart';
 import 'package:path/path.dart' as path;
 import 'package:path/path.dart';
 
 /**
  * Generate the target .dot file.
  */
-main() {
+main() async {
   String script = Platform.script.toFilePath(windows: Platform.isWindows);
   String pkgPath = normalize(join(dirname(script), '..', '..'));
-  GeneratedContent.generateAll(pkgPath, <GeneratedContent>[target, htmlTarget]);
+  await GeneratedContent
+      .generateAll(pkgPath, <GeneratedContent>[target, htmlTarget]);
 }
 
 final GeneratedFile htmlTarget = new GeneratedFile(
     'doc/tasks.html', (String pkgPath) => new Driver(pkgPath).generateHtml());
 
 final GeneratedFile target = new GeneratedFile(
     'tool/task_dependency_graph/tasks.dot',
     (String pkgPath) => new Driver(pkgPath).generateFileContents());
 
 typedef void GetterFinderCallback(PropertyAccessorElement element);
 
 class Driver {
   static bool hasInitializedPlugins = false;
   PhysicalResourceProvider resourceProvider;
-  AnalysisContext context;
+  AnalysisDriver driver;
   InterfaceType resultDescriptorType;
   InterfaceType listOfResultDescriptorType;
   ClassElement enginePluginClass;
   CompilationUnitElement taskUnitElement;
   InterfaceType extensionPointIdType;
 
   final String rootDir;
 
   Driver(String pkgPath) : rootDir = new Directory(pkgPath).absolute.path;
 
@@ skipping 47 matching lines @@
         new Set<PropertyAccessorElement>();
     node.accept(new GetterFinder(resultDescriptorType, resultDescriptors.add));
     for (PropertyAccessorElement resultDescriptor in resultDescriptors) {
       callback(resultDescriptor.name);
     }
   }
 
   /**
    * Generate the task dependency graph and return it as a [String].
    */
-  String generateFileContents() {
+  Future<String> generateFileContents() async {
+    String data = await generateGraphData();
     return '''
 // Copyright (c) 2015, 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.
 //
 // This file has been automatically generated.  Please do not edit it manually.
 // To regenerate the file, use the script
 // "pkg/analyzer/tool/task_dependency_graph/generate.dart".
 //
 // To render this graph using Graphviz (www.graphviz.org) use the command:
 // "dot tasks.dot -Tpdf -O".
 digraph G {
-${generateGraphData()}
+$data
 }
 ''';
   }
 
-  String generateGraphData() {
+  Future<String> generateGraphData() async {
     if (!hasInitializedPlugins) {
       AnalysisEngine.instance.processRequiredPlugins();
       hasInitializedPlugins = true;
     }
     List<String> lines = <String>[];
     resourceProvider = PhysicalResourceProvider.INSTANCE;
     DartSdk sdk = new FolderBasedDartSdk(resourceProvider,
         FolderBasedDartSdk.defaultSdkDirectory(resourceProvider));
-    context = AnalysisEngine.instance.createAnalysisContext();
+
     ContextBuilderOptions builderOptions = new ContextBuilderOptions();
     if (Platform.packageRoot != null) {
       builderOptions.defaultPackagesDirectoryPath =
           Uri.parse(Platform.packageRoot).toFilePath();
     } else if (Platform.packageConfig != null) {
       builderOptions.defaultPackageFilePath =
           Uri.parse(Platform.packageConfig).toFilePath();
     } else {
       // Let the context builder use the default algorithm for package
       // resolution.
     }
+
     ContextBuilder builder = new ContextBuilder(resourceProvider, null, null,
         options: builderOptions);
     List<UriResolver> uriResolvers = [
       new DartUriResolver(sdk),
       new PackageMapUriResolver(resourceProvider,
           builder.convertPackagesToMap(builder.createPackageMap(''))),
-      new ResourceUriResolver(PhysicalResourceProvider.INSTANCE)
+      new ResourceUriResolver(resourceProvider)
     ];
-    context.sourceFactory = new SourceFactory(uriResolvers);
-    Source dartDartSource =
-        setupSource(path.join('lib', 'src', 'task', 'dart.dart'));
-    Source taskSource = setupSource(path.join('lib', 'plugin', 'task.dart'));
-    Source modelSource = setupSource(path.join('lib', 'task', 'model.dart'));
-    Source enginePluginSource =
-        setupSource(path.join('lib', 'src', 'plugin', 'engine_plugin.dart'));
-    CompilationUnitElement modelElement = getUnit(modelSource).element;
+
+    var logger = new PerformanceLog(null);
+    var scheduler = new AnalysisDriverScheduler(logger);
+    driver = new AnalysisDriver(
+        scheduler,
+        logger,
+        resourceProvider,
+        new MemoryByteStore(),
+        new FileContentOverlay(),
+        null,
+        new SourceFactory(uriResolvers),
+        new AnalysisOptionsImpl());
+    scheduler.start();
+
+    TypeProvider typeProvider = await driver.currentSession.typeProvider;
+
+    String dartDartPath = path.join(rootDir, 'lib', 'src', 'task', 'dart.dart');
+    String taskPath = path.join(rootDir, 'lib', 'plugin', 'task.dart');
+    String modelPath = path.join(rootDir, 'lib', 'task', 'model.dart');
+    String enginePluginPath =
+        path.join(rootDir, 'lib', 'src', 'plugin', 'engine_plugin.dart');
+
+    CompilationUnitElement modelElement = await getUnitElement(modelPath);
     InterfaceType analysisTaskType = modelElement.getType('AnalysisTask').type;
-    DartType dynamicType = context.typeProvider.dynamicType;
+    DartType dynamicType = typeProvider.dynamicType;
     resultDescriptorType = modelElement
         .getType('ResultDescriptor')
         .type
         .instantiate([dynamicType]);
     listOfResultDescriptorType =
-        context.typeProvider.listType.instantiate([resultDescriptorType]);
-    CompilationUnit enginePluginUnit = getUnit(enginePluginSource);
+        typeProvider.listType.instantiate([resultDescriptorType]);
+    CompilationUnit enginePluginUnit = await getUnit(enginePluginPath);
     enginePluginClass = enginePluginUnit.element.getType('EnginePlugin');
     extensionPointIdType =
         enginePluginUnit.element.getType('ExtensionPointId').type;
-    CompilationUnit dartDartUnit = getUnit(dartDartSource);
-    CompilationUnit taskUnit = getUnit(taskSource);
+    CompilationUnit dartDartUnit = await getUnit(dartDartPath);
+    CompilationUnit taskUnit = await getUnit(taskPath);
     taskUnitElement = taskUnit.element;
     Set<String> results = new Set<String>();
     Set<String> resultLists = new Set<String>();
     for (CompilationUnitMember dartUnitMember in dartDartUnit.declarations) {
       if (dartUnitMember is ClassDeclaration) {
         ClassDeclaration clazz = dartUnitMember;
         if (!clazz.isAbstract &&
             clazz.element.type.isSubtypeOf(analysisTaskType)) {
           String task = clazz.name.name;
 
@@ skipping 36 matching lines @@
         lines.add('  $extension -> $resultList');
       });
     }
     for (String result in results) {
       lines.add('  $result [shape=box]');
     }
     lines.sort();
     return lines.join('\n');
   }
 
-  String generateHtml() {
+  Future<String> generateHtml() async {
+    var data = await generateGraphData();
     return '''
 <!DOCTYPE html>
 <html>
 <head>
     <title>Analysis Task Dependency Graph</title>
     <link rel="stylesheet" href="support/style.css">
     <script src="support/viz.js"></script>
     <script type="application/dart" src="support/web_app.dart.js"></script>
     <script src="support/dart.js"></script>
 </head>
 <body>
 <button id="zoomBtn">Zoom</button>
 <script type="text/vnd.graphviz" id="dot">
 digraph G {
   tooltip="Analysis Task Dependency Graph";
   node [fontname=Helvetica];
   edge [fontname=Helvetica, fontcolor=gray];
-${generateGraphData()}
+$data
 }
 </script>
 </body>
 </html>
 ''';
   }
 
-  CompilationUnit getUnit(Source source) =>
-      context.resolveCompilationUnit2(source, source);
+  Future<CompilationUnit> getUnit(String path) async {
+    var result = await driver.getResult(path);
+    return result.unit;
+  }
 
-  Source setupSource(String filename) {
-    String filePath = path.join(rootDir, filename);
-    File file = resourceProvider.getResource(filePath);
-    Source source = file.createSource();
-    Uri restoredUri = context.sourceFactory.restoreUri(source);
-    if (restoredUri != null) {
-      source = file.createSource(restoredUri);
-    }
-    ChangeSet changeSet = new ChangeSet();
-    changeSet.addedSource(source);
-    context.applyChanges(changeSet);
-    return source;
+  Future<CompilationUnitElement> getUnitElement(String path) async {
+    UnitElementResult result = await driver.getUnitElement(path);
+    return result.element;
   }
 
   /**
    * Find the result list getter having name [resultListGetterName] in the
    * [EnginePlugin] class, and use the [ExtensionPointId] annotation on that
    * getter to find the associated [TopLevelVariableElement] which can be used
    * to register extensions for that getter.
    */
   TopLevelVariableElement _getExtensionId(String resultListGetterName) {
     PropertyAccessorElement getter =
@@ skipping 69 matching lines @@
   @override
   visitIdentifier(Identifier node) {
     Element element = node.staticElement;
     if (element is PropertyAccessorElement &&
         element.isGetter &&
         element.returnType.isSubtypeOf(type)) {
       callback(element);
     }
   }
 }