Revert "fix(ElementBinderBuilder): throw if multiple transcluding directives per node"

This reverts commit 02a5079.

I'm reverting this temporarily to give folks some time to fix their
applications.  This commit unconditionally throws an exception without a
deprecation path.  Though incorrect, it turns out that for common cases,
using both ng-if and ng-repeat on the same directive would just work.

Author: chirayuk

lib/core_dom/element_binder_builder.dart

@@ -67,11 +67,6 @@ class ElementBinderBuilder {
     var children = annotation.children;
 
     if (annotation.children == Directive.TRANSCLUDE_CHILDREN) {
-      if (template != null) {
-        throw "There could be at most one transcluding directive on a node. The node "
-              "'${ref.element.outerHtml}' has both '${ref.annotation.selector}' and "
-              "'${template.annotation.selector}'.";
-      }
       template = ref;
     } else if (annotation is Component) {
       ComponentFactory factory;

test/core_dom/element_binder_builder_spec.dart

@@ -5,91 +5,73 @@ import 'dart:mirrors';
 
 @Component(selector:'component')            class _Component{}
 @Decorator(selector:'[ignore-children]',
-           children: Directive.IGNORE_CHILDREN)
-                                            class _IgnoreChildren{}
+             children: Directive.IGNORE_CHILDREN)
+                                              class _IgnoreChildren{}
 @Decorator(selector:'[structural]',
-           children: Directive.TRANSCLUDE_CHILDREN)
-                                            class _Structural{}
+             children: Directive.TRANSCLUDE_CHILDREN)
+                                              class _Structural{}
 @Decorator(selector:'[directive]')          class _DirectiveAttr{}
 
-@Decorator(selector: '[templates]',
-          children: Directive.TRANSCLUDE_CHILDREN)
-                                            class _Template1{}
-@Decorator(selector: '[templates]',
-          children: Directive.TRANSCLUDE_CHILDREN)
-                                            class _Template2{}
-
 
 directiveFor(i) {
   ClassMirror cm = reflectType(i);
 
 }
-void main() {
-  describe('ElementBinderBuilder', () {
-    ElementBinderBuilder builder;
-    ElementBinder binder;
-    var directives;
-    var node = new DivElement();
-
-    beforeEachModule((Module module) {
-      module..bind(_DirectiveAttr)
-            ..bind(_Component)
-            ..bind(_IgnoreChildren)
-            ..bind(_Structural)
-            ..bind(_Template1)
-            ..bind(_Template2);
+main() => describe('ElementBinderBuilder', () {
+  var b;
+  var directives;
+  var node = null;
+
+  beforeEachModule((Module module) {
+    module
+      ..bind(_DirectiveAttr)
+      ..bind(_Component)
+      ..bind(_IgnoreChildren)
+      ..bind(_Structural);
+  });
 
-    });
+  beforeEach((DirectiveMap d, ElementBinderFactory f) {
+    directives = d;
+    b = f.builder(null, null);
+  });
 
-    beforeEach((DirectiveMap d, ElementBinderFactory f) {
-      directives = d;
-      builder = f.builder(null, null);
+  addDirective(selector) {
+    directives.forEach((Directive annotation, Type type) {
+      if (annotation.selector == selector)
+        b.addDirective(new DirectiveRef(node, type, annotation, new Key(type), null));
     });
+    b = b.binder;
+  }
 
-    addDirective(selector) {
-      directives.forEach((Directive annotation, Type type) {
-        if (annotation.selector == selector)
-          builder.addDirective(new DirectiveRef(node, type, annotation, new Key(type), null));
-      });
-      binder = builder.binder;
-    }
-
-    it('should add a decorator', () {
-      expect(builder.decorators.length).toEqual(0);
-
-      addDirective('[directive]');
+  it('should add a decorator', () {
+    expect(b.decorators.length).toEqual(0);
 
-      expect(binder.decorators.length).toEqual(1);
-      expect(binder.componentData).toBeNull();
-      expect(binder.childMode).toEqual(Directive.COMPILE_CHILDREN);
+    addDirective('[directive]');
 
-    });
+    expect(b.decorators.length).toEqual(1);
+    expect(b.componentData).toBeNull();
+    expect(b.childMode).toEqual(Directive.COMPILE_CHILDREN);
 
-    it('should add a component', async(() {
-      addDirective('component');
+  });
 
-      expect(binder.decorators.length).toEqual(0);
-      expect(binder.componentData).toBeNotNull();
-    }));
+  it('should add a component', async(() {
+    addDirective('component');
 
-    it('should add a template', () {
-      addDirective('[structural]');
+    expect(b.decorators.length).toEqual(0);
+    expect(b.componentData).toBeNotNull();
+  }));
 
-      expect(binder.template).toBeNotNull();
-    });
+  it('should add a template', () {
+    addDirective('[structural]');
 
-    it('could have at most one template', () {
-      expect(() => addDirective(('[templates]')))
-          .toThrowWith(message: "There could be at most one transcluding directive on a node. The "
-                                "node '<div></div>' has both '[templates]' and '[templates]'.");
-    });
+    expect(b.template).toBeNotNull();
+  });
 
-    it('should add a directive that ignores children', () {
-      addDirective('[ignore-children]');
+  it('should add a directive that ignores children', () {
+    addDirective('[ignore-children]');
 
-      expect(binder.decorators.length).toEqual(1);
-      expect(binder.componentData).toBeNull();
-      expect(binder.childMode).toEqual(Directive.IGNORE_CHILDREN);
-    });
+    expect(b.decorators.length).toEqual(1);
+    expect(b.componentData).toBeNull();
+    expect(b.childMode).toEqual(Directive.IGNORE_CHILDREN);
   });
-}
+});