feat(dart/transform): Add debug transform parameters

Add two transform parameters to aid in debugging the transformer
- `mirror_mode`, with values {`debug`, `none`, and `verbose`}
- `init_reflector`, with values {`true`, `false`}

`mirror_mode`:
- `debug`: Allow reflective access, but log a message if it is used
- `none`: Remove reflective access, `throw` if it is used. Default value
- `verbose`: Allow reflective access, log a stack trace if it is used

`init_reflector`: Whether to generate calls to our generated
`initReflector` code.

These will be useful to reveal areas where the transformer is not generating
appropriate code and to quickly see where reflective accesses occur.

When the pub mode is `transform_dynamic`, we run in MirrorMode.debug
with `init_reflector = false`. This is used for testing purposes.

modules/angular2/src/reflection/debug_reflection_capabilities.dart

@@ -0,0 +1,55 @@
+library reflection.debug_reflection_capabilities;
+
+import 'package:logging/logging.dart';
+import 'package:stack_trace/stack_trace.dart';
+import 'types.dart';
+import 'reflection_capabilities.dart' as standard;
+
+class ReflectionCapabilities extends standard.ReflectionCapabilities {
+  final bool _verbose;
+  final Logger _log = new Logger('ReflectionCapabilities');
+
+  ReflectionCapabilities({bool verbose: false})
+      : _verbose = verbose,
+        super() {
+    Logger.root.level = _verbose ? Level.ALL : Level.INFO;
+    Logger.root.onRecord.listen((LogRecord rec) {
+      print('[${rec.loggerName}(${rec.level.name})]: ${rec.message}');
+    });
+  }
+
+  void _notify(String methodName, param) {
+    var trace = _verbose ? ' ${Trace.format(new Trace.current())}' : '';
+    _log.info('"$methodName" requested for "$param".$trace');
+  }
+
+  Function factory(Type type) {
+    _notify('factory', type);
+    return super.factory(type);
+  }
+
+  List<List> parameters(typeOrFunc) {
+    _notify('parameters', typeOrFunc);
+    return super.parameters(typeOrFunc);
+  }
+
+  List annotations(typeOrFunc) {
+    _notify('annotations', typeOrFunc);
+    return super.annotations(typeOrFunc);
+  }
+
+  GetterFn getter(String name) {
+    _notify('getter', name);
+    return super.getter(name);
+  }
+
+  SetterFn setter(String name) {
+    _notify('setter', name);
+    return super.setter(name);
+  }
+
+  MethodFn method(String name) {
+    _notify('method', name);
+    return super.method(name);
+  }
+}

modules/angular2/src/transform/common/mirror_mode.dart

@@ -0,0 +1,10 @@
+library angular2.transform.common.mirror_mode;
+
+/// Modes for mirror use.
+/// `none` is the default value and signifies that mirror use should be
+/// removed.
+/// `debug` allows the use of mirrors and logs a notice whenever they are
+/// accessed.
+/// `verbose` allows the use of mirrors and logs a stack trace whenever they
+/// are accessed.
+enum MirrorMode { debug, none, verbose }

modules/angular2/src/transform/common/names.dart

@@ -2,10 +2,10 @@ library angular2.transform.common.names;
 
 const SETUP_METHOD_NAME = 'initReflector';
 const REFLECTOR_VAR_NAME = 'reflector';
+const TRANSFORM_DYNAMIC_MODE = 'transform_dynamic';
 const DEPS_EXTENSION = '.ng_deps.dart';
 const REFLECTION_CAPABILITIES_NAME = 'ReflectionCapabilities';
 const REGISTER_TYPE_METHOD_NAME = 'registerType';
 const REGISTER_GETTERS_METHOD_NAME = 'registerGetters';
 const REGISTER_SETTERS_METHOD_NAME = 'registerSetters';
 const REGISTER_METHODS_METHOD_NAME = 'registerMethods';
-const TRANSFORM_MODE = 'ngstatic';

modules/angular2/src/transform/common/options.dart

@@ -1,5 +1,7 @@
 library angular2.transform.common.options;
 
+import 'mirror_mode.dart';
+
 const ENTRY_POINT_PARAM = 'entry_points';
 const REFLECTION_ENTRY_POINT_PARAM = 'reflection_entry_points';
 
