Specs: fix a raft of syntax errors caught by actually running a syntax checker...

sky/specs/elements.md

 Sky DOM APIs
 ============
 
 ```dart
 SKY MODULE
 <!-- part of dart:sky -->
 
 <script>
 // ELEMENT TREE API
 
 abstract class Node extends EventTarget {
   @override
   external List<EventTarget> getEventDispatchChain(); // O(N) in number of ancestors across shadow trees
   // implements EventTarget.getEventDispatchChain()
   // returns the event dispatch chain (including handling shadow trees)
 
   external Root get owner; // O(1)
 
   external ParentNode get parentNode; // O(1)
-  Element get parentElement => {
+  Element get parentElement {
     if (parentNode is Element)
       return parentNode as Element;
     return null;
   }
 
   external Node get previousSibling; // O(1)
-  Element get previousElementSibling => {
+  Element get previousElementSibling {
     var result = previousSibling;
     while (result != null && result is! Element)
       result = result.previousSibling;
     return result as Element;
   }
 
   external Node get nextSibling; // O(1)
-  Element get nextElementSibling => {
+  Element get nextElementSibling {
     var result = nextSibling;
     while (result != null && result is! Element)
       result = result.nextSibling;
     return result as Element;
   }
 
   // TODO(ianh): rename insertBefore() and insertAfter() since the Web
   // has an insertBefore() that means something else. What's a good
   // name, though?
 
   external void _insertBefore(Node node); // O(N) in number of descendants
   // node must be Text or Element, parentNode must be non-null
   void insertBefore(List nodes) {
     List.forEach((node) {
       if (node is String)
         node = new Text(node);
       _insertBefore(node);
     });    
   }
 
-  void _insertAfter(Node node); // O(N) in number of arguments plus all their descendants
+  external void _insertAfter(Node node); // O(N) in number of arguments plus all their descendants
   // node must be Text or Element, parentNode must be non-null
   void insertAfter(List nodes) {
     var lastNode = this;
     List.forEach((node) {
       if (node is String)
         node = new Text(node);
       lastNode._insertAfter(node);
       lastNode = node;
     });
   }
@@ skipping 45 matching lines @@
   void resetLayoutManager() { // O(1)
     if (renderNode != null) {
       renderNode._layoutManager = null;
       renderNode._needsManager = true;
     }
   }
 }
 
 abstract class ParentNode extends Node {
   external Node get firstChild; // O(1)
-  Element get firstElementChild => {
+  Element get firstElementChild {
     var result = firstChild;
     while (result != null && result is! Element)
       result = result.nextSibling;
     return result as Element;
   }
 
   external Node get lastChild; // O(1)
-  Element get lastElementChild => {
+  Element get lastElementChild {
     var result = lastChild;
     while (result != null && result is! Element)
       result = result.previousSibling;
     return result as Element;
   }
 
   // Returns a new List every time.
   external List<Node> getChildren(); // O(N) in number of child nodes
   List<Element> getChildElements() {
     // that the following works without a cast is absurd
     return getChildren().where((node) => node is Element).toList();
   }
 
   external void _appendChild(Node node); // O(N) in number of descendants
   // node must be Text or Element
-  void appendChild(Node node) {
+  void appendChild(node) {
     if (node is String)
       node = new Text(node);
     _appendChild(node);
   }
   void append(List nodes) {
     nodes.forEach(appendChild);
   }
 
   external void _prependChild(Node node); // O(N) in number of descendants
   // node must be Text or Element
-  void prependChild(Node node) {
+  void prependChild(node) {
     if (node is String)
       node = new Text(node);
     _prependChild(node);
   }
   void prepend(List nodes) {
     // note: not implemented in terms of _prependChild()
     if (firstChild != null)
       firstChild.insertBefore(nodes);
     else
       append(nodes);
   }
 
   external void removeChildren(); // O(N) in number of descendants
-  void setChild(Node node) {
+  void setChild(node) {
     removeChildren();
     appendChild(node);
   }
   void setChildren(List nodes) {
     removeChildren();
     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.isSubclassOf(reflectClass(Element)))
-      throw Error('@tagname can only be used on descendants of Element');
+    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 = 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);
-    bool needsShadow = reflect(this).type.metadata.singleWhere((mirror) => mirror.type == hasShadowClass);
+    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).value;
+    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
 
-  external final Root shadowRoot; // O(1)
+  external Root get shadowRoot; // O(1)
   // returns the shadow root
 
   void endTagParsedCallback() { }
   void attributeChangeCallback(String name, String oldValue, String newValue) { }
   // name will never be null when this is called by sky
 
   // TODO(ianh): does a node ever need to know when it's been redistributed?
 
   @override
   Type getLayoutManager() { // O(1)
@@ skipping 14 matching lines @@
   @override
   Type getLayoutManager() => TextLayoutManager; // O(1)
 }
 
 class Fragment extends ParentNode {
   Fragment({List children}); // O(N) in number of arguments plus all their descendants
   // children must be String, Text, or Element
 }
 
 class Root extends ParentNode {
-  external Root ({List children, Element host}); // O(N) in number of children nodes arguments plus all their descendants
-  // children must be String, Text, or Element
+  Root({List children: null, this.host}) { // O(N) in number of children nodes plus all their descendants
+    if (children != null)
+      children = children.map((node) => node is String ? new Text(node) : node).toList();
+    this._initRoot(children);
+  }
+  external void _initRoot(List children);
+  // appends the given children nodes
+  // children must be Text or Element
 
   final Element host;
 
   external Element findId(String id); // O(1)
   // throws if id is null
 }
 
 class ApplicationRoot extends Root {
-  external ApplicationRoot ({List children}) : Root(children: children); // O(N) in number of children nodes arguments plus all their descendants
-  // children must be String, Text, or Element
+  ApplicationRoot ({List children}) : super(children: children); // O(N) in number of children nodes arguments plus all their descendants
 
   @override
   Type getLayoutManager() => rootLayoutManager; // O(1)
 }
 
 Type rootLayoutManager = BlockLayoutManager; // O(1)
 
 
 // BUILT-IN ELEMENTS
 
@@ skipping 102 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>
 ```