Clean up a bunch of our Dart code.

sky/sdk/lib/framework/fn2.dart

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 library fn;
 
 import 'app.dart';
 import 'dart:async';
 import 'dart:collection';
 import 'dart:mirrors';
@@ skipping 139 matching lines @@
     node._sync(oldNode, slot);
     assert(node.root is RenderObject);
     return node;
   }
 }
 
 // Descendants of TagNode provide a way to tag RenderObjectWrapper and
 // Component nodes with annotations, such as event listeners,
 // stylistic information, etc.
 abstract class TagNode extends UINode {
-  UINode content;
 
   TagNode(UINode content, { Object key }) : this.content = content, super(key: key);
 
+  UINode content;
+
   void _sync(UINode old, dynamic slot) {
     UINode oldContent = old == null ? null : (old as TagNode).content;
     content = syncChild(content, oldContent, slot);
     assert(content.root != null);
     root = content.root;
   }
 
   void remove() {
     if (content != null)
       removeChild(content);
     super.remove();
   }
+
 }
 
 class ParentDataNode extends TagNode {
+  ParentDataNode(UINode content, this.parentData, { Object key }): super(content, key: key);
   final ParentData parentData;
-
-  ParentDataNode(UINode content, this.parentData, { Object key }): super(content, key: key);
 }
 
 typedef void GestureEventListener(sky.GestureEvent e);
 typedef void PointerEventListener(sky.PointerEvent e);
 typedef void EventListener(sky.Event e);
 
 class EventListenerNode extends TagNode  {
+
+  EventListenerNode(UINode content, {
+    EventListener onWheel,
+    GestureEventListener onGestureFlingCancel,
+    GestureEventListener onGestureFlingStart,
+    GestureEventListener onGestureScrollStart,
+    GestureEventListener onGestureScrollUpdate,
+    GestureEventListener onGestureTap,
+    GestureEventListener onGestureTapDown,
+    PointerEventListener onPointerCancel,
+    PointerEventListener onPointerDown,
+    PointerEventListener onPointerMove,
+    PointerEventListener onPointerUp,
+    Map<String, sky.EventListener> custom
+  }) : listeners = _createListeners(
+         onWheel: onWheel,
+         onGestureFlingCancel: onGestureFlingCancel,
+         onGestureFlingStart: onGestureFlingStart,
+         onGestureScrollUpdate: onGestureScrollUpdate,
+         onGestureScrollStart: onGestureScrollStart,
+         onGestureTap: onGestureTap,
+         onGestureTapDown: onGestureTapDown,
+         onPointerCancel: onPointerCancel,
+         onPointerDown: onPointerDown,
+         onPointerMove: onPointerMove,
+         onPointerUp: onPointerUp,
+         custom: custom
+       ),
+       super(content);
+
   final Map<String, sky.EventListener> listeners;
 
   static Map<String, sky.EventListener> _createListeners({
     EventListener onWheel,
     GestureEventListener onGestureFlingCancel,
     GestureEventListener onGestureFlingStart,
     GestureEventListener onGestureScrollStart,
     GestureEventListener onGestureScrollUpdate,
     GestureEventListener onGestureTap,
     GestureEventListener onGestureTapDown,
@@ skipping 26 matching lines @@
     if (onPointerDown != null)
       listeners['pointerdown'] = onPointerDown;
     if (onPointerMove != null)
       listeners['pointermove'] = onPointerMove;
     if (onPointerUp != null)
       listeners['pointerup'] = onPointerUp;
 
     return listeners;
   }
 
-  EventListenerNode(UINode content, {
-    EventListener onWheel,
-    GestureEventListener onGestureFlingCancel,
-    GestureEventListener onGestureFlingStart,
-    GestureEventListener onGestureScrollStart,
-    GestureEventListener onGestureScrollUpdate,
-    GestureEventListener onGestureTap,
-    GestureEventListener onGestureTapDown,
-    PointerEventListener onPointerCancel,
-    PointerEventListener onPointerDown,
-    PointerEventListener onPointerMove,
-    PointerEventListener onPointerUp,
-    Map<String, sky.EventListener> custom
-  }) : listeners = _createListeners(
-         onWheel: onWheel,
-         onGestureFlingCancel: onGestureFlingCancel,
-         onGestureFlingStart: onGestureFlingStart,
-         onGestureScrollUpdate: onGestureScrollUpdate,
-         onGestureScrollStart: onGestureScrollStart,
-         onGestureTap: onGestureTap,
-         onGestureTapDown: onGestureTapDown,
-         onPointerCancel: onPointerCancel,
-         onPointerDown: onPointerDown,
-         onPointerMove: onPointerMove,
-         onPointerUp: onPointerUp,
-         custom: custom
-       ),
-       super(content);
-
   void _handleEvent(sky.Event e) {
     sky.EventListener listener = listeners[e.type];
     if (listener != null) {
       listener(e);
     }
   }
+
 }
 
 /*
  * RenderObjectWrappers correspond to a desired state of a RenderObject.
  * They are fully immutable, with one exception: A UINode which is a
  * Component which lives within an MultiChildRenderObjectWrapper's
  * children list, may be replaced with the "old" instance if it has
  * become stateful.
  */
 abstract class RenderObjectWrapper extends UINode {
 
-  static final Map<RenderObject, RenderObjectWrapper> _nodeMap =
-      new HashMap<RenderObject, RenderObjectWrapper>();
-
-  static RenderObjectWrapper _getMounted(RenderObject node) => _nodeMap[node];
-
   RenderObjectWrapper({
     Object key
   }) : super(key: key);
 
   RenderObject createNode();
 
   void insert(RenderObjectWrapper child, dynamic slot);
 
+  static final Map<RenderObject, RenderObjectWrapper> _nodeMap =
+      new HashMap<RenderObject, RenderObjectWrapper>();
+
+  static RenderObjectWrapper _getMounted(RenderObject node) => _nodeMap[node];
+
   void _sync(UINode old, dynamic slot) {
     assert(parent != null);
     if (old == null) {
       root = createNode();
       assert(root != null);
       var ancestor = findAncestor(RenderObjectWrapper);
       if (ancestor is RenderObjectWrapper)
         ancestor.insert(this, slot);
     } else {
       root = old.root;
@@ skipping 25 matching lines @@
   }
 
   void remove() {
     assert(root != null);
     _nodeMap.remove(root);
     super.remove();
   }
 }
 
 abstract class OneChildRenderObjectWrapper extends RenderObjectWrapper {
+
+  OneChildRenderObjectWrapper({ UINode child, Object key }) : _child = child, super(key: key);
+
   UINode _child;
   UINode get child => _child;
 
-  OneChildRenderObjectWrapper({ UINode child, Object key }) : _child = child, super(key: key);
-
   void syncRenderObject(RenderObjectWrapper old) {
     super.syncRenderObject(old);
     UINode oldChild = old == null ? null : (old as OneChildRenderObjectWrapper).child;
     _child = syncChild(child, oldChild, null);
   }
 
   void insert(RenderObjectWrapper child, dynamic slot) {
     final root = this.root; // TODO(ianh): Remove this once the analyzer is cleverer
     assert(slot == null);
     assert(root is RenderObjectWithChildMixin);
     root.child = child.root;
     assert(root == this.root); // TODO(ianh): Remove this once the analyzer is cleverer
   }
 
   void removeChild(UINode node) {
     final root = this.root; // TODO(ianh): Remove this once the analyzer is cleverer
     assert(root is RenderObjectWithChildMixin);
     root.child = null;
     super.removeChild(node);
     assert(root == this.root); // TODO(ianh): Remove this once the analyzer is cleverer
   }
 
   void remove() {
     if (child != null)
       removeChild(child);
     super.remove();
   }
+
 }
 
 class Clip extends OneChildRenderObjectWrapper {
-  RenderClip root;
 
   Clip({ UINode child, Object key })
     : super(child: child, key: key);
 
+  RenderClip root;
   RenderClip createNode() => new RenderClip();
+
 }
 
 class Padding extends OneChildRenderObjectWrapper {
-  RenderPadding root;
-  final EdgeDims padding;
 
   Padding({ this.padding, UINode child, Object key })
     : super(child: child, key: key);
 
+  RenderPadding root;
+  final EdgeDims padding;
+
   RenderPadding createNode() => new RenderPadding(padding: padding);
 
   void syncRenderObject(Padding old) {
     super.syncRenderObject(old);
     root.padding = padding;
   }
+
 }
 
 class DecoratedBox extends OneChildRenderObjectWrapper {
-  RenderDecoratedBox root;
-  final BoxDecoration decoration;
 
   DecoratedBox({ this.decoration, UINode child, Object key })
     : super(child: child, key: key);
 
+  RenderDecoratedBox root;
+  final BoxDecoration decoration;
+
   RenderDecoratedBox createNode() => new RenderDecoratedBox(decoration: decoration);
 
   void syncRenderObject(DecoratedBox old) {
     super.syncRenderObject(old);
     root.decoration = decoration;
   }
+
 }
 
 class SizedBox extends OneChildRenderObjectWrapper {
-  RenderSizedBox root;
-  final Size desiredSize;
 
   SizedBox({
     double width: double.INFINITY,
     double height: double.INFINITY,
     UINode child,
     Object key
   }) : desiredSize = new Size(width, height), super(child: child, key: key);
 
+  RenderSizedBox root;
+  final Size desiredSize;
+
   RenderSizedBox createNode() => new RenderSizedBox(desiredSize: desiredSize);
 
   void syncRenderObject(SizedBox old) {
     super.syncRenderObject(old);
     root.desiredSize = desiredSize;
   }
+
 }
 
 class ConstrainedBox extends OneChildRenderObjectWrapper {
-  RenderConstrainedBox root;
-  final BoxConstraints constraints;
 
   ConstrainedBox({ this.constraints, UINode child, Object key })
     : super(child: child, key: key);
 
+  RenderConstrainedBox root;
+  final BoxConstraints constraints;
+
   RenderConstrainedBox createNode() => new RenderConstrainedBox(additionalConstraints: constraints);
 
   void syncRenderObject(ConstrainedBox old) {
     super.syncRenderObject(old);
     root.additionalConstraints = constraints;
   }
+
 }
 
 class ShrinkWrapWidth extends OneChildRenderObjectWrapper {
-  RenderShrinkWrapWidth root;
 
   ShrinkWrapWidth({ UINode child, Object key }) : super(child: child, key: key);
 
+  RenderShrinkWrapWidth root;
+
   RenderShrinkWrapWidth createNode() => new RenderShrinkWrapWidth();
+
 }
 
 class Transform extends OneChildRenderObjectWrapper {
-  RenderTransform root;
-  final Matrix4 transform;
 
   Transform({ this.transform, UINode child, Object key })
     : super(child: child, key: key);
 
+  RenderTransform root;
+  final Matrix4 transform;
+
   RenderTransform createNode() => new RenderTransform(transform: transform);
 
   void syncRenderObject(Transform old) {
     super.syncRenderObject(old);
     root.transform = transform;
   }
+
 }
 
 class SizeObserver extends OneChildRenderObjectWrapper {
-  RenderSizeObserver root;
-  final SizeChangedCallback callback;
 
   SizeObserver({ this.callback, UINode child, Object key })
     : super(child: child, key: key);
 
+  RenderSizeObserver root;
+  final SizeChangedCallback callback;
+
   RenderSizeObserver createNode() => new RenderSizeObserver(callback: callback);
 
   void syncRenderObject(SizeObserver old) {
     super.syncRenderObject(old);
     root.callback = callback;
   }
 
   void remove() {
     root.callback = null;
     super.remove();
   }
+
 }
 
 // TODO(jackson) need a mechanism for marking the RenderCustomPaint as needing paint
 class CustomPaint extends OneChildRenderObjectWrapper {
-  RenderCustomPaint root;
-  final CustomPaintCallback callback;
 
   CustomPaint({ this.callback, UINode child, Object key })
     : super(child: child, key: key);
 
+  RenderCustomPaint root;
+  final CustomPaintCallback callback;
+
   RenderCustomPaint createNode() => new RenderCustomPaint(callback: callback);
 
   void syncRenderObject(CustomPaint old) {
     super.syncRenderObject(old);
     root.callback = callback;
   }
 
   void remove() {
     root.callback = null;
     super.remove();
   }
+
 }
 
 final List<UINode> _emptyList = new List<UINode>();
 
 abstract class MultiChildRenderObjectWrapper extends RenderObjectWrapper {
 
   // In MultiChildRenderObjectWrapper subclasses, slots are RenderObject nodes
   // to use as the "insert before" sibling in ContainerRenderObjectMixin.add() calls
 
-  final List<UINode> children;
-
   MultiChildRenderObjectWrapper({
     Object key,
     List<UINode> children
   }) : this.children = children == null ? _emptyList : children,
   super(
     key: key
   ) {
     assert(!_debugHasDuplicateIds());
   }
 
+  final List<UINode> children;
+
   void insert(RenderObjectWrapper child, dynamic slot) {
     final root = this.root; // TODO(ianh): Remove this once the analyzer is cleverer
     assert(slot == null || slot is RenderObject);
     assert(root is ContainerRenderObjectMixin);
     root.add(child.root, before: slot);
     assert(root == this.root); // TODO(ianh): Remove this once the analyzer is cleverer
   }
 
   void removeChild(UINode node) {
     final root = this.root; // TODO(ianh): Remove this once the analyzer is cleverer
@@ skipping 147 matching lines @@
     // Removals
     currentNode = null;
     while (oldStartIndex < oldEndIndex) {
       oldNode = oldChildren[oldStartIndex];
       removeChild(oldNode);
       advanceOldStartIndex();
     }
 
     assert(root == this.root); // TODO(ianh): Remove this once the analyzer is cleverer
   }
+
 }
 
 class BlockContainer extends MultiChildRenderObjectWrapper {
+
+  BlockContainer({ Object key, List<UINode> children })
+    : super(key: key, children: children);
+
   RenderBlock root;
   RenderBlock createNode() => new RenderBlock();
 
-  BlockContainer({ Object key, List<UINode> children })
-    : super(key: key, children: children);
 }
 
 class StackContainer extends MultiChildRenderObjectWrapper {
+
+  StackContainer({ Object key, List<UINode> children })
+    : super(key: key, children: children);
+
   RenderStack root;
   RenderStack createNode() => new RenderStack();
 
-  StackContainer({ Object key, List<UINode> children })
-    : super(key: key, children: children);
 }
 
 class StackPositionedChild extends ParentDataNode {
   StackPositionedChild(UINode content, {
     double top, double right, double bottom, double left
   }) : super(content, new StackParentData()..top = top
                                            ..right = right
                                            ..bottom = bottom
                                            ..left = left);
 }
 
 class Paragraph extends RenderObjectWrapper {
+
+  Paragraph({ Object key, this.text }) : super(key: key);
+
   RenderParagraph root;
   RenderParagraph createNode() => new RenderParagraph(text: text);
 
   final String text;
 
-  Paragraph({ Object key, this.text }) : super(key: key);
-
   void syncRenderObject(UINode old) {
     super.syncRenderObject(old);
     root.text = text;
   }
 
   void insert(RenderObjectWrapper child, dynamic slot) {
     assert(false);
     // Paragraph does not support having children currently
   }
+
 }
 
 class FlexContainer extends MultiChildRenderObjectWrapper {
-  RenderFlex root;
-  RenderFlex createNode() => new RenderFlex(direction: this.direction);
-
-  final FlexDirection direction;
-  final FlexJustifyContent justifyContent;
 
   FlexContainer({
     Object key,
     List<UINode> children,
     this.direction: FlexDirection.horizontal,
     this.justifyContent: FlexJustifyContent.flexStart
   }) : super(key: key, children: children);
 
+  RenderFlex root;
+  RenderFlex createNode() => new RenderFlex(direction: this.direction);
+
+  final FlexDirection direction;
+  final FlexJustifyContent justifyContent;
+
   void syncRenderObject(UINode old) {
     super.syncRenderObject(old);
     root.direction = direction;
     root.justifyContent = justifyContent;
   }
+
 }
 
 class FlexExpandingChild extends ParentDataNode {
   FlexExpandingChild(UINode content, { int flex: 1, Object key })
     : super(content, new FlexBoxParentData()..flex = flex, key: key);
 }
 
 class Image extends RenderObjectWrapper {
-  RenderImage root;
-  RenderImage createNode() => new RenderImage(this.src, this.size);
-
-  final String src;
-  final Size size;
 
   Image({
     Object key,
     this.src,
     this.size
   }) : super(key: key);
 
+  RenderImage root;
+  RenderImage createNode() => new RenderImage(this.src, this.size);
+
+  final String src;
+  final Size size;
+
   void syncRenderObject(UINode old) {
     super.syncRenderObject(old);
     root.src = src;
     root.requestedSize = size;
   }
 
   void insert(RenderObjectWrapper child, dynamic slot) {
     assert(false);
     // Image does not support having children currently
   }
+
 }
 
 Set<Component> _dirtyComponents = new Set<Component>();
 bool _buildScheduled = false;
 bool _inRenderDirtyComponents = false;
 
 void _buildDirtyComponents() {
   //_tracing.begin('fn::_buildDirtyComponents');
 
   Stopwatch sw;
@@ skipping 29 matching lines @@
   assert(!_inRenderDirtyComponents);
   _dirtyComponents.add(c);
 
   if (!_buildScheduled) {
     _buildScheduled = true;
     new Future.microtask(_buildDirtyComponents);
   }
 }
 
 abstract class Component extends UINode {
+
+  Component({ Object key, bool stateful })
+      : _stateful = stateful != null ? stateful : false,
+        _order = _currentOrder + 1,
+        super(key: key);
+
+  Component.fromArgs(Object key, bool stateful)
+      : this(key: key, stateful: stateful);
+
+  static Component _currentlyBuilding;
   bool get _isBuilding => _currentlyBuilding == this;
+
+  bool _stateful;
   bool _dirty = true;
-
   bool _disqualifiedFromEverAppearingAgain = false;
 
-  UINode _built;
-  final int _order;
-  static int _currentOrder = 0;
-  bool _stateful;
-  static Component _currentlyBuilding;
   List<Function> _mountCallbacks;
   List<Function> _unmountCallbacks;
-  dynamic _slot; // cached slot from the last time we were synced
 
   void onDidMount(Function fn) {
     if (_mountCallbacks == null)
       _mountCallbacks = new List<Function>();
 
     _mountCallbacks.add(fn);
   }
 
   void onDidUnmount(Function fn) {
     if (_unmountCallbacks == null)
       _unmountCallbacks = new List<Function>();
 
     _unmountCallbacks.add(fn);
   }
 
-  Component({ Object key, bool stateful })
-      : _stateful = stateful != null ? stateful : false,
-        _order = _currentOrder + 1,
-        super(key: key);
-
-  Component.fromArgs(Object key, bool stateful)
-      : this(key: key, stateful: stateful);
-
   void _didMount() {
     assert(!_disqualifiedFromEverAppearingAgain);
     super._didMount();
     if (_mountCallbacks != null)
       for (Function fn in _mountCallbacks)
         fn();
   }
 
   void _didUnmount() {
     super._didUnmount();
@@ skipping 23 matching lines @@
     assert(_built != null);
     _disqualifiedFromEverAppearingAgain = true;
 
     // Make |oldComponent| the "new" component
     reflect.copyPublicFields(this, oldComponent);
     oldComponent._built = null;
     oldComponent._dirty = true;
     return true;
   }
 
+  final int _order;
+  static int _currentOrder = 0;
+
   /* There are three cases here:
    * 1) Building for the first time:
    *      assert(_built == null && old == null)
    * 2) Re-building (because a dirty flag got set):
    *      assert(_built != null && old == null)
    * 3) Syncing against an old version
    *      assert(_built == null && old != null)
    */
   void _sync(UINode old, dynamic slot) {
     assert(_built == null || old == null);
@@ skipping 44 matching lines @@
     _stateful = true;
     fn();
     if (_isBuilding || _dirty || !_mounted)
       return;
 
     _dirty = true;
     _scheduleComponentForRender(this);
   }
 
   UINode build();
+
 }
 
 class Container extends Component {
-  final UINode child;
-  final BoxConstraints constraints;
-  final BoxDecoration decoration;
-  final EdgeDims margin;
-  final EdgeDims padding;
-  final Matrix4 transform;
-  final double width;
-  final double height;
 
   Container({
     Object key,
     this.child,
     this.constraints,
     this.decoration,
     this.width,
     this.height,
     this.margin,
     this.padding,
     this.transform
   }) : super(key: key);
 
+  final UINode child;
+  final BoxConstraints constraints;
+  final BoxDecoration decoration;
+  final EdgeDims margin;
+  final EdgeDims padding;
+  final Matrix4 transform;
+  final double width;
+  final double height;
+
   UINode build() {
     UINode current = child;
 
     if (child == null && width == null && height == null)
       current = new SizedBox();
 
     if (padding != null)
       current = new Padding(padding: padding, child: current);
 
     if (decoration != null)
@@ skipping 10 matching lines @@
       current = new ConstrainedBox(constraints: constraints, child: current);
 
     if (margin != null)
       current = new Padding(padding: margin, child: current);
 
     if (transform != null)
       current = new Transform(transform: transform, child: current);
 
     return current;
   }
+
 }
 
 class _AppView extends AppView {
   _AppView() : super(null);
 
   void dispatchEvent(sky.Event event, HitTestResult result) {
     super.dispatchEvent(event, result);
 
     UINode target = RenderObjectWrapper._getMounted(result.path.first);
 
@@ skipping 18 matching lines @@
   AppView get appView => _appView;
 
   void _buildIfDirty() {
     assert(_dirty);
     assert(_mounted);
     _sync(null, null);
     if (root.parent == null)
       _appView.root = root;
     assert(root.parent is RenderView);
   }
+
 }
 
 class Text extends Component {
   Text(this.data) : super(key: '*text*');
   final String data;
   bool get interchangeable => true;
   UINode build() => new Paragraph(text: data);
 }