@@ -15,15 +17,22 @@ class TransformerOptions {
   /// The `BarbackMode#name` we are running in.
   final String modeName;
 
-  TransformerOptions._internal(
-      this.entryPoints, this.reflectionEntryPoints, this.modeName);
+  /// The [MirrorMode] to use for the transformation.
+  final MirrorMode mirrorMode;
+
+  /// Whether to generate calls to our generated `initReflector` code
+  final bool initReflector;
+
+  TransformerOptions._internal(this.entryPoints, this.reflectionEntryPoints,
+      this.modeName, this.mirrorMode, this.initReflector);
 
   factory TransformerOptions(List<String> entryPoints,
-      {List<String> reflectionEntryPoints, String modeName: 'release'}) {
+      {List<String> reflectionEntryPoints, String modeName: 'release',
+      MirrorMode mirrorMode: MirrorMode.none, bool initReflector: true}) {
     if (reflectionEntryPoints == null || reflectionEntryPoints.isEmpty) {
       reflectionEntryPoints = entryPoints;
     }
-    return new TransformerOptions._internal(
-        entryPoints, reflectionEntryPoints, modeName);
+    return new TransformerOptions._internal(entryPoints, reflectionEntryPoints,
+        modeName, mirrorMode, initReflector);
   }
 }

modules/angular2/src/transform/common/options_reader.dart

@@ -1,6 +1,7 @@
 library angular2.transform.common.options_reader;
 
 import 'package:barback/barback.dart';
+import 'mirror_mode.dart';
 import 'options.dart';
 
 TransformerOptions parseBarbackSettings(BarbackSettings settings) {
@@ -8,9 +9,27 @@ TransformerOptions parseBarbackSettings(BarbackSettings settings) {
   var entryPoints = _readFileList(config, ENTRY_POINT_PARAM);
   var reflectionEntryPoints =
       _readFileList(config, REFLECTION_ENTRY_POINT_PARAM);
+  var initReflector = !config.containsKey('init_reflector') ||
+      config['init_reflector'] != false;
+  String mirrorModeVal =
+      config.containsKey('mirror_mode') ? config['mirror_mode'] : '';
+  var mirrorMode = MirrorMode.none;
+  switch (mirrorModeVal) {
+    case 'debug':
+      mirrorMode = MirrorMode.debug;
+      break;
+    case 'verbose':
+      mirrorMode = MirrorMode.verbose;
+      break;
+    default:
+      mirrorMode = MirrorMode.none;
+      break;
+  }
   return new TransformerOptions(entryPoints,
       reflectionEntryPoints: reflectionEntryPoints,
-      modeName: settings.mode.name);
+      modeName: settings.mode.name,
+      mirrorMode: mirrorMode,
+      initReflector: initReflector);
 }
 
 /// Cribbed from the polymer project.

modules/angular2/src/transform/reflection_remover/remove_reflection_capabilities.dart

@@ -4,6 +4,7 @@ import 'dart:async';
 import 'package:analyzer/analyzer.dart';
 import 'package:barback/barback.dart';
 import 'package:angular2/src/transform/common/asset_reader.dart';
+import 'package:angular2/src/transform/common/mirror_mode.dart';
 
 import 'codegen.dart';
 import 'rewriter.dart';
@@ -15,12 +16,15 @@ import 'rewriter.dart';
 /// This only searches the code in `reflectionEntryPoint`, not `part`s,
 /// `import`s, `export`s, etc.
 Future<String> removeReflectionCapabilities(AssetReader reader,
-    AssetId reflectionEntryPoint, Iterable<AssetId> newEntryPoints) async {
+    AssetId reflectionEntryPoint, Iterable<AssetId> newEntryPoints,
+    {MirrorMode mirrorMode: MirrorMode.none,
+    bool writeStaticInit: true}) async {
   var code = await reader.readAsString(reflectionEntryPoint);
   var reflectionEntryPointPath = reflectionEntryPoint.path;
   var newEntryPointPaths = newEntryPoints.map((id) => id.path);
 
   var codegen = new Codegen(reflectionEntryPointPath, newEntryPointPaths);
-  return new Rewriter(code, codegen)
+  return new Rewriter(code, codegen,
+          mirrorMode: mirrorMode, writeStaticInit: writeStaticInit)
       .rewrite(parseCompilationUnit(code, name: reflectionEntryPointPath));
 }

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

@@ -2,7 +2,9 @@ library angular2.transform.reflection_remover.rewriter;
 
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:angular2/src/transform/common/logging.dart';
+import 'package:angular2/src/transform/common/mirror_mode.dart';
 import 'package:angular2/src/transform/common/names.dart';
+import 'package:path/path.dart' as path;
 
 import 'ast_tester.dart';
 import 'codegen.dart';
