Change how we narrow the "root" type on RenderObjectWrappers.

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 66 matching lines @@
         }
       }
       _mountedChanged.clear();
     } finally {
       _notifyingMountStatus = false;
     }
   }
   void didMount() { }
   void didUnmount() { }
 
-  RenderObject root;
+  RenderObject _root;
+  RenderObject get root => _root;
 
   // Subclasses which implements Nodes that become stateful may return true
   // if the |old| node has become stateful and should be retained.
   // This is called immediately before _sync().
   // Component._retainStatefulNodeIfPossible() calls syncFields().
   bool _retainStatefulNodeIfPossible(UINode old) => false;
 
   bool get interchangeable => false; // if true, then keys can be duplicated
 
   void _sync(UINode old, dynamic slot);
   // 'slot' is the identifier that the parent RenderObjectWrapper uses to know
   // where to put this descendant
 
   void remove() {
-    root = null;
+    _root = null;
     setParent(null);
   }
 
   UINode findAncestor(Type targetType) {
     var ancestor = _parent;
     while (ancestor != null && !reflectClass(ancestor.runtimeType).isSubtypeOf(reflectClass(targetType)))
       ancestor = ancestor._parent;
     return ancestor;
   }
 
@@ skipping 47 matching lines @@
 abstract class TagNode extends UINode {
 
   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;
+    _root = content.root;
+    assert(_root == root); // in case a subclass reintroduces it
   }
 
   void remove() {
     if (content != null)
       removeChild(content);
     super.remove();
   }
 
 }
 
@@ skipping 110 matching lines @@
   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);
+      _root = createNode();
       var ancestor = findAncestor(RenderObjectWrapper);
       if (ancestor is RenderObjectWrapper)
         ancestor.insert(this, slot);
     } else {
-      root = old.root;
+      _root = old.root;
     }
+    assert(_root == root); // in case a subclass reintroduces it
+    assert(root != null);
     assert(mounted);
