refactor(dart/transform): Use a protobufs representation during transform

To simplify processing and testing in the future, use protobufs to
represent of `.ng_deps.dart` files rather than always dealing
directly in Dart code.

This update does not actually use the protobuf representation, but this
is a step towards moving all phases to parse and use protobufs rather than
Dart code.

Author: Tim Blasi

modules_dart/transform/lib/src/transform/common/code/annotation_code.dart

@@ -0,0 +1,92 @@
+library angular2.transform.common.code.annotation_code;
+
+import 'package:analyzer/analyzer.dart';
+import 'package:analyzer/src/generated/ast.dart';
+import 'package:angular2/src/transform/common/annotation_matcher.dart';
+import 'package:angular2/src/transform/common/model/annotation_model.pb.dart';
+import 'package:barback/barback.dart' show AssetId;
+
+import 'constify.dart' show constify;
+
+/// Visitor responsible for parsing [Annotation]s into [AnnotationModel]s.
+class AnnotationVisitor extends SimpleAstVisitor<AnnotationModel> {
+  /// The file we are processing.
+  final AssetId assetId;
+
+  /// Responsible for testing whether [Annotation]s are those recognized by
+  /// Angular 2, for example `@Component`.
+  final AnnotationMatcher _annotationMatcher;
+
+  AnnotationVisitor(this.assetId, this._annotationMatcher);
+
+  @override
+  AnnotationModel visitAnnotation(Annotation node) {
+    var name = constify(node.name);
+    if (node.constructorName != null) {
+      name += '.${constify(node.constructorName)}';
+    }
+    var isComponent = _annotationMatcher.isComponent(node, assetId);
+    var isDirective =
+        isComponent || _annotationMatcher.isDirective(node, assetId);
+    var isInjectable =
+        isDirective || _annotationMatcher.isInjectable(node, assetId);
+    var isView = _annotationMatcher.isView(node, assetId);
+    var model = new AnnotationModel()
+      ..name = name
+      ..isComponent = isComponent
+      ..isDirective = isDirective
+      ..isInjectable = isInjectable
+      ..isView = isView;
+
+    if (node.arguments != null) {
+      for (var arg in node.arguments.arguments) {
+        if (arg is NamedExpression) {
+          model.namedParameters.add(new NamedParameter()
+            ..name = constify(arg.name.label)
+            ..value = constify(arg.expression));
+        } else {
+          model.parameters.add(constify(arg));
+        }
+      }
+    }
+
+    return model;
+  }
+}
+
+/// Defines the format in which an [AnnotationModel] is expressed as Dart code
+/// in a `.ng_deps.dart` file.
+abstract class AnnotationWriterMixin {
+  StringBuffer get buffer;
+
+  void writeAnnotationModel(AnnotationModel model) {
+    if (model.parameters != null || model.namedParameters != null) {
+      buffer.write('const ${model.name}(');
+      var first = true;
+      for (var param in model.parameters) {
+        if (!first) {
+          buffer.write(', ');
+        }
+        first = false;
+        buffer.write(param);
+      }
+      // TODO(kegluneq): We are currently outputting these sorted to ensure we
+      // have repeatable output for testing purposes.
+      // Remove this sorting once we are not testing output code directly.
+      var namedParameters = model.namedParameters.toList();
+      namedParameters.sort((a, b) => a.name.compareTo(b.name));
+      for (var param in namedParameters) {
+        if (!first) {
+          buffer.write(', ');
+        }
+        first = false;
+        buffer.write('${param.name}: ${param.value}');
+      }
+      buffer.write(')');
+    } else {
+      // This is a const instance, not a ctor invocation and does not need a
+      // const instance creation expression.
+      buffer.write(model.name);
+    }
+  }
+}

modules_dart/transform/lib/src/transform/common/code/constify.dart

