Specs: Revamp how styling works to make it possible

sky/specs/apis.md

 APIs
 ====
 
 The Sky core API
 ----------------
 
 ```javascript
 module 'sky:core' {
 
   // EVENTS
@@ skipping 107 matching lines @@
     
     // Returns a new Array and new Attr instances every time.
     Array<Attr> getAttributes(); // O(N) in number of attributes
 
     readonly attribute ShadowRoot? shadowRoot; // O(1) // returns the shadow root
     Array<ContentElement> getDestinationInsertionPoints(); // O(N) in number of insertion points the node is in
 
     virtual void endTagParsedCallback(); // noop
     virtual void attributeChangeCallback(String name, String? oldValue, String? newValue); // noop
     // TODO(ianh): does a node ever need to know when it's been redistributed?
+
+    readonly attribute StyleDeclarationList style; // O(1)
+    virtual LayoutManagerConstructor getLayoutManager(RenderNode renderNode); // O(1)
+      // default implementation looks up the 'display' property and returns the value:
+      //   if (renderNode)
+      //     return renderNode.getProperty(phDisplay);
+      //   return null;
+    readonly attribute RenderNode? renderNode; // O(1)
+      // this will be null until the first time it is rendered
+    void resetLayoutManager(); // O(1)
+      // if renderNode is non-null:
+      //   sets renderNode.layoutManager to null
+      //   sets renderNode.needsManager to true
   }
 
   class Text : Node {
     constructor (String value = ''); // O(1)
     attribute String value; // O(1)
 
     void replaceWith(String node); // O(1) // special case override of Node.replaceWith()
 
     virtual void valueChangeCallback(String? oldValue, String? newValue); // noop
   }
@@ skipping 59 matching lines @@
     constructor attribute String tagName; // O(1) // "script"
     constructor attribute Boolean shadow; // O(1) // false
   }
   class StyleElement : Element {
     constructor (Dictionary<String> attributes, ChildArguments... nodes); // O(M+N), M = number of attributes, N = number of nodes plus all their descendants
     constructor (ChildArguments... nodes); // shorthand
     constructor (Dictionary<String> attributes); // shorthand
     constructor (); // shorthand
     constructor attribute String tagName; // O(1) // "style"
     constructor attribute Boolean shadow; // O(1) // false
+
+    Array<Rule> getRules(); // O(N) in rules
   }
   class ContentElement : Element {
     constructor (Dictionary<String> attributes, ChildArguments... nodes); // O(M+N), M = number of attributes, N = number of nodes plus all their descendants
     constructor (ChildArguments... nodes); // shorthand
     constructor (Dictionary<String> attributes); // shorthand
     constructor (); // shorthand
     constructor attribute String tagName; // O(1) // "content"
     constructor attribute Boolean shadow; // O(1) // false
 
     Array<Node> getDistributedNodes(); // O(N) in distributed nodes
@@ skipping 164 matching lines @@
   typedef NewType OldType; // useful when OldType is a commonly-used union
 
   callback CallbackName ReturnType (ArgumentType argumentName);
 
   class ClassName {
     // a class corresponds to a JavaScript prototype
     // corresponds to a WebIDL 'interface'
   }
 
   abstract class Superclass {
-    // an abstract class can't have a constructor
-    // in every other respect it is the same as a regular class
+    // an abstract class can't have a non-abstract constructor
+    // an abstract class may have abstract constructors and methods
+    // an abstract class may have everything else a class can have
+
+    abstract constructor ();
+      // this indicates that non-abstract subclasses must have a constructor with the given arguments
+
+    abstract ReturnType methodCallback();
+      // this method does nothing, but is included to describe the interface that subclasses will implement
+      // a non-abstract class must have an explicit implementation of all inherited abstract methods
+    
   }
 
   class Subclass : Superclass {
     // properties
     readonly attribute ReturnType attributeName; // getter
     attribute ReturnType attributeName; // getter and setter
 
     // methods and constructors
     constructor ();
     ReturnType method();
       // When the platform calls this method, it always invokes the "real" method, even if it's been
       // deleted from the prototypes (as if it took a reference to the method at startup, and stored
       // state using Symbols)
       // Calling a method with fewer arguments than defined will throw.
       // Calling a method with more arguments ignores the extra arguments.
     virtual ReturnType methodCallback();
       // when the platform calls this, it actually calls it the way JS would, so author overrides do
       // affect what gets called. Make sure if you override it that you call the superclass implementation!
       // The default implementations of 'virtual' methods all end by calling the identically named method
       // on the superclass, if there is such a method.
 
+    // non-abstract classes cannot have abstract constructors or methods, and in particular, must
+    // have explicit non-abstract versions of any inherited abstract constructors or methods
+
     // properties on the constructor
     constructor readonly attribute ReturnType staticName;
 
     // private APIs - see below
     private void method();
 
     // arguments and overloading are done as follows
     // note that the argument names are only for documentation purposes
     ReturnType method(ArgumentType argumentName1, ArgumentType argumentName2);
     // the last argument's type can have "..." appended to it to indicate a varargs-like situation
@@ skipping 48 matching lines @@
 
 The following types are available:
 
 * ``Integer`` - WebIDL ``long long``
 * ``Float`` - WebIDL ``double``
 * ``Infinity`` - singleton type with value ``Infinity``
 * ``String`` - WebIDL ``USVString``
 * ``Boolean`` - WebIDL ``boolean``
 # ``Object`` - WebIDL ``object`` (``ClassName`` can be used as a literal for this type)
 * ``ClassName`` - an instance of the class ClassName
+* ``Class<ClassName>`` - a class ClassName or one of its subclasses (not an instance)
 * ``DictionaryName`` - an instance of the dictionary DictionaryName
 * ``Promise<Type>`` - WebIDL ``Promise<T>``
 * ``Generator<Type>`` - An ECMAScript generator function that returns data of the given type
 * ``Array<Type>`` - WebIDL ``sequence<T>``
 * ``Dictionary<Type>`` - unordered set of name-value String-Type pairs with no duplicate names
 * ``Type?`` - union of Type and the singleton type with value ``null`` (WebIDL nullable)
 * ``(Type1 or Type2)`` - union of Type1 and Type2 (WebIDL union)
 * ``any`` - union of all types (WebIDL ``any``)
 
 Methods that return nothing (undefined, in JS) use the keyword "void"
@@ skipping 24 matching lines @@
   the core mojo fabric JS API   sky:mojo:fabric:core
   the asyncWait/cancelWait mojo fabric JS API (interface to IPC thread)  sky:mojo:fabric:ipc
   the mojom for the shell, proxying through C++ so that the shell pipe isn't exposed  sky:mojo:shell
   the sky API  sky:core
   the sky debug symbols for private APIs  sky:debug
 ```
 
 TODO(ianh): determine if we want to separate the "this" from the
 Document, especially for Modules, so that exposing a module's element
 doesn't expose the module's exports attribute.