fixes #183, remove our InMemory* in favor of analyzer's impl

lib/src/dependency_graph.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.
 
 /// Tracks the shape of the import/export graph and dependencies between files.
 library dev_compiler.src.dependency_graph;
 
 import 'dart:collection' show HashSet;
 
 import 'package:analyzer/analyzer.dart' show parseDirectives;
@@ skipping 72 matching lines @@
   final SourceGraph graph;
 
   /// Resolved URI for this node.
   final Uri uri;
 
   /// Resolved source from the analyzer. We let the analyzer internally track
   /// for modifications to the source files.
   Source _source;
   Source get source => _source;
 
-  String get contents => graph._context.getContents(source).data;
+  String get contents => graph._context.getContents(_source).data;
 
   /// Last stamp read from `source.modificationStamp`.
-  int _lastStamp = 0;
+  /// This starts at -1, because analyzer uses that for files that don't exist.
+  int _lastStamp = -1;
 
   /// A hash used to help browsers cache the output that would be produced from
   /// building this node.
   String cachingHash;
 
   /// Whether we need to rebuild this source file.
   bool needsRebuild = false;
 
   /// Whether the structure of dependencies from this node (scripts, imports,
   /// exports, or parts) changed after we reparsed its contents.
@@ skipping 10 matching lines @@
 
   SourceNode(this.graph, this.uri, this._source);
 
   /// Check for whether the file has changed and, if so, mark [needsRebuild] and
   /// [structureChanged] as necessary.
   void update() {
     if (_source == null) {
       _source = graph._context.sourceFactory.forUri(Uri.encodeFull('$uri'));
       if (_source == null) return;
     }
-    int newStamp = _source.modificationStamp;
-    if (newStamp > _lastStamp) {
+
+    int newStamp = _source.exists() ? _source.modificationStamp : -1;
+    if (newStamp > _lastStamp || newStamp == -1 && _lastStamp != -1) {
       // If the timestamp changed, read the file from disk and cache it.
       // We don't want the source text to change during compilation.
       saveUpdatedContents();
       _lastStamp = newStamp;
       needsRebuild = true;
     }
   }
 
   void saveUpdatedContents() {}
 
@@ skipping 65 matching lines @@
         newResources.add(graph.nodeFromUri(uri.resolve(tag.attributes['src'])));
       }
       if (!_same(newResources, resources)) {
         structureChanged = true;
         resources = newResources;
       }
     }
   }
 
   void _reportError(SourceGraph graph, String message, Node node) {
-    graph._reporter.enterHtml(source.uri);
+    graph._reporter.enterHtml(_source.uri);
     var span = node.sourceSpan;
     graph._reporter.log(
         new Message(message, Level.SEVERE, span.start.offset, span.end.offset));
     graph._reporter.leaveHtml();
   }
 }
 
 /// A node representing a Dart library or part.
 class DartSourceNode extends SourceNode {
   /// Set of imported libraries (empty for part files).
@@ skipping 20 matching lines @@
 
   LibraryInfo info;
 
   // TODO(jmesserly): it would be nice to not keep all sources in memory at
   // once, but how else can we ensure a consistent view across a given
   // compile? One different from dev_compiler vs analyzer is that our
   // messages later in the compiler need the original source text to print
   // spans. We also read source text ourselves to parse directives.
   // But we could discard it after that point.
   void saveUpdatedContents() {
-    graph._context.setContents(source, source.contents.data);
+    graph._context.setContents(_source, _source.contents.data);
   }
 
   @override
   void update() {
     super.update();
 
-    if (needsRebuild && contents != null) {
+    if (needsRebuild) {
       graph._reporter.clearLibrary(uri);
       // If the defining compilation-unit changed, the structure might have
       // changed.
-      var unit = parseDirectives(contents, name: source.fullName);
+      var unit = parseDirectives(contents, name: _source.fullName);
       var newImports = new Set<DartSourceNode>();
       var newExports = new Set<DartSourceNode>();
       var newParts = new Set<DartSourceNode>();
       for (var d in unit.directives) {
         // Nothing to do for parts.
         if (d is PartOfDirective) return;
         if (d is LibraryDirective) continue;
 
         // `dart:core` and other similar URLs only contain a name, but it is
         // meant to be a folder when resolving relative paths from it.
         var targetUri = uri.scheme == 'dart' && uri.pathSegments.length == 1
             ? Uri.parse('$uri/').resolve(d.uri.stringValue)
             : uri.resolve(d.uri.stringValue);
         var target =
-            ParseDartTask.resolveDirective(graph._context, source, d, null);
+            ParseDartTask.resolveDirective(graph._context, _source, d, null);
         if (target != null) {
           if (targetUri != target.uri) print(">> ${target.uri} $targetUri");
         }
         var node = graph.nodes.putIfAbsent(
             targetUri, () => new DartSourceNode(graph, targetUri, target));
         //var node = graph.nodeFromUri(targetUri);
-        if (node.source == null || !node.source.exists()) {
+        if (node._source == null || !node._source.exists()) {
           _reportError(graph, 'File $targetUri not found', unit, d);
         }
 
         if (d is ImportDirective) {
           newImports.add(node);
         } else if (d is ExportDirective) {
           newExports.add(node);
         } else if (d is PartDirective) {
           newParts.add(node);
         }
@@ skipping 37 matching lines @@
       // However we do a full update to make it easier to adjust when users
       // switch a file from a part to a library.
       p.update();
       if (p.needsRebuild) needsRebuild = true;
     }
   }
 
   void _reportError(
       SourceGraph graph, String message, CompilationUnit unit, AstNode node) {
     graph._reporter
-      ..enterLibrary(source.uri)
-      ..enterCompilationUnit(unit, source)
+      ..enterLibrary(_source.uri)
+      ..enterCompilationUnit(unit, _source)
       ..log(new Message(message, Level.SEVERE, node.offset, node.end))
       ..leaveCompilationUnit()
       ..leaveLibrary();
   }
 }
 
 /// Represents a runtime resource from our compiler that is needed to run an
 /// application.
 class ResourceSourceNode extends SourceNode {
   ResourceSourceNode(graph, uri, source) : super(graph, uri, source);
@@ skipping 151 matching lines @@
   'dart._interceptors',
   'dart._native_typed_data',
   */
 ];
 
 /// Runtime files added to applications when running in server mode.
 final runtimeFilesForServerMode = new List<String>.from(defaultRuntimeFiles)
   ..addAll(const ['messages_widget.js', 'messages.css']);
 
 final _log = new Logger('dev_compiler.dependency_graph');