feat(dart/transformer:: Initial commit of ctor stubs & annotation register

Closes angular#646

Closes angular#496

Closes angular#498

Author: Tim Blasi

gulpfile.js

@@ -516,11 +516,17 @@ gulp.task('ci', function(done) {
   );
 });
 
+gulp.task('tests/transform.dart', function() {
+  return gulp.src('modules/angular2/test/transform/**')
+    .pipe(gulp.dest('dist/dart/angular2/test/transform'));
+});
+
 // -----------------
 // orchestrated targets
 gulp.task('build.dart', function(done) {
   runSequence(
     ['build/deps.js.dart2js', 'build/transpile.dart', 'build/html.dart'],
+    'tests/transform.dart',
     'build/pubspec.dart',
     'build/multicopy.dart',
     'build/pubbuild.dart',

modules/angular2/pubspec.yaml

@@ -9,6 +9,11 @@ homepage: <%= packageJson.homepage %>
 environment:
   sdk: '>=1.4.0'
 dependencies:
+  analyzer: '0.22.4'
+  barback: '0.15.2+2'
+  code_transformers: '0.2.5'
+  dart_style: '0.1.3'
+  html5lib: '0.12.0'
   stack_trace: '>=1.1.1 <1.2.0'
 dev_dependencies:
   guinness: ">=0.1.16 <0.2.0"

modules/angular2/src/transform/annotation_processor.dart

@@ -0,0 +1,58 @@
+import 'dart:collection' show Queue;
+import 'package:analyzer/src/generated/element.dart';
+
+/// Provides a mechanism for checking an element for the provided
+/// [_annotationClass] and reporting the resulting (element, annotation) pairs.
+class AnnotationMatcher {
+  /// Queue for annotations.
+  final initQueue = new Queue<AnnotationMatch>();
+  /// All the annotations we have seen for each element
+  final _seenAnnotations = new Map<Element, Set<ElementAnnotation>>();
+
+  /// The class we are searching for to populate [initQueue].
+  final ClassElement _annotationClass;
+
+  AnnotationMatcher(this._annotationClass);
+
+  /// Records all [_annotationClass] annotations and the [element]s they apply to.
+  /// Returns [true] if 1) [element] is annotated with [_annotationClass] and
+  /// 2) ([element], [_annotationClass]) has been seen previously.
+  bool processAnnotations(ClassElement element) {
+    var found = false;
+    element.metadata.where((ElementAnnotation meta) {
+      // Only process [_annotationClass]s.
+      // TODO(tjblasi): Make this recognize non-ConstructorElement annotations.
+      return meta.element is ConstructorElement &&
+          _isAnnotationMatch(meta.element.returnType);
+    }).where((ElementAnnotation meta) {
+      // Only process ([element], [meta]) combinations we haven't seen previously.
+      return !_seenAnnotations
+          .putIfAbsent(element, () => new Set<ElementAnnotation>())
+          .contains(meta);
+    }).forEach((ElementAnnotation meta) {
+      _seenAnnotations[element].add(meta);
+      initQueue.addLast(new AnnotationMatch(element, meta));
+      found = true;
+    });
+    return found;
+  }
+
+  /// Whether [type], its superclass, or one of its interfaces matches [_annotationClass].
+  bool _isAnnotationMatch(InterfaceType type) {
+    if (type == null || type.element == null) return false;
+    if (type.element.type == _annotationClass.type) return true;
+    if (_isAnnotationMatch(type.superclass)) return true;
+    for (var interface in type.interfaces) {
+      if (_isAnnotationMatch(interface)) return true;
+    }
+    return false;
+  }
+}
+
+// Element/ElementAnnotation pair.
+class AnnotationMatch {
+  final Element element;
+  final ElementAnnotation annotation;
+
+  AnnotationMatch(this.element, this.annotation);
+}