Rework codegen tools to avoid relying on CWD; integrate with task model 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 task_dependency_graph.generate;
 
 import 'dart:io' hide File;
 import 'dart:io' as io;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/file_system/physical_file_system.dart';
+import 'package:analyzer/src/codegen/tools.dart';
 import 'package:analyzer/src/generated/constant.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/java_io.dart';
 import 'package:analyzer/src/generated/sdk.dart';
 import 'package:analyzer/src/generated/sdk_io.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/source_io.dart';
 import 'package:path/path.dart' as path;
+import 'package:path/path.dart';
 
 /**
  * Generate the target .dot file.
  */
 main() {
-  new Driver().generateFile();
+  String script = Platform.script.toFilePath(windows: Platform.isWindows);
+  String pkgPath = normalize(join(dirname(script), '..', '..'));
+  target.generate(pkgPath);
 }
 
+final GeneratedFile target = new GeneratedFile(
+    'tool/task_dependency_graph/tasks.dot',
+    (String pkgPath) => new Driver(pkgPath).generateFileContents());
+
 typedef void GetterFinderCallback(PropertyAccessorElement element);
 
 class Driver {
   PhysicalResourceProvider resourceProvider;
   AnalysisContext context;
   InterfaceType resultDescriptorType;
   InterfaceType listOfResultDescriptorType;
   ClassElement enginePluginClass;
   CompilationUnitElement taskUnitElement;
   InterfaceType extensionPointIdType;
   final String rootDir;
 
-  Driver()
-      : rootDir =
-            findRoot(Platform.script.toFilePath(windows: Platform.isWindows));
+  Driver(String pkgPath) : rootDir = new Directory(pkgPath).absolute.path;
 
   /**
    * Get an [io.File] object corresponding to the file in which the generated
    * graph should be output.
    */
   io.File get file => new io.File(
       path.join(rootDir, 'tool', 'task_dependency_graph', 'tasks.dot'));
 
   /**
-   * Determine if the output [file] contains the expected contents.
-   */
-  bool checkFile() {
-    String expectedContents = generateFileContents();
-    String actualContents = file.readAsStringSync();
-    // Normalize Windows line endings to Unix line endings so that the
-    // comparison doesn't fail on Windows.
-    actualContents = actualContents.replaceAll('\r\n', '\n');
-    return expectedContents == actualContents;
-  }
-
-  /**
    * Starting at [node], find all calls to registerExtension() which refer to
    * the given [extensionIdVariable], and execute [callback] for the associated
    * result descriptors.
    */
   void findExtensions(AstNode node, TopLevelVariableElement extensionIdVariable,
       void callback(descriptorName)) {
     Set<PropertyAccessorElement> resultDescriptors =
         new Set<PropertyAccessorElement>();
     node.accept(new ExtensionFinder(
         resultDescriptorType, extensionIdVariable, resultDescriptors.add));
@@ skipping 27 matching lines @@
       AstNode node, void callback(String descriptorName)) {
     Set<PropertyAccessorElement> resultDescriptors =
         new Set<PropertyAccessorElement>();
     node.accept(new GetterFinder(resultDescriptorType, resultDescriptors.add));
     for (PropertyAccessorElement resultDescriptor in resultDescriptors) {
       callback(resultDescriptor.name);
     }
   }
 
   /**
-   * Generate the task dependency graph and write it to the output [file].
-   */
-  void generateFile() {
-    String fileContents = generateFileContents();
-    file.writeAsStringSync(fileContents);
-  }
-
-  /**
    * Generate the task dependency graph and return it as a [String].
    */
   String generateFileContents() {
     List<String> lines = <String>[];
     resourceProvider = PhysicalResourceProvider.INSTANCE;
     DartSdk sdk = DirectoryBasedDartSdk.defaultSdk;
     context = AnalysisEngine.instance.createAnalysisContext();
     String packageRootPath;
     if (Platform.packageRoot.isNotEmpty) {
       packageRootPath = Platform.packageRoot;
@@ skipping 117 matching lines @@
             in taskUnitElement.topLevelVariables) {
           if (variable.name == extensionPointId) {
             return variable;
           }
         }
       }
     }
     throw new Exception(
         'Could not find extension ID corresponding to $resultListGetterName');
   }
-
-  /**
-   * Find the root directory of the analyzer package by proceeding
-   * upward to the 'tool' dir, and then going up one more directory.
-   */
-  static String findRoot(String pathname) {
-    while (path.basename(pathname) != 'tool') {
-      String parent = path.dirname(pathname);
-      if (parent.length >= pathname.length) {
-        throw new Exception("Can't find root directory");
-      }
-      pathname = parent;
-    }
-    return path.dirname(pathname);
-  }
 }
 
 /**
  * Visitor that finds calls that register extension points.  Specifically, we
  * look for calls of the form `method(extensionIdVariable, resultDescriptor)`,
  * where `resultDescriptor` has type [resultDescriptorType], and we pass the
  * corresponding result descriptor names to [callback].
  */
 class ExtensionFinder extends GeneralizingAstVisitor {
   final InterfaceType resultDescriptorType;
@@ skipping 42 matching lines @@
   @override
   visitIdentifier(Identifier node) {
     Element element = node.staticElement;
     if (element is PropertyAccessorElement &&
         element.isGetter &&
         element.returnType.isSubtypeOf(type)) {
       callback(element);
     }
   }
 }