Fix in multi-package-resolver to support files that will be created later (graph

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;
 import 'package:analyzer/src/generated/ast.dart'
     show
+        AstNode,
+        CompilationUnit,
+        ExportDirective,
+        Identifier,
+        ImportDirective,
         LibraryDirective,
-        ImportDirective,
-        ExportDirective,
         PartDirective,
-        PartOfDirective,
-        CompilationUnit,
-        Identifier;
+        PartOfDirective;
 import 'package:analyzer/src/generated/engine.dart'
     show ParseDartTask, AnalysisContext;
 import 'package:analyzer/src/generated/source.dart' show Source, SourceKind;
-import 'package:html5lib/dom.dart' show Document;
+import 'package:html5lib/dom.dart' show Document, Node;
 import 'package:html5lib/parser.dart' as html;
 import 'package:logging/logging.dart' show Level;
 import 'package:path/path.dart' as path;
 import 'package:source_span/source_span.dart' show SourceSpan;
 
 import 'info.dart';
 import 'options.dart';
 import 'report.dart';
 import 'utils.dart';
 
@@ skipping 31 matching lines @@
   }
 }
 
 /// A node in the import graph representing a source file.
 abstract class SourceNode {
   /// 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.
-  final Source source;
+  Source _source;
+  Source get source => _source;
 
   /// Last stamp read from `source.modificationStamp`.
   int _lastStamp = 0;
 
   /// 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.
   bool structureChanged = false;
 
   /// Direct dependencies in the [SourceGraph]. These include script tags for
   /// [HtmlSourceNode]s; and imports, exports and parts for [DartSourceNode]s.
   Iterable<SourceNode> get allDeps => const [];
 
   /// Like [allDeps] but excludes parts for [DartSourceNode]s. For many
   /// operations we mainly care about dependencies at the library level, so
   /// parts are excluded from this list.
   Iterable<SourceNode> get depsWithoutParts => const [];
 
-  SourceNode(this.uri, this.source);
+  SourceNode(this.uri, this._source);
 
   /// Check for whether the file has changed and, if so, mark [needsRebuild] and
   /// [structureChanged] as necessary.
   void update(SourceGraph graph) {
-    int newStamp = source.modificationStamp;
+    if (_source == null) {
+      _source = graph._context.sourceFactory.forUri(Uri.encodeFull('$uri'));
+      if (_source == null) return;
+    }
+    int newStamp = _source.modificationStamp;
     if (newStamp > _lastStamp) {
       _lastStamp = newStamp;
       needsRebuild = true;
     }
   }
 
   String toString() {
     var simpleUri = uri.scheme == 'file' ? path.relative(uri.path) : "$uri";
     return '[$runtimeType: $simpleUri]';
   }
@@ skipping 30 matching lines @@
   void update(SourceGraph graph) {
     super.update(graph);
     if (needsRebuild) {
       graph._reporter.clearHtml(uri);
       document = html.parse(source.contents.data, generateSpans: true);
       var newScripts = new Set<DartSourceNode>();
       var tags = document.querySelectorAll('script[type="application/dart"]');
       for (var script in tags) {
         var src = script.attributes['src'];
         if (src == null) {
-          graph._reporter.enterHtml(source.uri);
-          graph._reporter.log(new DependencyGraphError(
-              'inlined script tags not supported at this time '
+          _reportError(graph, 'inlined script tags not supported at this time '
               '(see https://github.com/dart-lang/dart-dev-compiler/issues/54).',
-              script.sourceSpan));
-          graph._reporter.leaveHtml();
+              script);
           continue;
         }
         var node = graph.nodeFromUri(uri.resolve(src));
         if (node == null || !node.source.exists()) {
-          graph._reporter.enterHtml(source.uri);
-          graph._reporter.log(new DependencyGraphError(
-              'Script file $src not found', script.sourceSpan));
-          graph._reporter.leaveHtml();
+          _reportError(graph, 'Script file $src not found', script);
         }
         if (node != null) newScripts.add(node);
       }
 
       if (!_same(newScripts, scripts)) {
         structureChanged = true;
         scripts = newScripts;
       }
     }
   }
+
+  void _reportError(SourceGraph graph, String message, Node node) {
+    graph._reporter.enterHtml(source.uri);
+    graph._reporter.log(new DependencyGraphError(message, node.sourceSpan));
+    graph._reporter.leaveHtml();
+  }
 }
 
 /// A node representing a Dart library or part.
 class DartSourceNode extends SourceNode {
   /// Set of imported libraries (empty for part files).
   Set<DartSourceNode> imports = new Set<DartSourceNode>();
 
   /// Set of exported libraries (empty for part files).
   Set<DartSourceNode> exports = new Set<DartSourceNode>();
 
@@ skipping 23 matching lines @@
       // If the defining compilation-unit changed, the structure might have
       // changed.
       var unit = parseDirectives(source.contents.data, 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);
-        var uri = target.uri;
-        var node =
-            graph.nodes.putIfAbsent(uri, () => new DartSourceNode(uri, target));
-        if (!node.source.exists()) {
-          graph._reporter.enterLibrary(source.uri);
-          graph._reporter.log(new DependencyGraphError(
-              'File $uri not found', spanForNode(unit, source, d)));
-          graph._reporter.leaveLibrary();
+        if (target != null) {
+          if (targetUri != target.uri) print(">> ${target.uri} $targetUri");
+        }
+        var node = graph.nodes.putIfAbsent(
+            targetUri, () => new DartSourceNode(targetUri, target));
+        //var node = graph.nodeFromUri(targetUri);
+        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 32 matching lines @@
     // internally:
     for (var p in parts) {
       // Technically for parts we don't need to look at the contents. If they
       // contain imports, exports, or parts, we'll ignore them in our crawling.
       // 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(graph);
       if (p.needsRebuild) needsRebuild = true;
     }
   }
+
+  void _reportError(
+      SourceGraph graph, String message, CompilationUnit unit, AstNode node) {
+    graph._reporter.enterLibrary(source.uri);
+    graph._reporter.log(
+        new DependencyGraphError(message, spanForNode(unit, source, node)));
+    graph._reporter.leaveLibrary();
+  }
 }
 
 /// Represents a runtime resource from our compiler that is needed to run an
 /// application.
 class ResourceSourceNode extends SourceNode {
   ResourceSourceNode(uri, source) : super(uri, source);
 }
 
 /// Updates the structure and `needsRebuild` marks in nodes of [graph] reachable
 /// from [start].
@@ skipping 113 matching lines @@
   helper(start);
 }
 
 bool _same(Set a, Set b) => a.length == b.length && a.containsAll(b);
 
 /// An error message discovered while parsing the dependencies between files.
 class DependencyGraphError extends MessageWithSpan {
   const DependencyGraphError(String message, SourceSpan span)
       : super(message, Level.SEVERE, span);
 }