work in progress: observable implementation using detailed change records

lib/src/compiler.dart

 // Copyright (c) 2012, 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 compiler;
 
 import 'dart:async';
 import 'dart:collection' show SplayTreeMap;
+import 'dart:uri';
 import 'package:html5lib/dom.dart';
 import 'package:html5lib/parser.dart';
 
 import 'analyzer.dart';
 import 'code_printer.dart';
 import 'codegen.dart' as codegen;
 import 'directive_parser.dart' show parseDartCode;
 import 'emitters.dart';
 import 'file_system.dart';
 import 'file_system/path.dart';
 import 'files.dart';
 import 'html_cleaner.dart';
 import 'info.dart';
 import 'messages.dart';
+import 'observable_transform.dart' show transformObservables;
 import 'options.dart';
 import 'utils.dart';
 
 /**
  * Parses an HTML file [contents] and returns a DOM-like tree.
  * Note that [contents] will be a [String] if coming from a browser-based
  * [FileSystem], or it will be a [List<int>] if running on the command line.
  *
  * Adds emitted error/warning to [messages], if [messages] is supplied.
  */
@@ skipping 13 matching lines @@
 class Compiler {
   final FileSystem fileSystem;
   final CompilerOptions options;
   final List<SourceFile> files = <SourceFile>[];
   final List<OutputFile> output = <OutputFile>[];
 
   Path _mainPath;
   PathInfo _pathInfo;
   Messages _messages;
 
+  FutureGroup _tasks;
+  Set _processed;
+
   /** Information about source [files] given their href. */
   final Map<Path, FileInfo> info = new SplayTreeMap<Path, FileInfo>();
 
  /**
   * Creates a compiler with [options] using [fileSystem].
   *
   * Adds emitted error/warning messages to [messages], if [messages] is
   * supplied.
   */
   Compiler(this.fileSystem, this.options, this._messages, {String currentDir}) {
@@ skipping 26 matching lines @@
 
   /** Compile the application starting from the given [mainFile]. */
   Future run() {
     if (_mainPath.filename.endsWith('.dart')) {
       _messages.error("Please provide an HTML file as your entry point.",
           null, file: _mainPath);
       return new Future.immediate(null);
     }
     return _parseAndDiscover(_mainPath).then((_) {
       _analyze();
+      _transformDart();
       _emit();
     });
   }
 
   /**
    * Asynchronously parse [inputFile] and transitively discover web components
    * to load and parse. Returns a future that completes when all files are
    * processed.
    */
   Future _parseAndDiscover(Path inputFile) {
-    var tasks = new FutureGroup();
-    bool isEntry = !options.componentsOnly;
+    _tasks = new FutureGroup();
+    _processed = new Set();
+    _processed.add(inputFile);
+    _tasks.add(_parseHtmlFile(inputFile).then(_processHtmlFile));
+    return _tasks.future;
+  }
 
-    var processed = new Set();
-    processHtmlFile(SourceFile file) {
-      if (file == null) return;
-      if (!_pathInfo.checkInputPath(file.path, _messages)) return;
+  bool _shouldProcessFile(SourceFile file) =>
+      file != null && _pathInfo.checkInputPath(file.path, _messages);
 
-      files.add(file);
+  void _processHtmlFile(SourceFile file) {
+    if (!_shouldProcessFile(file)) return;
 
-      var fileInfo = _time('Analyzed definitions', file.path,
-          () => analyzeDefinitions(file, _messages, isEntryPoint: isEntry));
-      isEntry = false;
-      info[file.path] = fileInfo;
+    bool isEntryPoint = _processed.length == 1;
 
-      // Load component files referenced by [file].
-      for (var href in fileInfo.componentLinks) {
-        if (!processed.contains(href)) {
-          processed.add(href);
-          tasks.add(_parseHtmlFile(href).then(processHtmlFile));
-        }
-      }
+    files.add(file);
 
-      // Load .dart files being referenced in the page.
-      var src = fileInfo.externalFile;
-      if (src != null && !processed.contains(src)) {
-        processed.add(src);
-        tasks.add(_parseDartFile(src).then(_addDartFile));
-      }
+    var fileInfo = _time('Analyzed definitions', file.path,
+        () => analyzeDefinitions(file, _messages, isEntryPoint: isEntryPoint));
+    info[file.path] = fileInfo;
 
-      // Load .dart files being referenced in components.
-      for (var component in fileInfo.declaredComponents) {
-        var src = component.externalFile;
-        if (src != null && !processed.contains(src)) {
-          processed.add(src);
-          tasks.add(_parseDartFile(src).then(_addDartFile));
-        }
+    _processImports(fileInfo);
+
+    // Load component files referenced by [file].
+    for (var href in fileInfo.componentLinks) {
+      if (!_processed.contains(href)) {
+        _processed.add(href);
+        _tasks.add(_parseHtmlFile(href).then(_processHtmlFile));
       }
     }
 
-    processed.add(inputFile);
-    tasks.add(_parseHtmlFile(inputFile).then(processHtmlFile));
-    return tasks.future;
+    // Load .dart files being referenced in the page.
+    var src = fileInfo.externalFile;
+    if (src != null && !_processed.contains(src)) {
+      _processed.add(src);
+      _tasks.add(_parseDartFile(src).then(_processDartFile));
+    }
+
+    // Load .dart files being referenced in components.
+    for (var component in fileInfo.declaredComponents) {
+      var src = component.externalFile;
+      if (src != null && !_processed.contains(src)) {
+        _processed.add(src);
+        _tasks.add(_parseDartFile(src).then(_processDartFile));
+      }
+    }
   }
 
   /** Asynchronously parse [path] as an .html file. */
   Future<SourceFile> _parseHtmlFile(Path path) {
     return fileSystem.readTextOrBytes(path).then((source) {
           var file = new SourceFile(path);
           file.document = _time('Parsed', path,
               () => parseHtml(source, path, _messages));
           return file;
         })
         .catchError((e) => _readError(e, path));
   }
 
   /** Parse [filename] and treat it as a .dart file. */
   Future<SourceFile> _parseDartFile(Path path) {
     return fileSystem.readText(path)
         .then((code) => new SourceFile(path, isDart: true)..code = code)
         .catchError((e) => _readError(e, path));
   }
 
   SourceFile _readError(error, Path path) {
     _messages.error('exception while reading file, original message:\n $error',
         null, file: path);
 
     return null;
   }
 
-  void _addDartFile(SourceFile dartFile) {
-    if (dartFile == null) return;
-    if (!_pathInfo.checkInputPath(dartFile.path, _messages)) return;
+  void _processDartFile(SourceFile dartFile) {
+    if (!_shouldProcessFile(dartFile)) return;
 
     files.add(dartFile);
 
     var fileInfo = new FileInfo(dartFile.path);
     info[dartFile.path] = fileInfo;
-    fileInfo.inlinedCode = dartFile.code;
-    fileInfo.userCode = parseDartCode(fileInfo.inlinedCode,
-        fileInfo.path, messages:_messages);
-    if (fileInfo.userCode.partOf != null) {
-      _messages.error('expected a library, not a part.', null,
-          file: dartFile.path);
+    fileInfo.userCode = parseDartCode(dartFile.code,
+        fileInfo.path, messages: _messages);
+
+    _processImports(fileInfo);
+  }
+
+  void _processImports(FileInfo fileInfo) {
+    if (fileInfo.userCode == null) return;
+
+    for (var directive in fileInfo.userCode.directives) {
+      var src = _getDirectivePath(fileInfo, directive.uri);
+      if (src == null) continue;
+      if (!_processed.contains(src)) {
+        _processed.add(src);
+        _tasks.add(_parseDartFile(src).then(_processDartFile));
+      }
     }
   }
 
+  Path _getDirectivePath(LibraryInfo libInfo, String uri) {
+    if (uri.startsWith('dart:')) return null;
+
+    if (uri.startsWith('package:')) {
+      // Don't process our own package -- we'll implement @observable manually.
+      if (uri.startsWith('package:web_ui/')) return null;
+
+      return _mainPath.directoryPath.join(new Path('packages'))
+          .join(new Path(uri.substring(8)));
+    } else {
+      return libInfo.inputPath.directoryPath.join(new Path(uri));
+    }
+  }
+
+  /**
+   * Transform Dart source code.
+   * Currently, the only transformation is [transformObservables].
+   * Calls _emitModifiedDartFiles to write the transformed files.
+   */
+  void _transformDart() {
+    var libraries = <LibraryInfo>[];
+    for (var sourceFile in files) {
+      var file = info[sourceFile.path];
+      libraries.add(file);
+      libraries.addAll(file.declaredComponents);
+    }
+    // Prefer to process the .dart file if it is external.
+    for (var i = 0; i < libraries.length; i++) {
+      var external = libraries[i].externalCode;
+      if (external != null) libraries[i] = external;
+    }
+    libraries = libraries.where((lib) => lib.userCode != null).toList();
+
+    var transformed = [];
+    for (var library in libraries) {
+      // TODO(jmesserly): does it make sense for us to warn about Dart parse
+      // errors? It seems useful, but the VM or dart2js would still issue these
+      // messages anyway later.
+      if (transformObservables(library, messages: _messages)) {
+        transformed.add(library);
+      }
+    }
+
+    _emitModifiedDartFiles(libraries, transformed);
+  }
+
+  /**
+   * This method rewrites imports transitively for any modified dart files,
+   * and queues the [outputs] to be written. This will not write files that
+   * are handled by [WebComponentEmitter] and [MainPageEmitter].
+   */
+  void _emitModifiedDartFiles(List<LibraryInfo> libraries,
+      List<FileInfo> transformed) {
+
+    if (transformed.length == 0) return;
+
+    // Compute files that reference each file, then use this information to
+    // flip the modified bit transitively. This is a lot simpler than trying
+    // to compute it the other way because of circular references.
+    for (var library in libraries) {
+      for (var directive in library.userCode.directives) {
+        var importPath = _getDirectivePath(library, directive.uri);
+        if (importPath == null) continue;
+
+        info[importPath].referencedBy.add(library);
+      }
+    }
+
+    // Propegate the modified bit to anything that references a modified file.
+    void setModified(LibraryInfo library) {
+      if (library.modified) return;
+      library.modified = true;
+      library.referencedBy.forEach(setModified);
+    }
+    transformed.forEach(setModified);
+
+    for (var library in libraries) {
+      // We don't need this anymore, so free it.
+      library.referencedBy = null;
+
+      if (!library.modified) continue;
+
+      var fileOutputPath = _pathInfo.outputLibraryPath(library);
+
+      // Fix imports of modified files to use the generated path.
+      for (var directive in library.userCode.directives) {
+        var importPath = _getDirectivePath(library, directive.uri);
+        if (importPath == null) continue;
+        var importInfo = info[importPath];
+
+        if (importInfo.modified && !directive.generated) {
+          // Use the generated URI for this file.
+          directive.generated = true;
+          directive.uri = _pathInfo.outputLibraryPath(importInfo)
+              .relativeTo(fileOutputPath.directoryPath).toString();
+        }
+      }
+
+      // Components will get emitted by WebComponentEmitter, and the
+      // entry point will get emitted by MainPageEmitter.
+      // So we only need to worry about other .dart files.
+      if (library is FileInfo && library.htmlFile == null) {
+        // Add an output file for the transformed .dart code:
+        output.add(new OutputFile(fileOutputPath,
+            emitDartFile(library, _pathInfo), source: library.inputPath));
+      }
+    }
+  }
+
   /** Run the analyzer on every input html file. */
   void _analyze() {
     var uniqueIds = new IntIterator();
     for (var file in files) {
       if (file.isDart) continue;
       _time('Analyzed contents', file.path,
           () => analyzeFile(file, info, uniqueIds, _messages));
     }
   }
 
@@ skipping 102 matching lines @@
         _messages.warning('file should start with <!DOCTYPE html> '
             'to avoid the possibility of it being parsed in quirks mode in IE. '
             'See http://www.w3.org/TR/html5-diff/#doctype',
             doctype.sourceSpan, file: file.path);
       }
     }
     document.nodes.insertAt(commentIndex, parseFragment(
         '\n<!-- This file was auto-generated from ${file.path}. -->\n'));
   }
 }
-
-