Updating Angular version

third_party/pkg/angular/lib/core/directive.dart

 part of angular.core;
 
 abstract class NgAnnotation {
   /**
    * CSS selector which will trigger this component/directive.
    * CSS Selectors are limited to a single element and can contain:
    *
    * * `element-name` limit to a given element name.
    * * `.class` limit to an element with a given class.
    * * `[attribute]` limit to an element with a given attribute name.
@@ skipping 227 matching lines @@
              children: NgAnnotation.COMPILE_CHILDREN,
              visibility: visibility,
              publishTypes: publishTypes,
              publishAs: publishAs,
              map: map,
              exportExpressions: exportExpressions,
              exportExpressionAttrs: exportExpressionAttrs);
 
   NgAnnotation cloneWithNewMap(newMap) =>
       new NgComponent(
-          template: this.template,
-          templateUrl: this.templateUrl,
-          cssUrls: this.cssUrls,
-          applyAuthorStyles: this.applyAuthorStyles,
-          resetStyleInheritance: this.resetStyleInheritance,
-          publishAs: this.publishAs,
+          template: template,
+          templateUrl: templateUrl,
+          cssUrl: cssUrl,
+          cssUrls: cssUrls,
+          applyAuthorStyles: applyAuthorStyles,
+          resetStyleInheritance: resetStyleInheritance,
+          publishAs: publishAs,
           map: newMap,
-          selector: this.selector,
-          visibility: this.visibility,
-          publishTypes: this.publishTypes,
-          exportExpressions: this.exportExpressions,
-          exportExpressionAttrs: this.exportExpressionAttrs);
+          selector: selector,
+          visibility: visibility,
+          publishTypes: publishTypes,
+          exportExpressions: exportExpressions,
+          exportExpressionAttrs: exportExpressionAttrs);
 }
 
 RegExp _ATTR_NAME = new RegExp(r'\[([^\]]+)\]$');
 
 /**
  * Meta-data marker placed on a class which should act as a directive.
  *
  * Angular directives are instantiated using dependency injection, and can
  * ask for any injectable object in their constructor. Directives
  * can also ask for other components or directives declared on the DOM element.
@@ skipping 18 matching lines @@
                     publishTypes : const <Type>[],
                     exportExpressions,
                     exportExpressionAttrs
                     }) : super(selector: selector, children: children, visibility: visibility,
   publishTypes: publishTypes, publishAs: publishAs, map: map,
   exportExpressions: exportExpressions,
   exportExpressionAttrs: exportExpressionAttrs);
 
   NgAnnotation cloneWithNewMap(newMap) =>
       new NgDirective(
-          children: this.children,
-          publishAs: this.publishAs,
+          children: children,
+          publishAs: publishAs,
           map: newMap,
-          selector: this.selector,
-          visibility: this.visibility,
-          publishTypes: this.publishTypes,
-          exportExpressions: this.exportExpressions,
-          exportExpressionAttrs: this.exportExpressionAttrs);
+          selector: selector,
+          visibility: visibility,
+          publishTypes: publishTypes,
+          exportExpressions: exportExpressions,
+          exportExpressionAttrs: exportExpressionAttrs);
 }
 
 /**
  * Meta-data marker placed on a class which should act as a controller for your application.
  *
- * Controllers are essentially [NgDirectives] with few key differences:
+ * Controllers are essentially [NgDirective]s with few key differences:
  *
  * * Controllers create a new scope at the element.
  * * Controllers should not do any DOM manipulation.
  * * Controllers are meant for application-logic
  *   (rather then DOM monipulation logic which directives are meant for.)
  *
  * Controllers can implement [NgAttachAware], [NgDetachAware] and
  * declare these optional methods:
  *
  * * `attach()` - Called on first [Scope.$digest()].
@@ skipping 13 matching lines @@
                     publishTypes : const <Type>[],
                     exportExpressions,
                     exportExpressionAttrs
                     }) : super(selector: selector, children: children, visibility: visibility,
   publishTypes: publishTypes, publishAs: publishAs, map: map,
   exportExpressions: exportExpressions,
   exportExpressionAttrs: exportExpressionAttrs);
 
   NgAnnotation cloneWithNewMap(newMap) =>
       new NgController(
-          children: this.children,
-          publishAs: this.publishAs,
+          children: children,
+          publishAs: publishAs,
           map: newMap,
-          selector: this.selector,
-          visibility: this.visibility,
-          publishTypes: this.publishTypes,
-          exportExpressions: this.exportExpressions,
-          exportExpressionAttrs: this.exportExpressionAttrs);
+          selector: selector,
+          visibility: visibility,
+          publishTypes: publishTypes,
+          exportExpressions: exportExpressions,
+          exportExpressionAttrs: exportExpressionAttrs);
 }
 
 abstract class AttrFieldAnnotation {
   final String attrName;
   const AttrFieldAnnotation(this.attrName);
   String get mappingSpec;
 }
 
 /**
  * When applied as an annotation on a directive field specifies that
@@ skipping 62 matching lines @@
 
 /**
  * Implementing directives or components [detach] method will be called when
  * the associated scope is destroyed.
  */
 abstract class NgDetachAware {
   void detach();
 }
 
 @NgInjectableService()
-class DirectiveMap extends AnnotationMap<NgAnnotation> {
+class DirectiveMap extends AnnotationsMap<NgAnnotation> {
   DirectiveMap(Injector injector, MetadataExtractor metadataExtractor,
       FieldMetadataExtractor fieldMetadataExtractor)
       : super(injector, metadataExtractor) {
-    Map<NgAnnotation, Type> directives = {};
+    Map<NgAnnotation, List<Type>> directives = {};
     forEach((NgAnnotation annotation, Type type) {
       var match;
       var fieldMetadata = fieldMetadataExtractor(type);
       if (fieldMetadata.isNotEmpty) {
         var newMap = annotation.map == null ? {} : new Map.from(annotation.map);
         fieldMetadata.forEach((String fieldName, AttrFieldAnnotation ann) {
           var attrName = ann.attrName;
           if (newMap.containsKey(attrName)) {
             throw 'Mapping for attribute $attrName is already defined (while '
                   'processing annottation for field $fieldName of $type)';
           }
           newMap[attrName] = '${ann.mappingSpec}$fieldName';
         });
         annotation = annotation.cloneWithNewMap(newMap);
       }
-      directives[annotation] = type;
+      directives.putIfAbsent(annotation, () => []).add(type);
     });
     _map.clear();
     _map.addAll(directives);
   }
 }
 
 @NgInjectableService()
 class FieldMetadataExtractor {
   List<TypeMirror> _fieldAnnotations = [reflectType(NgAttr),
       reflectType(NgOneWay), reflectType(NgOneWayOneTime),
@@ skipping 17 matching lines @@
                     'than once in $type';
             }
             fields[fieldName] = meta.reflectee as AttrFieldAnnotation;
           }
         });
       }
     });
     return fields;
   }
 }