feat(transformers): implement initializing deferred libraries

Implement deferred libraries to work with dependency injection and other
angular codegen. This is done by not initializing the library in the parent
ng_deps file when it is declared as deferred, rewriting the import and,
chaining a future that initializes the library in any files that are using
deferred libraries which need angular codegen.

modules/angular2/src/transform/deferred_rewriter/rewriter.dart

@@ -0,0 +1,142 @@
+library angular2.transform.deferred_rewriter.rewriter;
+
+import 'dart:async';
+
+import 'package:analyzer/analyzer.dart';
+import 'package:analyzer/src/generated/ast.dart';
+import 'package:angular2/src/transform/common/asset_reader.dart';
+import 'package:angular2/src/transform/common/logging.dart';
+import 'package:angular2/src/transform/common/names.dart';
+import 'package:barback/barback.dart';
+import 'package:code_transformers/assets.dart';
+import 'package:quiver/iterables.dart' as it;
+
+class Rewriter {
+  final AssetId _entryPoint;
+  final AssetReader _reader;
+
+  Rewriter(this._entryPoint, this._reader);
+
+  /// Rewrites the provided code by finding all the deferred library imports
+  /// and loadLibrary invocations. Then it removes any libraries that don't
+  /// require angular codegen. For the remaining libraries it rewrites the
+  /// import to the corresponding ng_dep file, and chains a future which
+  /// first initializes the library.
+  ///
+  /// To the extent possible, this method does not change line numbers or
+  /// offsets in the provided code to facilitate debugging via source maps.
+  Future<String> rewrite() async {
+    var code = await _reader.readAsString(_entryPoint);
+    var node = parseCompilationUnit(code);
+    if (node == null) return null;
+
+    var visitor = new _FindDeferredLibraries(_reader, _entryPoint);
+    node.accept(visitor);
+    // Look to see if we found any deferred libraries
+    if (!visitor.hasDeferredLibrariesToRewrite()) return null;
+    // Remove any libraries that don't need angular codegen.
+    await visitor.cull();
+    // Check again if there are any deferred libraries.
+    if (!visitor.hasDeferredLibrariesToRewrite()) return null;
+
+    var compare = (AstNode a, AstNode b) => a.offset - b.offset;
+    visitor.deferredImports.sort(compare);
+    visitor.loadLibraryInvocations.sort(compare);
+
+    var buf = new StringBuffer();
+    var idx = visitor.deferredImports.fold(0,
+        (int lastIdx, ImportDirective node) {
+      buf.write(code.substring(lastIdx, node.offset));
+
+      var import = code.substring(node.offset, node.end);
+      buf.write(import.replaceFirst('.dart', DEPS_EXTENSION));
+      return node.end;
+    });
+
+    idx = visitor.loadLibraryInvocations.fold(idx,
+        (int lastIdx, MethodInvocation node) {
+      buf.write(code.substring(lastIdx, node.offset));
+      var value = node.realTarget as SimpleIdentifier;
+      var prefix = value.name;
+      // Chain a future that initializes the reflector.
+      buf.write('$prefix.loadLibrary().then((_) {$prefix.initReflector();})');
+      return node.end;
+    });
+    if (idx < code.length) buf.write(code.substring(idx));
+    return '$buf';
+  }
+}
+
+/// Visitor responsible for finding the deferred libraries that need angular
+/// codegen. Those are the libraries that are loaded deferred and have a
+/// corresponding ng_deps file.
+class _FindDeferredLibraries extends Object with RecursiveAstVisitor<Object> {
+  var deferredImports = new List<ImportDirective>();
+  var loadLibraryInvocations = new List<MethodInvocation>();
+  final AssetReader _reader;
+  final AssetId _entryPoint;
+
+  _FindDeferredLibraries(this._reader, this._entryPoint);
+
+  @override
+  Object visitImportDirective(ImportDirective node) {
+    if (node.deferredKeyword != null) {
+      deferredImports.add(node);
+    }
+    return null;
+  }
+
+  @override
+  Object visitMethodInvocation(MethodInvocation node) {
+    if (node.methodName.name == 'loadLibrary') {
+      loadLibraryInvocations.add(node);
+    }
+    return super.visitMethodInvocation(node);
+  }
+
+  bool hasDeferredLibrariesToRewrite() {
+    if (deferredImports.isEmpty) {
+      logger.fine('There are no deferred library imports.');
+      return false;
+    }
+    if (loadLibraryInvocations.isEmpty) {
+      logger.fine(
+          'There are no loadLibrary invocations that need to be rewritten.');
+      return false;
+    }
+    return true;
+  }
+
+  // Remove all deferredImports that do not have a ng_dep file
+  // then remove all loadLibrary invocations that are not in the set of
+  // prefixes that are left.
+  Future cull() async {
+    // Determine whether a deferred import has ng_deps.
+    var hasInputs = await Future.wait(deferredImports
+        .map((import) => stringLiteralToString(import.uri))
+        .map((uri) => toDepsExtension(uri))
+        .map((depsUri) => uriToAssetId(_entryPoint, depsUri, logger, null,
+            errorOnAbsolute: false))
+        .map((asset) => _reader.hasInput(asset)));
+
+    // Filter out any deferred imports that do not have ng_deps.
+    deferredImports = it
+        .zip([deferredImports, hasInputs])
+        .where((importHasInput) => importHasInput[1])
+        .map((importHasInput) => importHasInput[0])
+        .toList();
+
+    // Find the set of prefixes which have ng_deps.
+    var prefixes =
+        new Set.from(deferredImports.map((import) => import.prefix.name));
+
+    // Filters out any load library invocations where the prefix is not a known
+    // library with ng_deps.
+    loadLibraryInvocations = loadLibraryInvocations.where((library) {
+      var value = library.realTarget as SimpleIdentifier;
+      return prefixes.contains(value.name);
+    }).toList();
+
+    return;
+  }
+}