-    assert(root != null);
     _nodeMap[root] = this;
     syncRenderObject(old);
   }
 
   void syncRenderObject(RenderObjectWrapper old) {
     ParentData parentData = null;
     UINode ancestor = parent;
     while (ancestor != null && ancestor is! RenderObjectWrapper) {
       if (ancestor is ParentDataNode && ancestor.parentData != null) {
         if (parentData != null)
@@ skipping 53 matching lines @@
     super.remove();
   }
 
 }
 
 class Clip extends OneChildRenderObjectWrapper {
 
   Clip({ UINode child, Object key })
     : super(child: child, key: key);
 
-  RenderClip root;
+  RenderClip get root => super.root as RenderClip;
   RenderClip createNode() => new RenderClip();
 
 }
 
 class Padding extends OneChildRenderObjectWrapper {
 
   Padding({ this.padding, UINode child, Object key })
     : super(child: child, key: key);
 
-  RenderPadding root;
+  RenderPadding get root => super.root as RenderPadding;
   final EdgeDims padding;
 
   RenderPadding createNode() => new RenderPadding(padding: padding);
 
   void syncRenderObject(Padding old) {
     super.syncRenderObject(old);
     root.padding = padding;
   }
 
 }
 
 class DecoratedBox extends OneChildRenderObjectWrapper {
 
   DecoratedBox({ this.decoration, UINode child, Object key })
     : super(child: child, key: key);
 
-  RenderDecoratedBox root;
+  RenderDecoratedBox get root => super.root as RenderDecoratedBox;
   final BoxDecoration decoration;
 
   RenderDecoratedBox createNode() => new RenderDecoratedBox(decoration: decoration);
 
   void syncRenderObject(DecoratedBox old) {
     super.syncRenderObject(old);
     root.decoration = decoration;
   }
 
 }
 
 class SizedBox extends OneChildRenderObjectWrapper {
 
   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;
+  RenderSizedBox get root => super.root as RenderSizedBox;
   final Size desiredSize;
 
   RenderSizedBox createNode() => new RenderSizedBox(desiredSize: desiredSize);
 
   void syncRenderObject(SizedBox old) {
     super.syncRenderObject(old);
     root.desiredSize = desiredSize;
   }
 
 }
 
 class ConstrainedBox extends OneChildRenderObjectWrapper {
 
   ConstrainedBox({ this.constraints, UINode child, Object key })
     : super(child: child, key: key);
 
-  RenderConstrainedBox root;
+  RenderConstrainedBox get root => super.root as RenderConstrainedBox;
   final BoxConstraints constraints;
 
   RenderConstrainedBox createNode() => new RenderConstrainedBox(additionalConstraints: constraints);
 
   void syncRenderObject(ConstrainedBox old) {
     super.syncRenderObject(old);
     root.additionalConstraints = constraints;
   }
 
 }
 
 class ShrinkWrapWidth extends OneChildRenderObjectWrapper {
 
   ShrinkWrapWidth({ UINode child, Object key }) : super(child: child, key: key);
 
-  RenderShrinkWrapWidth root;
+  RenderShrinkWrapWidth get root => super.root as RenderShrinkWrapWidth;
 
   RenderShrinkWrapWidth createNode() => new RenderShrinkWrapWidth();
 
 }
 
 class Transform extends OneChildRenderObjectWrapper {
 
   Transform({ this.transform, UINode child, Object key })
     : super(child: child, key: key);
 
-  RenderTransform root;
+  RenderTransform get root => super.root as RenderTransform;
   final Matrix4 transform;
 
   RenderTransform createNode() => new RenderTransform(transform: transform);
 
   void syncRenderObject(Transform old) {
     super.syncRenderObject(old);
     root.transform = transform;
   }
 
 }
 
 class SizeObserver extends OneChildRenderObjectWrapper {
 
   SizeObserver({ this.callback, UINode child, Object key })
     : super(child: child, key: key);
 
-  RenderSizeObserver root;
+  RenderSizeObserver get root => super.root as RenderSizeObserver;
   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 {
 
   CustomPaint({ this.callback, UINode child, Object key })
     : super(child: child, key: key);
 
-  RenderCustomPaint root;
+  RenderCustomPaint get root => super.root as RenderCustomPaint;
   final CustomPaintCallback callback;
 
   RenderCustomPaint createNode() => new RenderCustomPaint(callback: callback);
 
   void syncRenderObject(CustomPaint old) {
     super.syncRenderObject(old);
     root.callback = callback;
   }
 
   void remove() {
@@ skipping 186 matching lines @@
     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 get root => super.root as RenderBlock;
   RenderBlock createNode() => new RenderBlock();
 
 }
 
 class StackContainer extends MultiChildRenderObjectWrapper {
 
   StackContainer({ Object key, List<UINode> children })
     : super(key: key, children: children);
 
-  RenderStack root;
+  RenderStack get root => super.root as RenderStack;
   RenderStack createNode() => new RenderStack();
 
 }
 
 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 get root => super.root as RenderParagraph;
   RenderParagraph createNode() => new RenderParagraph(text: text);
 
   final String text;
 
   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 {
 
   FlexContainer({
     Object key,
     List<UINode> children,
     this.direction: FlexDirection.horizontal,
     this.justifyContent: FlexJustifyContent.flexStart
   }) : super(key: key, children: children);
 
-  RenderFlex root;
+  RenderFlex get root => super.root as RenderFlex;
   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 {
 
   Image({
     Object key,
     this.src,
     this.size
   }) : super(key: key);
 
-  RenderImage root;
+  RenderImage get root => super.root as RenderImage;
   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;
   }
@@ skipping 147 matching lines @@
     _currentOrder = _order;
     _currentlyBuilding = this;
     _built = build();
     assert(_built != null);
     _currentlyBuilding = null;
     _currentOrder = lastOrder;
 
     _built = syncChild(_built, oldBuilt, slot);
     assert(_built != null);
     _dirty = false;
-    root = _built.root;
+    _root = _built.root;
+    assert(_root == root); // in case a subclass reintroduces it
     assert(root != null);
   }
 
   void _buildIfDirty() {
     assert(!_disqualifiedFromEverAppearingAgain);
     if (!_dirty || !_mounted)
       return;
 
     assert(root != null);
     _sync(null, _slot);
@@ skipping 112 matching lines @@
   }
 
 }
 
 class Text extends Component {
   Text(this.data) : super(key: '*text*');
   final String data;
   bool get interchangeable => true;
   UINode build() => new Paragraph(text: data);
 }