fix(directive-injector): Fixes for Direcive Injector.

Breaking change: Regular (application) injectors cannot construct
DirectiveInjectors (DI). Only compilers create DI as part of view
creation process.

Deprecation: directive injector parent is now private. New public
method on dependency injector - parentGet, which allows to get through the
usual chain but skipping itself.

TestBed does not need DI in its constructor.

Internal changes:
- Application Injector reference is passed through view creation and
passed into new Directive Injector (instead of using
parentInjector.appInjector, which is wrong when used with ng-view).
- Unwind recursion from the directive injector for performance.
- Remove EventListener from View.
- Replace DefaultDirectiveInjector with DirectiveInjector with parent = null.
- Component visibility handled outside the visibility enum.
- Removed Shadowless and ShadowDirectiveInjector subclasses.

Prepares for ComponentInjectors breaking the resolution chain, unless
directly called. Does not land that change because it is used by
clients.

Closes #1111

Author: rkirov

lib/application.dart

@@ -189,7 +189,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

@@ -45,21 +45,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

@@ -24,13 +24,11 @@ final CONTENT_PORT_KEY = new Key(ContentPort);
 final TEMPLATE_LOADER_KEY = new Key(TemplateLoader);
 final SHADOW_ROOT_KEY = new Key(ShadowRoot);
 
+final num MAX_DEPTH = 1 << 30;
+
 const int VISIBILITY_LOCAL                    = -1;
 const int VISIBILITY_DIRECT_CHILD             = -2;
 const int VISIBILITY_CHILDREN                 = -3;
-const int VISIBILITY_COMPONENT_OFFSET         = VISIBILITY_CHILDREN;
-const int VISIBILITY_COMPONENT_LOCAL          = VISIBILITY_LOCAL        + VISIBILITY_COMPONENT_OFFSET;
-const int VISIBILITY_COMPONENT_DIRECT_CHILD   = VISIBILITY_DIRECT_CHILD + VISIBILITY_COMPONENT_OFFSET;
-const int VISIBILITY_COMPONENT_CHILDREN       = VISIBILITY_CHILDREN     + VISIBILITY_COMPONENT_OFFSET;
 
 const int UNDEFINED_ID              = 0;
 const int INJECTOR_KEY_ID           = 1;
@@ -52,6 +50,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() {
@@ -99,9 +99,9 @@ class DirectiveInjector implements DirectiveBinder {
       , EVENT_HANDLER_KEY
       , KEEP_ME_LAST
       ];
-
+  
   final DirectiveInjector _parent;
-  final Injector appInjector;
+  final Injector _appInjector;
   final Node _node;
   final NodeAttrs _nodeAttrs;
   final Animate _animate;
@@ -134,21 +134,17 @@ class DirectiveInjector implements DirectiveBinder {
       case VISIBILITY_LOCAL:                  return Visibility.LOCAL;
       case VISIBILITY_DIRECT_CHILD:           return Visibility.DIRECT_CHILD;
       case VISIBILITY_CHILDREN:               return Visibility.CHILDREN;
-      case VISIBILITY_COMPONENT_LOCAL:        return Visibility.LOCAL;
-      case VISIBILITY_COMPONENT_DIRECT_CHILD: return Visibility.DIRECT_CHILD;
-      case VISIBILITY_COMPONENT_CHILDREN:     return Visibility.CHILDREN;
       default:                                return null;
     }
   }
 
   static Binding _tempBinding = new Binding();
 
-  DirectiveInjector(DirectiveInjector parent, Injector appInjector, this._node, this._nodeAttrs,
+  DirectiveInjector(this._parent, appInjector, this._node, this._nodeAttrs,
       this._eventHandler, this.scope, this._animate)
-      : appInjector = appInjector,
-        _parent = parent == null ? new DefaultDirectiveInjector(appInjector) : parent;
+      : _appInjector = appInjector;
 
-  DirectiveInjector._default(this._parent, this.appInjector)
+  DirectiveInjector._default(this._parent, this._appInjector)
       : _node = null,
         _nodeAttrs = null,
         _eventHandler = null,
@@ -195,54 +191,72 @@ 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));
-  Object getFromParent(Type type) => _parent.get(type);
+  Object getFromParent(Type type) => getFromParentByKey(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;
     } finally {
       oldTag.makeCurrent();
     }
   }
