Rework codegen tools to avoid relying on CWD; integrate with task model graph.

pkg/analyzer/lib/src/codegen/tools.dart

 // Copyright (c) 2014, 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.
 
 /**
  * Tools for generating code in analyzer and analysis server.
  */
 library analyzer.src.codegen.tools;
 
 import 'dart:io';
 
 import 'package:html/dom.dart' as dom;
 import 'package:path/path.dart';
 
 import 'html.dart';
 import 'text_formatter.dart';
 
+final RegExp trailingSpacesInLineRegExp = new RegExp(r' +$', multiLine: true);
 final RegExp trailingWhitespaceRegExp = new RegExp(r'[\n ]+$');
-final RegExp trailingSpacesInLineRegExp = new RegExp(r' +$', multiLine: true);
 
 /**
  * Join the given strings using camelCase.  If [doCapitalize] is true, the first
  * part will be capitalized as well.
  */
 String camelJoin(List<String> parts, {bool doCapitalize: false}) {
   List<String> upcasedParts = <String>[];
   for (int i = 0; i < parts.length; i++) {
     if (i == 0 && !doCapitalize) {
       upcasedParts.add(parts[i]);
     } else {
       upcasedParts.add(capitalize(parts[i]));
     }
   }
   return upcasedParts.join();
 }
 
 /**
  * Capitalize and return the passed String.
  */
 String capitalize(String string) {
   return string[0].toUpperCase() + string.substring(1);
 }
 
 /**
  * Type of functions used to compute the contents of a set of generated files.
+ * [pkgPath] is the path to the current package.
  */
-typedef Map<String, FileContentsComputer> DirectoryContentsComputer();
+typedef Map<String, FileContentsComputer> DirectoryContentsComputer(
+    String pkgPath);
 
 /**
  * Type of functions used to compute the contents of a generated file.
+ * [pkgPath] is the path to the current package.
  */
-typedef String FileContentsComputer();
+typedef String FileContentsComputer(String pkgPath);
 
 /**
  * Mixin class for generating code.
  */
 class CodeGenerator {
   _CodeGeneratorState _state;
 
   /**
    * Settings that specialize code generation behavior for a given
    * programming language.
@@ skipping 191 matching lines @@
   CodeGeneratorSettings(
       {this.languageName: 'java',
       this.lineCommentLineLeader: '// ',
       this.docCommentStartMarker: '/**',
       this.docCommentLineLeader: ' * ',
       this.docCommentEndMarker: ' */',
       this.commentLineLength: 99,
       this.indent: '  '});
 }
 
