Specs: found a way to make @autorun work

sky/specs/script.md

 Sky Script Language
 ===================
 
 The Sky script language is Dart.
 
 The way that Sky integrates the module system with its script language
 is described in [modules.md](modules.md).
 
 When an method defined as ``external`` receives an argument, it must
 type-check it, and, if the argument's value is the wrong type, then it
@@ skipping 18 matching lines @@
 The ``@nonnull`` annotation does nothing in code not marked
 ``external``, but it has been included anyway for documentation
 purposes. It indicates places where providing a null is a contract
 violation and that results are therefore likely to be poor.
 
 The following definitions are exposed in ``sky:core``:
 
 ```dart
 abstract class AutomaticMetadata {
   const AutomaticMetadata();
-  void init(DeclarationMirror target) { }
+  void init(DeclarationMirror target, Module module);
+
+  static void runLibrary(LibraryMirror library, Module module) {
+    library.declarations.values.toList()..sort((DeclarationMirror a, DeclarationMirror b) {
+      bool aHasLocation;
+      try {
+        aHasLocation = a.location != null;
+      } catch(e) {
+        aHasLocation = false;
+      }
+      bool bHasLocation;
+      try {
+        bHasLocation = b.location != null;
+      } catch(e) {
+        bHasLocation = false;
+      }
+      if (!aHasLocation)
+        return bHasLocation ? 1 : 0;
+      if (!bHasLocation)
+        return -1;
+      if (a.location.sourceUri != b.location.sourceUri)
+        return a.location.sourceUri.toString().compareTo(b.location.sourceUri.toString());
+      if (a.location.line != b.location.line)
+        return a.location.line - b.location.line;
+      return a.location.column - b.location.column;
+    })
+    ..forEach((DeclarationMirror d) {
+      d.metadata.forEach((InstanceMirror i) {
+        if (i.reflectee is AutomaticMetadata)
+          i.reflectee.run(d, module);
+      });
+    });
+  }
 }
 
-/*
 class AutomaticFunction extends AutomaticMetadata {
   const AutomaticFunction();
-  void init(DeclarationMirror target) {
+  void init(DeclarationMirror target, Module module) {
     assert(target is MethodMirror);
     MethodMirror f = target as MethodMirror;
     assert(!f.isAbstract);
     assert(f.isRegularMethod);
     assert(f.isTopLevel);
     assert(f.isStatic);
     assert(f.parameters.length == 0);
     assert(f.returnType == currentMirrorSystem().voidType);
     (f.owner as LibraryMirror).invoke(f.simpleName, []);
   }
 }
 const autorun = const AutomaticFunction();
-*/
 ```
 
 Extensions
 ----------
 
 The following as-yet unimplemented features of the Dart language are
 assumed to exist:
 
 * It is assumed that a subclass can define a constructor by reference
   to a superclass' constructor, wherein the subclass' constructor has
@@ skipping 29 matching lines @@
   List<T> _exceptions;
   void add(T exception) {
     if (_exceptions == null)
       _exceptions = new List<T>();
     _exceptions.add(exception);
   }
   int get length => _exceptions == null ? 0 : _exceptions.length;
   Iterator<T> iterator() => _exceptions.iterator();
 }
 ```