-  Object getFromParentByKey(Key key) => _parent.getByKey(key);
 
-  Object _getByKey(Key key) {
+  Object getFromParentByKey(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;
     return isDirective ? _getDirectiveByKey(key, uid, appInjector) : _getById(uid);
   }
 
-  Object _getDirectiveByKey(Key k, int visType, Injector i) {
-    do {
-      if (_key0 == null) break; if (identical(_key0, k)) return _obj0 == null ?  _obj0 = _new(_pKeys0, _factory0) : _obj0;
-      if (_key1 == null) break; if (identical(_key1, k)) return _obj1 == null ?  _obj1 = _new(_pKeys1, _factory1) : _obj1;
-      if (_key2 == null) break; if (identical(_key2, k)) return _obj2 == null ?  _obj2 = _new(_pKeys2, _factory2) : _obj2;
-      if (_key3 == null) break; if (identical(_key3, k)) return _obj3 == null ?  _obj3 = _new(_pKeys3, _factory3) : _obj3;
-      if (_key4 == null) break; if (identical(_key4, k)) return _obj4 == null ?  _obj4 = _new(_pKeys4, _factory4) : _obj4;
-      if (_key5 == null) break; if (identical(_key5, k)) return _obj5 == null ?  _obj5 = _new(_pKeys5, _factory5) : _obj5;
-      if (_key6 == null) break; if (identical(_key6, k)) return _obj6 == null ?  _obj6 = _new(_pKeys6, _factory6) : _obj6;
-      if (_key7 == null) break; if (identical(_key7, k)) return _obj7 == null ?  _obj7 = _new(_pKeys7, _factory7) : _obj7;
-      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);
-    switch (visType) {
-      case VISIBILITY_LOCAL:                  return appInjector.getByKey(k);
-      case VISIBILITY_DIRECT_CHILD:           return _parent._getDirectiveByKey(k, VISIBILITY_LOCAL, i);
-      case VISIBILITY_CHILDREN:               return _parent._getDirectiveByKey(k, VISIBILITY_CHILDREN, i);
-      // SHADOW
-      case VISIBILITY_COMPONENT_LOCAL:        return _parent._getDirectiveByKey(k, VISIBILITY_LOCAL, i);
-      case VISIBILITY_COMPONENT_DIRECT_CHILD: return _parent._getDirectiveByKey(k, VISIBILITY_DIRECT_CHILD, i);
-      case VISIBILITY_COMPONENT_CHILDREN:     return _parent._getDirectiveByKey(k, VISIBILITY_CHILDREN, i);
+  num _getDepth(int visType) {
+    switch(visType) {
+      case VISIBILITY_LOCAL:        return 0;
+      case VISIBILITY_DIRECT_CHILD: return 1;
+      case VISIBILITY_CHILDREN:     return MAX_DEPTH;
       default: throw null;
     }
   }
 
+  _getDirectiveByKey(Key k, int visType, Injector appInjector) {
+    num depth = _getDepth(visType);
+    // ci stands for currentInjector, abbreviated for readability.
+    var ci = this;
+    while (ci != null && depth >= 0) {
+      do {
+        if (ci._key0 == null) break; if (identical(ci._key0, k)) return ci._obj0 == null ?  ci._obj0 = ci._new(ci._pKeys0, ci._factory0) : ci._obj0;
+        if (ci._key1 == null) break; if (identical(ci._key1, k)) return ci._obj1 == null ?  ci._obj1 = ci._new(ci._pKeys1, ci._factory1) : ci._obj1;
+        if (ci._key2 == null) break; if (identical(ci._key2, k)) return ci._obj2 == null ?  ci._obj2 = ci._new(ci._pKeys2, ci._factory2) : ci._obj2;
+        if (ci._key3 == null) break; if (identical(ci._key3, k)) return ci._obj3 == null ?  ci._obj3 = ci._new(ci._pKeys3, ci._factory3) : ci._obj3;
+        if (ci._key4 == null) break; if (identical(ci._key4, k)) return ci._obj4 == null ?  ci._obj4 = ci._new(ci._pKeys4, ci._factory4) : ci._obj4;
+        if (ci._key5 == null) break; if (identical(ci._key5, k)) return ci._obj5 == null ?  ci._obj5 = ci._new(ci._pKeys5, ci._factory5) : ci._obj5;
+        if (ci._key6 == null) break; if (identical(ci._key6, k)) return ci._obj6 == null ?  ci._obj6 = ci._new(ci._pKeys6, ci._factory6) : ci._obj6;
+        if (ci._key7 == null) break; if (identical(ci._key7, k)) return ci._obj7 == null ?  ci._obj7 = ci._new(ci._pKeys7, ci._factory7) : ci._obj7;
+        if (ci._key8 == null) break; if (identical(ci._key8, k)) return ci._obj8 == null ?  ci._obj8 = ci._new(ci._pKeys8, ci._factory8) : ci._obj8;
+        if (ci._key9 == null) break; if (identical(ci._key9, k)) return ci._obj9 == null ?  ci._obj9 = ci._new(ci._pKeys9, ci._factory9) : ci._obj9;
+      } while (false);
+      // Future feature: Component Injectors fall-through only if directly called.
+      // if ((ci is ComponentDirectiveInjector) && !identical(ci, this)) break;
+      ci = ci._parent;
+      depth--;
+    }
+    return appInjector.getByKey(k);
+  }
+
   List get directives {
     var directives = [];
     if (_obj0 != null) directives.add(_obj0);
@@ -260,7 +274,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;
@@ -270,7 +284,13 @@ 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:
+        var currentInjector = _parent;
+        while (currentInjector != null) {
+          if (currentInjector is ComponentDirectiveInjector) return currentInjector._contentPort;
+          currentInjector = currentInjector._parent;
+        }
+        return null;
       default: new NoProviderError(_KEYS[keyId]);
     }
   }
@@ -279,29 +299,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;
@@ -367,14 +388,15 @@ class TemplateDirectiveInjector extends DirectiveInjector {
 
 }
 
-abstract class ComponentDirectiveInjector extends DirectiveInjector {
+class ComponentDirectiveInjector extends DirectiveInjector {
 
   final TemplateLoader _templateLoader;
   final ShadowRoot _shadowRoot;
+  final ContentPort _contentPort;
 
   ComponentDirectiveInjector(DirectiveInjector parent, Injector appInjector,
                         EventHandler eventHandler, Scope scope,
-                        this._templateLoader, this._shadowRoot)
+                        this._templateLoader, this._shadowRoot, this._contentPort)
       : super(parent, appInjector, parent._node, parent._nodeAttrs, eventHandler, scope,
               parent._animate);
 
@@ -386,56 +408,16 @@ abstract class ComponentDirectiveInjector extends DirectiveInjector {
     }
   }
 
-  _getDirectiveByKey(Key k, int visType, Injector i) =>
-      super._getDirectiveByKey(k, visType + VISIBILITY_COMPONENT_OFFSET, i);
-}
-
-class ShadowlessComponentDirectiveInjector extends ComponentDirectiveInjector {
-  final ContentPort _contentPort;
-
-  ShadowlessComponentDirectiveInjector(DirectiveInjector parent, Injector appInjector,
-                                  EventHandler eventHandler, Scope scope,
-                                  templateLoader, shadowRoot, this._contentPort)
-      : super(parent, appInjector, eventHandler, scope, templateLoader, shadowRoot);
-
-  Object _getById(int keyId) {
-    switch(keyId) {
-      case CONTENT_PORT_KEY_ID: return _contentPort;
-      default: return super._getById(keyId);
-    }
-  }
-}
-
-class ShadowDomComponentDirectiveInjector extends ComponentDirectiveInjector {
-  ShadowDomComponentDirectiveInjector(DirectiveInjector parent, Injector appInjector,
-                                 Scope scope, templateLoader, shadowRoot)
-      : super(parent, appInjector, new ShadowRootEventHandler(shadowRoot,
-                                               parent.getByKey(EXPANDO_KEY),
-                                               parent.getByKey(EXCEPTION_HANDLER_KEY)),
-            scope, templateLoader, shadowRoot);
-
   ElementProbe get elementProbe {
     if (_elementProbe == null) {
       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]);
-    }
-  }
+  // Add 1 to visibility to allow to skip over current component injector.
+  // For example, a local directive is visible from its component injector children.
+  num _getDepth(int visType) => super._getDepth(visType) + 1;
 }
+

lib/core_dom/directive_map.dart

@@ -13,12 +13,13 @@ class DirectiveMap {
   final 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 dir) {
@@ -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) {