fix(directive-injector): Pass the correct injector into nested views

Replace DefaultDirectiveInjector with DirectiveInjector (with parent = null).

Application Injector reference is passed through view creation and
passed into new Directive Injector (instead of using
parentInjector.appInjector, which is wrong).

New public method on dependency injector - parentGet. Allowing to get
through the usual chain but skipping itself (used for NgControl).

Remove EventListener from View.

Closes #1244

Author: rkirov

lib/application.dart

@@ -180,7 +180,7 @@ abstract class Application {
           DirectiveMap directiveMap = injector.getByKey(DIRECTIVE_MAP_KEY);
           RootScope rootScope = injector.getByKey(ROOT_SCOPE_KEY);
           ViewFactory viewFactory = compiler(rootElements, directiveMap);
-          viewFactory(rootScope, injector.get(DirectiveInjector), rootElements);
+          viewFactory(rootScope, null, rootElements);
         } catch (e, s) {
           exceptionHandler(e, s);
         }

lib/core_dom/common.dart

@@ -43,21 +43,3 @@ class DirectiveRef {
   }
 }
 
-/**
- * Creates a child injector that allows loading new directives, formatters and
- * services from the provided modules.
- */
-Injector forceNewDirectivesAndFormatters(Injector injector, DirectiveInjector dirInjector,
-                                         List<Module> modules) {
-  modules.add(new Module()
-      ..bind(Scope, toFactory: (Injector injector) {
-          var scope = injector.parent.getByKey(SCOPE_KEY);
-          return scope.createChild(new PrototypeMap(scope.context));
-        }, inject: [INJECTOR_KEY])
-      ..bind(DirectiveMap)
-      ..bind(FormatterMap)
-      ..bind(DirectiveInjector,
-              toFactory: () => new DefaultDirectiveInjector.newAppInjector(dirInjector, injector)));
-
-  return new ModuleInjector(modules, injector);
-}

lib/core_dom/directive_injector.dart

@@ -52,6 +52,8 @@ const int CONTENT_PORT_KEY_ID       = 16;
 const int EVENT_HANDLER_KEY_ID      = 17;
 const int KEEP_ME_LAST              = 18;
 
