Specs: pass the current <script> to the module library init()

sky/specs/elements.md

 Sky DOM APIs
 ============
 
 ```dart
 SKY MODULE
 <!-- part of dart:sky -->
 
 <script>
 // ELEMENT TREE API
 
@@ skipping 166 matching lines @@
     append(nodes);
   }
 }
 
 class Attr {
   const Attr (this.name, [this.value = '']); // O(1)
   final String name; // O(1)
   final String value; // O(1)
 }
 
-// @tagname annotation for registering elements
-// only useful when placed on classes that inherit from Element
-class tagname extends AutomaticMetadata {
-  const tagname(this.name);
-  final String name;
-  void init(DeclarationMirror target, Module module) {
-    assert(target is ClassMirror);
-    if (!(target as ClassMirror).isSubclassOf(reflectClass(Element)))
-      throw new UnsupportedError('@tagname can only be used on descendants of Element');
-    module.registerElement(name, (target as ClassMirror).reflectedType);
-  }
-}
-
 // @hasShadow annotation for registering elements
 class _HasShadow {
   const _HasShadow();
 }
 const hasShadow = const _HasShadow();
 
 abstract class Element extends ParentNode {
   Element({Map<String, String> attributes: null,
            List children: null,
            Module hostModule: null}) { // O(M+N), M = number of attributes, N = number of children nodes plus all their descendants
     var shadowClass = reflectClass(hasShadow.runtimeType);
     var shadowAnnotations = reflect(this).type.metadata.where((mirror) => mirror.type == shadowClass);
     if (shadowAnnotations.length > 2)
       throw new StateError('@hasShadow specified multiple times on ' + currentMirrorSystem().getName(reflectClass(this.runtimeType).simpleName));
     bool needsShadow = shadowAnnotations.length == 1;
     if (children != null)
       children = children.map((node) => node is String ? new Text(node) : node).toList();
     this._initElement(attributes, children, hostModule, needsShadow);
   }
   external void _initElement(Map<String, String> attributes, List children, Module hostModule, bool needsShadow);
   // initialises the internal attributes table, which is a ordered list
   // appends the given children nodes
   // children must be Text or Element
   // if needsShadow is true, creates a shadow tree
 
-  String get tagName { // O(N) in number of annotations on the class
-    // throws a StateError if the class doesn't have an @tagname annotation
-    var tagnameClass = reflectClass(tagname);
-    return (reflectClass(this.runtimeType).metadata.singleWhere((mirror) => mirror.type == tagnameClass).reflectee as tagname).name;
-  }
-
   external bool hasAttribute(String name); // O(N) in number of attributes
   external String getAttribute(String name); // O(N) in number of attributes
   external void setAttribute(String name, [String value = '']); // O(N) in number of attributes
   external void removeAttribute(String name); // O(N) in number of attributes
   // calling setAttribute() with a null value removes the attribute
   // (calling it without a value sets it to the empty string)
 
   // Returns a new Array and new Attr instances every time.
   external List<Attr> getAttributes(); // O(N) in number of attributes
 
@@ skipping 164 matching lines @@
   external bool matches(Element element); // O(F())
   external Element find(Node root); // O(N*F())+O(M) where N is the number of descendants and M the average depth of the tree
   external List<Element> findAll(Node root); // O(N*F())+O(N*M) where N is the number of descendants and M the average depth of the tree
   // find() and findAll() throw if the root is not one of the following:
   //  - Element
   //  - Fragment
   //  - Root
 }
 </script>
 ```