@@ -0,0 +1,64 @@
+library angular2.transform.common.code.constify;
+
+import 'package:analyzer/analyzer.dart';
+import 'package:analyzer/src/generated/java_core.dart';
+
+/// Serializes the provided [AstNode] to Dart source, replacing `new` in
+/// [InstanceCreationExpression]s and the `@` in [Annotation]s with `const`.
+String constify(AstNode node) {
+  var writer = new PrintStringWriter();
+  node.accept(new _ConstifyingVisitor(writer));
+  return '$writer';
+}
+
+class _ConstifyingVisitor extends ToSourceVisitor {
+  final PrintWriter writer;
+
+  _ConstifyingVisitor(PrintWriter writer)
+      : this.writer = writer,
+        super(writer);
+
+  @override
+  Object visitInstanceCreationExpression(InstanceCreationExpression node) {
+    if (node.keyword.lexeme == 'const') {
+      return super.visitInstanceCreationExpression(node);
+    } else if (node.keyword.lexeme == 'new') {
+      writer.print('const ');
+      if (node.constructorName != null) {
+        node.constructorName.accept(this);
+      }
+      if (node.argumentList != null) {
+        node.argumentList.accept(this);
+      }
+    }
+    return null;
+  }
+
+  @override
+  Object visitAnnotation(Annotation node) {
+    var hasArguments =
+        node.arguments != null && node.arguments.arguments != null;
+    if (hasArguments) {
+      writer.print('const ');
+    }
+    if (node.name != null) {
+      node.name.accept(this);
+    }
+    if (node.constructorName != null) {
+      writer.print('.');
+      node.constructorName.accept(this);
+    }
+    if (hasArguments) {
+      var args = node.arguments.arguments;
+      writer.print('(');
+      for (var i = 0, iLen = args.length; i < iLen; ++i) {
+        if (i != 0) {
+          writer.print(', ');
+        }
+        args[i].accept(this);
+      }
+      writer.print(')');
+    }
+    return null;
+  }
+}

modules_dart/transform/lib/src/transform/common/code/import_export_code.dart

@@ -0,0 +1,98 @@
+library angular2.transform.common.code.import_export_code;
+
+import 'package:analyzer/analyzer.dart';
+import 'package:angular2/src/transform/common/model/import_export_model.pb.dart';
+
+/// Visitor responsible for parsing [ImportDirective]s into [ImportModel]s.
+class ImportVisitor extends SimpleAstVisitor<ImportModel> {
+  @override
+  ImportModel visitImportDirective(ImportDirective node) {
+    if (node.isSynthetic) return null;
+
+    var model = new ImportModel()
+      ..uri = stringLiteralToString(node.uri)
+      ..isDeferred = node.deferredKeyword != null;
+    if (node.prefix != null) {
+      model.prefix = node.prefix.name;
+    }
+    _populateCombinators(node, model);
+    return model;
+  }
+}
+
+/// Visitor responsible for parsing [ExportDirective]s into [ExportModel]s.
+class ExportVisitor extends SimpleAstVisitor<ExportModel> {
+  @override
+  ExportModel visitExportDirective(ExportDirective node) {
+    if (node.isSynthetic) return null;
+
+    var model = new ExportModel()..uri = stringLiteralToString(node.uri);
+    _populateCombinators(node, model);
+    return model;
+  }
+}
+
+/// Parses `combinators` in `node` and adds them to `model`, which should be
+/// either an [ImportModel] or an [ExportModel].
+void _populateCombinators(NamespaceDirective node, dynamic model) {
+  if (node.combinators != null) {
+    node.combinators.forEach((c) {
+      if (c is ShowCombinator) {
+        model.showCombinators.addAll(c.shownNames.map((id) => '$id'));
+      } else if (c is HideCombinator) {
+        model.hideCombinators.addAll(c.hiddenNames.map((id) => '$id'));
+      }
+    });
+  }
+}
+
+/// Defines the format in which an [ImportModel] is expressed as Dart code in a
+/// `.ng_deps.dart` file.
+abstract class ImportWriterMixin {
+  StringBuffer get buffer;
+
+  void writeImportModel(ImportModel model) {
+    buffer.write("import '${model.uri}'");
+    if (model.isDeferred) {
+      buffer.write(' deferred');
+    }
+    if (model.prefix != null && model.prefix.isNotEmpty) {
+      buffer.write(' as ${model.prefix}');
+    }
+    _writeCombinators(buffer, model);
+    buffer.writeln(';');
+  }
+}
+
+/// Defines the format in which an [ExportModel] is expressed as Dart code in a
+/// `.ng_deps.dart` file.
+abstract class ExportWriterMixin {
+  StringBuffer get buffer;
+
+  void writeExportModel(ExportModel model) {
+    buffer.write("export '${model.uri}'");
+    _writeCombinators(buffer, model);
+    buffer.writeln(';');
+  }
+}
+
+void _writeCombinators(StringBuffer buffer, dynamic model) {
+  if (model.showCombinators != null && model.showCombinators.isNotEmpty) {
+    buffer.write(' show ');
+    for (var i = 0; i < model.showCombinators.length; ++i) {
+      if (i != 0) {
+        buffer.write(', ');
+      }
+      buffer.write(model.showCombinators[i]);
+    }
+  }
+  if (model.hideCombinators != null && model.hideCombinators.isNotEmpty) {
+    buffer.write(' hide ');
+    for (var i = 0; i < model.hideCombinators.length; ++i) {
+      if (i != 0) {
+        buffer.write(', ');
+      }
+      buffer.write(model.hideCombinators[i]);
+    }
+  }
+}