@@ -11,9 +13,14 @@ class Rewriter {
   final String _code;
   final Codegen _codegen;
   final AstTester _tester;
+  final MirrorMode _mirrorMode;
+  final bool _writeStaticInit;
 
-  Rewriter(this._code, this._codegen, {AstTester tester})
-      : _tester = tester == null ? const AstTester() : tester;
+  Rewriter(this._code, this._codegen, {AstTester tester,
+      MirrorMode mirrorMode: MirrorMode.none, bool writeStaticInit: true})
+      : _mirrorMode = mirrorMode,
+        _writeStaticInit = writeStaticInit,
+        _tester = tester == null ? const AstTester() : tester;
 
   /// Rewrites the provided code removing imports of the
   /// {@link ReflectionCapabilities} library and instantiations of
@@ -51,8 +58,12 @@ class Rewriter {
             'Found import prefix "${_codegen.prefix}" in source file.'
             ' Transform may not succeed.');
       }
-      buf.write(_commentedNode(node));
-      if (!importAdded) {
+      if (_mirrorMode != MirrorMode.none) {
+        buf.write(_importDebugReflectionCapabilities(node));
+      } else {
+        buf.write(_commentedNode(node));
+      }
+      if (!importAdded && _writeStaticInit) {
         buf.write(_codegen.codegenImport());
         importAdded = true;
       }
@@ -67,8 +78,19 @@ class Rewriter {
         node = node.parent;
       }
       buf.write(_code.substring(lastIdx, node.offset));
-      buf.write(_commentedNode(node));
-      if (!setupAdded) {
+      switch (_mirrorMode) {
+        case MirrorMode.debug:
+          buf.write(node);
+          break;
+        case MirrorMode.verbose:
+          buf.write(_instantiateVerboseReflectionCapabilities(assignNode));
+          break;
+        case MirrorMode.none:
+        default:
+          buf.write(_commentedNode(node));
+          break;
+      }
+      if (!setupAdded && _writeStaticInit) {
         buf.write(_codegen.codegenSetupReflectionCall(
             reflectorAssignment: assignNode));
         setupAdded = true;
@@ -79,8 +101,24 @@ class Rewriter {
     return buf.toString();
   }
 
+  String _instantiateVerboseReflectionCapabilities(
+      AssignmentExpression assignNode) {
+    if (assignNode.rightHandSide is! InstanceCreationExpression) {
+      return '$assignNode;';
+    }
+    var rhs = (assignNode.rightHandSide as InstanceCreationExpression);
+    return '${assignNode.leftHandSide} ${assignNode.operator} '
+        'new ${rhs.constructorName}(verbose: true);';
+  }
+
+  String _importDebugReflectionCapabilities(ImportDirective node) {
+    var uri = '${node.uri}';
+    uri = path.join(path.dirname(uri), 'debug_${path.basename(uri)}');
+    var asClause = node.prefix != null ? ' as ${node.prefix}' : '';
+    return 'import $uri$asClause;';
+  }
+
   String _commentedNode(AstNode node) {
-    // TODO(kegluneq): Return commented code once we generate all needed code.
     return '/*${_code.substring(node.offset, node.end)}*/';
   }
 }

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

@@ -3,6 +3,7 @@ library angular2.transform.reflection_remover.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/mirror_mode.dart';
 import 'package:angular2/src/transform/common/names.dart';
 import 'package:angular2/src/transform/common/options.dart';
 import 'package:barback/barback.dart';
@@ -38,8 +39,19 @@ class ReflectionRemover extends Transformer {
       });
       var reader = new AssetReader.fromTransform(transform);
 
+      var mirrorMode = options.mirrorMode;
+      var writeStaticInit = options.initReflector;
+      if (options.modeName == TRANSFORM_DYNAMIC_MODE) {
+        mirrorMode = MirrorMode.debug;
+        writeStaticInit = false;
+        log.logger.info('Running in "${options.modeName}", '
+            'mirrorMode: ${mirrorMode}, '
+            'writeStaticInit: ${writeStaticInit}.');
+      }
+
       var transformedCode = await removeReflectionCapabilities(
-          reader, transform.primaryInput.id, newEntryPoints);
+          reader, transform.primaryInput.id, newEntryPoints,
+          mirrorMode: mirrorMode, writeStaticInit: writeStaticInit);
       transform.addOutput(
           new Asset.fromString(transform.primaryInput.id, transformedCode));
     } catch (ex, stackTrace) {