+/**
+ * Abstract base class representing behaviors common to generated files and
+ * generated directories.
+ */
 abstract class GeneratedContent {
-  FileSystemEntity get outputFile;
-  bool check();
-  void generate();
+  /**
+   * Check whether the [output] has the correct contents, and return true if it
+   * does.  [pkgPath] is the path to the current package.
+   */
+  bool check(String pkgPath);
+
+  /**
+   * Replace the [output] with the correct contents.  [pkgPath] is the path to
+   * the current package.
+   */
+  void generate(String pkgPath);
+
+  /**
+   * Get a [FileSystemEntity] representing the output file or directory.
+   * [pkgPath] is the path to the current package.
+   */
+  FileSystemEntity output(String pkgPath);
 }
 
 /**
  * Class representing a single output directory (either generated code or
  * generated HTML). No other content should exist in the directory.
  */
 class GeneratedDirectory extends GeneratedContent {
   /**
    * The path to the directory that will have the generated content.
    */
   final String outputDirPath;
 
   /**
    * Callback function that computes the directory contents.
    */
   final DirectoryContentsComputer directoryContentsComputer;
 
   GeneratedDirectory(this.outputDirPath, this.directoryContentsComputer);
 
-  /**
-   * Get a Directory object representing the output directory.
-   */
-  Directory get outputFile =>
-      new Directory(joinAll(posix.split(outputDirPath)));
-
-  /**
-   * Check whether the directory has the correct contents, and return true if it
-   * does.
-   */
   @override
-  bool check() {
-    Map<String, FileContentsComputer> map = directoryContentsComputer();
+  bool check(String pkgPath) {
+    Directory outputDirectory = output(pkgPath);
+    Map<String, FileContentsComputer> map = directoryContentsComputer(pkgPath);
     try {
       for (String file in map.keys) {
         FileContentsComputer fileContentsComputer = map[file];
-        String expectedContents = fileContentsComputer();
-        File outputFile =
-            new File(joinAll(posix.split(posix.join(outputDirPath, file))));
+        String expectedContents = fileContentsComputer(pkgPath);
+        File outputFile = new File(posix.join(outputDirectory.path, file));
         String actualContents = outputFile.readAsStringSync();
         // Normalize Windows line endings to Unix line endings so that the
         // comparison doesn't fail on Windows.
         actualContents = actualContents.replaceAll('\r\n', '\n');
         if (expectedContents != actualContents) {
           return false;
         }
       }
       int nonHiddenFileCount = 0;
-      outputFile
+      outputDirectory
           .listSync(recursive: false, followLinks: false)
           .forEach((FileSystemEntity fileSystemEntity) {
         if (fileSystemEntity is File &&
             !basename(fileSystemEntity.path).startsWith('.')) {
           nonHiddenFileCount++;
         }
       });
       if (nonHiddenFileCount != map.length) {
         // The number of files generated doesn't match the number we expected to
         // generate.
         return false;
       }
     } catch (e) {
       // There was a problem reading the file (most likely because it didn't
       // exist).  Treat that the same as if the file doesn't have the expected
       // contents.
       return false;
     }
     return true;
   }
 
-  /**
-   * Replace the directory with the correct contents.  [spec] is the "tool/spec"
-   * directory.  If [spec] is unspecified, it is assumed to be the directory
-   * containing Platform.executable.
-   */
   @override
-  void generate() {
+  void generate(String pkgPath) {
+    Directory outputDirectory = output(pkgPath);
     try {
       // delete the contents of the directory (and the directory itself)
-      outputFile.deleteSync(recursive: true);
+      outputDirectory.deleteSync(recursive: true);
     } catch (e) {
       // Error caught while trying to delete the directory, this can happen if
       // it didn't yet exist.
     }
     // re-create the empty directory
-    outputFile.createSync(recursive: true);
+    outputDirectory.createSync(recursive: true);
 
     // generate all of the files in the directory
-    Map<String, FileContentsComputer> map = directoryContentsComputer();
+    Map<String, FileContentsComputer> map = directoryContentsComputer(pkgPath);
     map.forEach((String file, FileContentsComputer fileContentsComputer) {
-      File outputFile = new File(joinAll(posix.split(outputDirPath + file)));
-      outputFile.writeAsStringSync(fileContentsComputer());
+      File outputFile = new File(posix.join(outputDirectory.path, file));
+      outputFile.writeAsStringSync(fileContentsComputer(pkgPath));
     });
   }
+
+  @override
+  Directory output(String pkgPath) =>
+      new Directory(join(pkgPath, joinAll(posix.split(outputDirPath))));
 }
 
 /**
  * Class representing a single output file (either generated code or generated
  * HTML).
  */
 class GeneratedFile extends GeneratedContent {
   /**
    * The output file to which generated output should be written, relative to
    * the "tool/spec" directory.  This filename uses the posix path separator
    * ('/') regardless of the OS.
    */
   final String outputPath;
 
   /**
    * Callback function which computes the file.
    */
   final FileContentsComputer computeContents;
 
   GeneratedFile(this.outputPath, this.computeContents);
 
-  /**
-   * Get a File object representing the output file.
-   */
-  File get outputFile => new File(joinAll(posix.split(outputPath)));
-
-  /**
-   * Check whether the file has the correct contents, and return true if it
-   * does.
-   */
   @override
-  bool check() {
-    String expectedContents = computeContents();
+  bool check(String pkgPath) {
+    File outputFile = output(pkgPath);
+    String expectedContents = computeContents(pkgPath);
     try {
       String actualContents = outputFile.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;
     } catch (e) {
       // There was a problem reading the file (most likely because it didn't
       // exist).  Treat that the same as if the file doesn't have the expected
       // contents.
       return false;
     }
   }
 
-  /**
-   * Replace the file with the correct contents.  [spec] is the "tool/spec"
-   * directory.  If [spec] is unspecified, it is assumed to be the directory
-   * containing Platform.executable.
-   */
-  void generate() {
-    outputFile.writeAsStringSync(computeContents());
+  @override
+  void generate(String pkgPath) {
+    output(pkgPath).writeAsStringSync(computeContents(pkgPath));
   }
+
+  @override
+  File output(String pkgPath) =>
+      new File(join(pkgPath, joinAll(posix.split(outputPath))));
 }
 
 /**
  * Mixin class for generating HTML representations of code that are suitable
  * for enclosing inside a <pre> element.
  */
 abstract class HtmlCodeGenerator {
   _HtmlCodeGeneratorState _state;
 
   /**
@@ skipping 122 matching lines @@
     if (lines.last.isEmpty) {
       lines.removeLast();
       buffer.add(new dom.Text(lines.join('\n$indent') + '\n'));
       indentNeeded = true;
     } else {
       buffer.add(new dom.Text(lines.join('\n$indent')));
       indentNeeded = false;
     }
   }
 }