+EventHandler eventHandler(DirectiveInjector di) => di._eventHandler;
+
 class DirectiveInjector implements DirectiveBinder {
   static bool _isInit = false;
   static initUID() {
@@ -100,8 +102,8 @@ class DirectiveInjector implements DirectiveBinder {
       , KEEP_ME_LAST
       ];
 
-  final DirectiveInjector parent;
-  final Injector appInjector;
+  final DirectiveInjector _parent;
+  final Injector _appInjector;
   final Node _node;
   final NodeAttrs _nodeAttrs;
   final Animate _animate;
@@ -140,17 +142,8 @@ class DirectiveInjector implements DirectiveBinder {
 
   static Binding _temp_binding = new Binding();
 
-  DirectiveInjector(parent, appInjector, this._node, this._nodeAttrs, this._eventHandler,
-                    this.scope, this._animate)
-      : appInjector = appInjector,
-        parent = parent == null ? new DefaultDirectiveInjector(appInjector) : parent;
-
-  DirectiveInjector._default(this.parent, this.appInjector)
-      : _node = null,
-        _nodeAttrs = null,
-        _eventHandler = null,
-        scope = null,
-        _animate = null;
+  DirectiveInjector(this._parent, this._appInjector, this._node, this._nodeAttrs, this._eventHandler,
+                    this.scope, this._animate);
 
   bind(key, {dynamic toValue: DEFAULT_VALUE,
             Function toFactory: DEFAULT_VALUE,
@@ -190,12 +183,17 @@ class DirectiveInjector implements DirectiveBinder {
     else { throw 'Maximum number of directives per element reached.'; }
   }
 
+  // Get a key from the directive injector chain. When it is exhausted, get from
+  // the current application injector chain.
   Object get(Type type) => getByKey(new Key(type));
 
+  // Same behavior as get but skips the current injector.
+  Object parentGet(Type type) => parentGetByKey(new Key(type));
+
   Object getByKey(Key key) {
     var oldTag = _TAG_GET.makeCurrent();
     try {
-      return _getByKey(key);
+      return _getByKey(key, _appInjector);
     } on ResolvingError catch (e, s) {
       e.appendKey(key);
       rethrow;
@@ -204,7 +202,15 @@ class DirectiveInjector implements DirectiveBinder {
     }
   }
 
-  Object _getByKey(Key key) {
+  Object parentGetByKey(Key key) {
+    if (_parent == null) {
+      return _appInjector.getByKey(key);
+    } else {
+      return _parent._getByKey(key, _appInjector);
+    }
+  }
+
+  Object _getByKey(Key key, Injector appInjector) {
     int uid = key.uid;
     if (uid == null || uid == UNDEFINED_ID) return appInjector.getByKey(key);
     bool isDirective = uid < 0;
@@ -224,8 +230,10 @@ class DirectiveInjector implements DirectiveBinder {
       if (_key8 == null) break; if (identical(_key8, k)) return _obj8 == null ?  _obj8 = _new(_pKeys8, _factory8) : _obj8;
       if (_key9 == null) break; if (identical(_key9, k)) return _obj9 == null ?  _obj9 = _new(_pKeys9, _factory9) : _obj9;
     } while (false);
+    var parent = this._parent;
+    if (parent == null) return i.getByKey(k);
     switch (visType) {
-      case VISIBILITY_LOCAL:                  return appInjector.getByKey(k);
+      case VISIBILITY_LOCAL:                  return i.getByKey(k);
       case VISIBILITY_DIRECT_CHILD:           return parent._getDirectiveByKey(k, VISIBILITY_LOCAL, i);
       case VISIBILITY_CHILDREN:               return parent._getDirectiveByKey(k, VISIBILITY_CHILDREN, i);
       // SHADOW
@@ -234,6 +242,7 @@ class DirectiveInjector implements DirectiveBinder {
       case VISIBILITY_COMPONENT_CHILDREN:     return parent._getDirectiveByKey(k, VISIBILITY_CHILDREN, i);
       default: throw null;
     }
+
   }
 
   List get directives {
@@ -253,7 +262,7 @@ class DirectiveInjector implements DirectiveBinder {
 
   Object _getById(int keyId) {
     switch(keyId) {
-      case INJECTOR_KEY_ID:           return appInjector;
+      case INJECTOR_KEY_ID:           return _appInjector;
       case DIRECTIVE_INJECTOR_KEY_ID: return this;
       case NODE_KEY_ID:               return _node;
       case ELEMENT_KEY_ID:            return _node;
@@ -263,7 +272,8 @@ class DirectiveInjector implements DirectiveBinder {
       case ELEMENT_PROBE_KEY_ID:      return elementProbe;
       case NG_ELEMENT_KEY_ID:         return ngElement;
       case EVENT_HANDLER_KEY_ID:      return _eventHandler;
-      case CONTENT_PORT_KEY_ID:       return parent._getById(keyId);
+      case CONTENT_PORT_KEY_ID:
+          return _parent == null ? null : _parent._getById(keyId);
       default: new NoProviderError(_KEYS[keyId]);
     }
   }
@@ -272,29 +282,30 @@ class DirectiveInjector implements DirectiveBinder {
     var oldTag = _TAG_GET.makeCurrent();
     int size = paramKeys.length;
     var obj;
+    var appInjector = this._appInjector;
     if (size > 15) {
       var params = new List(paramKeys.length);
       for(var i = 0; i < paramKeys.length; i++) {
-        params[i] = _getByKey(paramKeys[i]);
+        params[i] = _getByKey(paramKeys[i], appInjector);
       }
       _TAG_INSTANTIATE.makeCurrent();
       obj = Function.apply(fn, params);
     } else {
-      var a01 = size >= 01 ? _getByKey(paramKeys[00]) : null;
-      var a02 = size >= 02 ? _getByKey(paramKeys[01]) : null;
-      var a03 = size >= 03 ? _getByKey(paramKeys[02]) : null;
-      var a04 = size >= 04 ? _getByKey(paramKeys[03]) : null;
-      var a05 = size >= 05 ? _getByKey(paramKeys[04]) : null;
-      var a06 = size >= 06 ? _getByKey(paramKeys[05]) : null;
-      var a07 = size >= 07 ? _getByKey(paramKeys[06]) : null;
-      var a08 = size >= 08 ? _getByKey(paramKeys[07]) : null;
-      var a09 = size >= 09 ? _getByKey(paramKeys[08]) : null;
-      var a10 = size >= 10 ? _getByKey(paramKeys[09]) : null;
-      var a11 = size >= 11 ? _getByKey(paramKeys[10]) : null;
-      var a12 = size >= 12 ? _getByKey(paramKeys[11]) : null;
-      var a13 = size >= 13 ? _getByKey(paramKeys[12]) : null;
-      var a14 = size >= 14 ? _getByKey(paramKeys[13]) : null;
-      var a15 = size >= 15 ? _getByKey(paramKeys[14]) : null;
+      var a01 = size >= 01 ? _getByKey(paramKeys[00], appInjector) : null;
+      var a02 = size >= 02 ? _getByKey(paramKeys[01], appInjector) : null;
+      var a03 = size >= 03 ? _getByKey(paramKeys[02], appInjector) : null;
+      var a04 = size >= 04 ? _getByKey(paramKeys[03], appInjector) : null;
+      var a05 = size >= 05 ? _getByKey(paramKeys[04], appInjector) : null;
+      var a06 = size >= 06 ? _getByKey(paramKeys[05], appInjector) : null;
+      var a07 = size >= 07 ? _getByKey(paramKeys[06], appInjector) : null;
+      var a08 = size >= 08 ? _getByKey(paramKeys[07], appInjector) : null;
+      var a09 = size >= 09 ? _getByKey(paramKeys[08], appInjector) : null;
+      var a10 = size >= 10 ? _getByKey(paramKeys[09], appInjector) : null;
+      var a11 = size >= 11 ? _getByKey(paramKeys[10], appInjector) : null;
+      var a12 = size >= 12 ? _getByKey(paramKeys[11], appInjector) : null;
+      var a13 = size >= 13 ? _getByKey(paramKeys[12], appInjector) : null;
+      var a14 = size >= 14 ? _getByKey(paramKeys[13], appInjector) : null;
+      var a15 = size >= 15 ? _getByKey(paramKeys[14], appInjector) : null;
       _TAG_INSTANTIATE.makeCurrent();
       switch(size) {
         case 00: obj = fn(); break;
@@ -322,7 +333,7 @@ class DirectiveInjector implements DirectiveBinder {
 
   ElementProbe get elementProbe {
     if (_elementProbe == null) {
-      ElementProbe parentProbe = parent is DirectiveInjector ? parent.elementProbe : null;
+      ElementProbe parentProbe = _parent == null ? null : _parent.elementProbe;
       _elementProbe = new ElementProbe(parentProbe, _node, this, scope);
     }
     return _elementProbe;
@@ -353,7 +364,7 @@ class TemplateDirectiveInjector extends DirectiveInjector {
       case VIEW_PORT_KEY_ID: return ((_viewPort) == null) ?
             _viewPort = new ViewPort(this, scope, _node, _animate) : _viewPort;
       case BOUND_VIEW_FACTORY_KEY_ID: return (_boundViewFactory == null) ?
-            _boundViewFactory = _viewFactory.bind(this.parent) : _boundViewFactory;
+            _boundViewFactory = _viewFactory.bind(this._parent) : _boundViewFactory;
       default: return super._getById(keyId);
     }
   }
@@ -409,27 +420,9 @@ class ShadowDomComponentDirectiveInjector extends ComponentDirectiveInjector {
 
   ElementProbe get elementProbe {
     if (_elementProbe == null) {
-      ElementProbe parentProbe =
-        parent is DirectiveInjector ? parent.elementProbe : parent.getByKey(ELEMENT_PROBE_KEY);
+      ElementProbe parentProbe = _parent == null ? null : _parent.elementProbe;
       _elementProbe = new ElementProbe(parentProbe, _shadowRoot, this, scope);
     }
     return _elementProbe;
   }
 }
-
-@Injectable()
-class DefaultDirectiveInjector extends DirectiveInjector {
-  DefaultDirectiveInjector(Injector appInjector): super._default(null, appInjector);
-  DefaultDirectiveInjector.newAppInjector(DirectiveInjector parent, Injector appInjector)
-    : super._default(parent, appInjector);
-
-  Object getByKey(Key key) => appInjector.getByKey(key);
-  _getDirectiveByKey(Key key, int visType, Injector i) =>
-    parent == null ? i.getByKey(key) : parent._getDirectiveByKey(key, visType, i);
-  _getById(int keyId) {
-    switch (keyId) {
-      case CONTENT_PORT_KEY_ID: return null;
-      default: throw new NoProviderError(DirectiveInjector._KEYS[keyId]);
-    }
-  }
-}

lib/core_dom/directive_map.dart

@@ -13,12 +13,13 @@ class DirectiveMap {
   DirectiveSelectorFactory _directiveSelectorFactory;
   FormatterMap _formatters;
   DirectiveSelector _selector;
+  Injector _injector;
 
-  DirectiveMap(Injector injector,
+  DirectiveMap(Injector this._injector,
                this._formatters,
                MetadataExtractor metadataExtractor,
                this._directiveSelectorFactory) {
-    (injector as ModuleInjector).types.forEach((type) {
+    (_injector as ModuleInjector).types.forEach((type) {
       metadataExtractor(type)
       .where((annotation) => annotation is Directive)
       .forEach((Directive directive) {
@@ -29,7 +30,7 @@ class DirectiveMap {
 
   DirectiveSelector get selector {
     if (_selector != null) return _selector;
-    return _selector = _directiveSelectorFactory.selector(this, _formatters);
+    return _selector = _directiveSelectorFactory.selector(this, _injector, _formatters);
   }
 
   List<DirectiveTypeTuple> operator[](String key) {

lib/core_dom/element_binder.dart

@@ -14,10 +14,10 @@ class TemplateElementBinder extends ElementBinder {
     return _directiveCache = [template];
   }
 
-  TemplateElementBinder(perf, expando, parser, config,
+  TemplateElementBinder(perf, expando, parser, config, appInjector,
                         this.template, this.templateBinder,
                         onEvents, bindAttrs, childMode)
-      : super(perf, expando, parser, config,
+      : super(perf, expando, parser, config, appInjector,
           null, null, onEvents, bindAttrs, childMode);
 
   String toString() => "[TemplateElementBinder template:$template]";
@@ -47,6 +47,8 @@ class ElementBinder {
   final Expando _expando;
   final Parser _parser;
   final CompilerConfig _config;
+  final Injector _appInjector;
+  Animate _animate;
 
   final Map onEvents;
   final Map bindAttrs;
@@ -60,8 +62,10 @@ class ElementBinder {
   final String childMode;
 
   ElementBinder(this._perf, this._expando, this._parser, this._config,
-                this.componentData, this.decorators,
-                this.onEvents, this.bindAttrs, this.childMode);
+                this._appInjector, this.componentData, this.decorators,
+                this.onEvents, this.bindAttrs, this.childMode) {
+    _animate = _appInjector.getByKey(ANIMATE_KEY);
+  }
 
   final bool hasTemplate = false;
 
@@ -257,20 +261,21 @@ class ElementBinder {
 
   DirectiveInjector bind(View view, Scope scope,
                          DirectiveInjector parentInjector,
-                         dom.Node node, EventHandler eventHandler, Animate animate) {
+                         dom.Node node) {
     var nodeAttrs = node is dom.Element ? new NodeAttrs(node) : null;
 
     var directiveRefs = _usableDirectiveRefs;
     if (!hasDirectivesOrEvents) return parentInjector;
 
     DirectiveInjector nodeInjector;
+    var parentEventHandler = parentInjector == null ?
+        _appInjector.getByKey(EVENT_HANDLER_KEY) :
+        eventHandler(parentInjector);
     if (this is TemplateElementBinder) {
-      nodeInjector = new TemplateDirectiveInjector(parentInjector, parentInjector.appInjector,
-          node, nodeAttrs, eventHandler, scope, animate,
-          (this as TemplateElementBinder).templateViewFactory);
+      nodeInjector = new TemplateDirectiveInjector(parentInjector, _appInjector,
+          node, nodeAttrs, parentEventHandler, scope, _animate, (this as TemplateElementBinder).templateViewFactory);
     } else {
-      nodeInjector = new DirectiveInjector(parentInjector, parentInjector.appInjector,
-          node, nodeAttrs, eventHandler, scope, animate);
+      nodeInjector = new DirectiveInjector(parentInjector, _appInjector, node, nodeAttrs, parentEventHandler, scope, _animate);
     }
 
     for(var i = 0; i < directiveRefs.length; i++) {
@@ -299,7 +304,7 @@ class ElementBinder {
 
     if (onEvents.isNotEmpty) {
       onEvents.forEach((event, value) {
-        view.registerEvent(EventHandler.attrNameToEventName(event));
+        parentEventHandler.register(EventHandler.attrNameToEventName(event));
       });
     }
     return nodeInjector;

lib/core_dom/element_binder_builder.dart

@@ -15,16 +15,17 @@ class ElementBinderFactory {
       this.astParser, this.componentFactory, this.shadowDomComponentFactory, this.transcludingComponentFactory);
 
   // TODO: Optimize this to re-use a builder.
-  ElementBinderBuilder builder(FormatterMap formatters, DirectiveMap directives) =>
-    new ElementBinderBuilder(this,formatters, directives);
+  ElementBinderBuilder builder(FormatterMap formatters, DirectiveMap directives, Injector injector) =>
+    new ElementBinderBuilder(this, formatters, directives, injector);
 
   ElementBinder binder(ElementBinderBuilder b) =>
 
-      new ElementBinder(_perf, _expando, _parser, _config,
+      new ElementBinder(_perf, _expando, _parser, _config, b._injector,
           b.componentData, b.decorators, b.onEvents, b.bindAttrs, b.childMode);
 
-  TemplateElementBinder templateBinder(ElementBinderBuilder b, ElementBinder transclude) =>
-      new TemplateElementBinder(_perf, _expando, _parser, _config,
+  TemplateElementBinder templateBinder(
+      ElementBinderBuilder b, ElementBinder transclude) =>
+      new TemplateElementBinder(_perf, _expando, _parser, _config, b._injector,
           b.template, transclude, b.onEvents, b.bindAttrs, b.childMode);
 }
 
@@ -45,13 +46,14 @@ class ElementBinderBuilder {
   final bindAttrs = new HashMap<String, AST>();
 
   final decorators = <DirectiveRef>[];
+  final Injector _injector;
   DirectiveRef template;
   BoundComponentData componentData;
 
   // Can be either COMPILE_CHILDREN or IGNORE_CHILDREN
   String childMode = Directive.COMPILE_CHILDREN;
 
-  ElementBinderBuilder(this._factory, this._formatters, this._directives);
+  ElementBinderBuilder(this._factory, this._formatters, this._directives, this._injector);
 
   /**
    * Adds [DirectiveRef]s to this [ElementBinderBuilder].
@@ -79,7 +81,7 @@ class ElementBinderBuilder {
         factory = _factory.componentFactory;
       }
 
-      componentData = new BoundComponentData(ref, () => factory.bind(ref, _directives));
+      componentData = new BoundComponentData(ref, () => factory.bind(ref, _directives, _injector));
     } else {
       decorators.add(ref);
     }