modules/angular2/src/transform/deferred_rewriter/transformer.dart

@@ -0,0 +1,49 @@
+library angular2.transform.deferred_rewriter.transformer;
+
+import 'dart:async';
+
+import 'package:angular2/src/transform/common/asset_reader.dart';
+import 'package:angular2/src/transform/common/logging.dart' as log;
+import 'package:angular2/src/transform/common/names.dart';
+import 'package:angular2/src/transform/common/options.dart';
+import 'package:barback/barback.dart';
+
+import 'rewriter.dart';
+
+/// Transformer responsible for rewriting deferred library loads to enable
+/// initializing the reflector in a deferred way to keep the code with the
+/// deferred library.
+class DeferredRewriter extends Transformer {
+  final TransformerOptions options;
+
+  DeferredRewriter(this.options);
+
+  @override
+  bool isPrimary(AssetId id) =>
+      id.extension.endsWith('dart') && !id.path.endsWith(DEPS_EXTENSION);
+
+  @override
+  Future apply(Transform transform) async {
+    log.init(transform);
+
+    try {
+      var asset = transform.primaryInput;
+      var reader = new AssetReader.fromTransform(transform);
+      var transformedCode = await rewriteDeferredLibraries(reader, asset.id);
+      if (transformedCode != null) {
+        transform.addOutput(
+            new Asset.fromString(transform.primaryInput.id, transformedCode));
+      }
+    } catch (ex, stackTrace) {
+      log.logger.warning('Rewritting deferred libraries failed.\n'
+          'Exception: $ex\n'
+          'Stack Trace: $stackTrace');
+    }
+  }
+}
+
+// Visible for testing
+Future<String> rewriteDeferredLibraries(AssetReader reader, AssetId id) async {
+  var rewriter = new Rewriter(id, reader);
+  return await rewriter.rewrite();
+}

modules/angular2/src/transform/directive_processor/rewriter.dart

@@ -93,7 +93,9 @@ class CreateNgDepsVisitor extends Object with SimpleAstVisitor<Object> {
   void _maybeWriteImport() {
     if (_wroteBaseLibImport) return;
     _wroteBaseLibImport = true;
-    writer.print('''import '${path.basename(assetId.path)}';''');
+    var origDartFile = path.basename(assetId.path);
+    writer.print('''import '$origDartFile';''');
+    writer.print('''export '$origDartFile';''');
     writer.print("import '$_REFLECTOR_IMPORT' as $_REF_PREFIX;");
   }
 
@@ -106,6 +108,11 @@ class CreateNgDepsVisitor extends Object with SimpleAstVisitor<Object> {
   Object visitImportDirective(ImportDirective node) {
     _maybeWriteImport();
     _updateUsesNonLangLibs(node);
+    // Ignore deferred imports here so as to not load the deferred libraries
+    // code in the current library causing much of the code to not be
+    // deferred. Instead `DeferredRewriter` will rewrite the code as to load
+    // `ng_deps` in a deferred way.
+    if (node.deferredKeyword != null) return null;
     return node.accept(_copyVisitor);
   }
 

modules/angular2/src/transform/transformer.dart

@@ -3,6 +3,7 @@ library angular2.transform;
 import 'package:barback/barback.dart';
 import 'package:dart_style/dart_style.dart';
 
+import 'deferred_rewriter/transformer.dart';
 import 'directive_linker/transformer.dart';
 import 'directive_metadata_extractor/transformer.dart';
 import 'directive_processor/transformer.dart';
@@ -29,7 +30,11 @@ class AngularTransformerGroup extends TransformerGroup {
     phases.addAll(new List.generate(
         options.optimizationPhases, (_) => [new EmptyNgDepsRemover()]));
     phases.addAll([
-      [new DirectiveLinker(), new DirectiveMetadataExtractor()],
+      [
+        new DirectiveLinker(),
+        new DirectiveMetadataExtractor(),
+        new DeferredRewriter(options)
+      ],
       [new BindGenerator(options)],
       [new TemplateCompiler(options)]
     ]);