Initial commit of Dart transformer to generate constructor stubs, see https://github.com/angular/an…

modules/angular2/src/transform/codegen.dart

-library angular2.transformer;
+library angular2.src.transform;
 
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/java_core.dart';
 import 'package:barback/barback.dart' show AssetId, TransformLogger;
 import 'package:dart_style/dart_style.dart';
 import 'package:path/path.dart' as path;
 
 import 'annotation_processor.dart';
 
 /// Base class that maintains codegen state.
 class Context {
   final TransformLogger _logger;
   /// Maps libraries to the import prefixes we will use in the newly
   /// generated code.
   final Map<LibraryElement, String> _libraryPrefixes;
 
   DirectiveRegistry _directiveRegistry;
+  /// Generates [registerType] calls for all [register]ed [AnnotationMatch]
+  /// objects.
   DirectiveRegistry get directiveRegistry => _directiveRegistry;
 
   Context({TransformLogger logger})
       : _logger = logger,
         _libraryPrefixes = {} {
     _directiveRegistry = new _DirectiveRegistryImpl(this);
   }
 
   void error(String errorString) {
-    if (_logger != null) {
-      _logger.error(errorString);
-    } else {
-      throw new Error(errorString);
-    }
+    if (_logger == null) throw new Error(errorString);
+    _logger.error(errorString);
   }
 
   /// If elements in [lib] should be prefixed in our generated code, returns
   /// the appropriate prefix followed by a `.`. Future items from the same
   /// library will use the same prefix.
   /// If [lib] does not need a prefix, returns the empty string.
   String _getPrefixDot(LibraryElement lib) {
-    var prefix = lib != null && !lib.isInSdk
-        ? _libraryPrefixes.putIfAbsent(lib, () => 'i${_libraryPrefixes.length}')
-        : null;
-    return prefix == null ? '' : '${prefix}.';
+    if (lib == null || lib.isInSdk) return '';
+    var prefix =
+        _libraryPrefixes.putIfAbsent(lib, () => 'i${_libraryPrefixes.length}');
+    return '${prefix}.';
   }
 }
 
+/// Object which [register]s [AnnotationMatch] objects for code generation.
 abstract class DirectiveRegistry {
   // Adds [entry] to the `registerType` calls which will be generated.
   void register(AnnotationMatch entry);
 }
 
-const _reflectorImport =
-    'import \'package:angular2/src/reflection/reflection.dart\' '
-    'show reflector;';
+const _reflectorImport = '''
+import 'package:angular2/src/reflection/reflection.dart' show reflector;
+''';
 
 /// Default implementation to map from [LibraryElement] to [AssetId]. This
 /// assumes that [el.source] has a getter called [assetId].
 AssetId _assetIdFromLibraryElement(LibraryElement el) {
   return (el.source as dynamic).assetId;
 }
 
 String codegenEntryPoint(Context context,
     {LibraryElement entryPoint, AssetId newEntryPoint}) {
   // This must be called prior to [codegenImports] or the entry point
@@ skipping 29 matching lines @@
   } else if (path.url.split(libraryId.path)[0] ==
       path.url.split(entryPoint.path)[0]) {
     var relativePath =
         path.relative(libraryId.path, from: path.dirname(entryPoint.path));
     return "import '${relativePath}'";
   } else {
     context._error("Can't import `${libraryId}` from `${entryPoint}`");
   }
 }
 
+// TODO(https://github.com/kegluneq/angular/issues/4): Remove calls to
+// Element#node.
 class _DirectiveRegistryImpl implements DirectiveRegistry {
   final Context _context;
   final StringBuffer _buffer = new StringBuffer();
 
   _DirectiveRegistryImpl(this._context);
 
   @override
   String toString() {
     return _buffer.isEmpty ? '' : 'reflector${_buffer};';
   }
@@ skipping 75 matching lines @@
 
 /// Visitor providing common methods for concrete implementations.
 abstract class _TransformVisitor extends ToSourceVisitor {
   final Context _context;
   final PrintWriter _writer;
 
   _TransformVisitor(PrintWriter writer, this._context)
       : this._writer = writer,
         super(writer);
 
-  /// Safely visit the given node.
-  /// @param node the node to be visited
+  /// Safely visit [node].
   void _visitNode(AstNode node) {
     if (node != null) {
       node.accept(this);
     }
   }
 
-  /**
-   * Safely visit the given node, printing the prefix before the node if it is non-`null`.
-   *
-   * @param prefix the prefix to be printed if there is a node to visit
-   * @param node the node to be visited
-   */
+  /// If [node] is null does nothing. Otherwise, prints [prefix], then
+  /// visits [node].
   void _visitNodeWithPrefix(String prefix, AstNode node) {
     if (node != null) {
       _writer.print(prefix);
       node.accept(this);
     }
   }
 
-  /**
-   * Safely visit the given node, printing the suffix after the node if it is non-`null`.
-   *
-   * @param suffix the suffix to be printed if there is a node to visit
-   * @param node the node to be visited
-   */
+  /// If [node] is null does nothing. Otherwise, visits [node], then prints
+  /// [suffix].
   void _visitNodeWithSuffix(AstNode node, String suffix) {
     if (node != null) {
       node.accept(this);
       _writer.print(suffix);
     }
   }
 
   @override
   Object visitSimpleIdentifier(SimpleIdentifier node) {
     // Make sure the identifier is prefixed if necessary.
@@ skipping 144 matching lines @@
   @override
   Object visitAnnotation(Annotation node) {
     _writer.print('const ');
     _visitNode(node.name);
 //     TODO(tjblasi): Do we need to handle named constructors for annotations?
 //    _visitNodeWithPrefix(".", node.constructorName);
     _visitNode(node.arguments);
     return null;
   }
 }