Add JavaScriptSourceNode to represent runtime libraries (fixes #85)

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 32 matching lines @@
 
   SourceGraph(this._context, this._options);
 
   /// Node associated with a resolved [uri].
   SourceNode nodeFromUri(Uri uri) {
     var uriString = Uri.encodeFull('$uri');
     return nodes.putIfAbsent(uri, () {
       var source = _context.sourceFactory.forUri(uriString);
       var extension = path.extension(uriString);
       if (extension == '.html') {
-        return new HtmlSourceNode(uri, source);
+        return new HtmlSourceNode(uri, source, this);
       } else if (extension == '.dart' || uriString.startsWith('dart:')) {
         return new DartSourceNode(uri, source);
+      } else if (extension == '.js') {
+        return new JavaScriptSourceNode(uri, source);
       } else {
         assert(false); // unreachable
       }
     });
   }
 }
 
 /// 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;
 
   /// Last stamp read from `source.modificationStamp`.
   int _lastStamp = 0;
 
   /// 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;
+  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;
+  Iterable<SourceNode> get depsWithoutParts => const [];
 
   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 (newStamp > _lastStamp) {
       _lastStamp = newStamp;
       needsRebuild = true;
     }
   }
 
   String toString() {
     var simpleUri = uri.scheme == 'file' ? path.relative(uri.path) : "$uri";
     return '[$runtimeType: $simpleUri]';
   }
 }
 
 /// A node representing an entry HTML source file.
 class HtmlSourceNode extends SourceNode {
+  /// Javascript dependencies, included by default on any application.
+  Set<JavaScriptSourceNode> runtimeDeps = new Set<JavaScriptSourceNode>();

[Jennifer Messerly, 2015/03/09 16:12:41]

Are we moving to a style where we duplicate the full type?
I've been trying to write this as:

    final runtimeDeps = new Set<JavaScriptSourceNode>();

[Siggi Cherem (dart-lang), 2015/03/09 17:31:39]

Good question - I would prefer not to as well. But I keep debating on what's
best to do if the field is not final.

In this case I think I can switch it to be final, but in the case of Script
below, I'm not sure what's best to do. I'm inclined to change it to:

  Set<DartSourceNode> scripts = new Set();

thoughts?

[Jennifer Messerly, 2015/03/09 17:34:18]

yeah, seems fine to me. Could also be "var" I suppose (not sure if we have plans
to distinguish the two).

fwiw, at least until we can self host, I've seen it useful to have a reified
generic type when using js_ast, e.g. to catch expressions being placed in a
statement list.

+
   /// Libraries referred to via script tags.
   Set<DartSourceNode> scripts = new Set<DartSourceNode>();
 
   @override
-  Iterable<SourceNode> get allDeps => scripts;
+  Iterable<SourceNode> get allDeps => [scripts, runtimeDeps].expand((e) => e);
 
   @override
-  Iterable<SourceNode> get depsWithoutParts => scripts;
+  Iterable<SourceNode> get depsWithoutParts => allDeps;
 
   /// Parsed document, updated whenever [update] is invoked.
   Document document;
 
-  HtmlSourceNode(uri, source) : super(uri, source);
+  HtmlSourceNode(uri, source, graph) : super(uri, source) {
+    var prefix = 'package:dev_compiler/runtime';
+    runtimeDeps
+      ..add(graph.nodeFromUri(Uri.parse('$prefix/dart_runtime.js')))
+      ..add(graph.nodeFromUri(Uri.parse('$prefix/harmony_feature_check.js')));
+  }
 
   void update(SourceGraph graph) {
     super.update(graph);
     if (needsRebuild) {
       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) {
@@ skipping 116 matching lines @@
       // 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;
     }
   }
 }
 
+/// Represents a Javascript runtime resource from our compiler that is needed to
+/// run an application.
+class JavaScriptSourceNode extends SourceNode {
+  JavaScriptSourceNode(uri, source) : super(uri, source);
+}
+
 /// Updates the structure and `needsRebuild` marks in nodes of [graph] reachable
 /// from [start].
 ///
 /// That is, staring from [start], we update the graph by detecting file changes
 /// and rebuilding the structure of the graph wherever it changed (an import was
 /// added or removed, etc).
 ///
 /// After calling this function a node is marked with `needsRebuild` only if it
 /// contained local changes. Rebuild decisions that derive from transitive
 /// changes (e.g. when the API of a dependency changed) are handled later in
@@ skipping 43 matching lines @@
   // cases anways require using summaries to understand what parts of the public
   // API may be affected by transitive changes. The re-export case is just one
   // of those transitive cases, but is not sufficient. See
   // https://github.com/dart-lang/dev_compiler/issues/76
   var apiChangeDetected = new HashSet<SourceNode>();
   bool structureHasChanged = false;
 
   bool shouldBuildNode(SourceNode n) {
     if (n.needsRebuild) return true;
     if (n is HtmlSourceNode) return structureHasChanged;
+    if (n is JavaScriptSourceNode) return false;

[Jennifer Messerly, 2015/03/09 16:12:41]

eventually we may want to follow ES6 imports?

[Siggi Cherem (dart-lang), 2015/03/09 17:31:39]

we totally could if it comes to it. 

     return (n as DartSourceNode).imports
         .any((i) => apiChangeDetected.contains(i));
   }
 
   visitInPostOrder(start, (n) {
     if (n.structureChanged) structureHasChanged = true;
     if (shouldBuildNode(n)) {
       if (build(n)) apiChangeDetected.add(n);
     } else if (n is DartSourceNode &&
         n.exports.any((e) => apiChangeDetected.contains(e))) {
@@ skipping 34 matching lines @@
     if (!seen.add(node)) return;
     var deps = includeParts ? node.allDeps : node.depsWithoutParts;
     deps.forEach(helper);
     action(node);
   }
   helper(start);
 }
 
 bool _same(Set a, Set b) => a.length == b.length && a.containsAll(b);
 final _log = new Logger('dev_compiler.graph');