Add @override annotation to known overriden methods

sky/sdk/lib/widgets/widget.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.
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:sky' as sky;
 
 import 'package:sky/mojo/activity.dart' as activity;
 
@@ skipping 189 matching lines @@
     }
 
     assert(oldNode == null || (oldNode.mounted == false && oldNode.parent == null));
     assert(!newNode.mounted);
     newNode.setParent(this);
     newNode._sync(oldNode, slot);
     assert(newNode.root is RenderObject);
     return newNode;
   }
 
+  @override
   String toString([String prefix = '', String startPrefix = '']) {
     String childrenString = '';
     List<Widget> children = new List<Widget>();
     walkChildren(children.add);
     if (children.length > 0) {
       Widget lastChild = children.removeLast();
       String nextStartPrefix = prefix + ' +-';
       String nextPrefix = prefix + ' | ';
       for (Widget child in children)
         childrenString += child.toString(nextPrefix, nextStartPrefix);
@@ skipping 19 matching lines @@
 
   TagNode(Widget child, { String key })
     : this.child = child, super(key: key);
 
   // TODO(jackson): Remove this workaround for limitation of Dart mixins
   TagNode._withKey(Widget child, String key)
     : this.child = child, super._withKey(key);
 
   Widget child;
 
+  @override
   void walkChildren(WidgetTreeWalker walker) {
     if (child != null)
       walker(child);
   }
 
+  @override
   void _sync(Widget old, dynamic slot) {
     Widget oldChild = old == null ? null : (old as TagNode).child;
     child = syncChild(child, oldChild, slot);
     assert(child.parent == this);
     assert(child.root != null);
     _root = child.root;
     assert(_root == root); // in case a subclass reintroduces it
   }
 
+  @override
   void updateSlot(dynamic newSlot) {
     child.updateSlot(newSlot);
   }
 
+  @override
   void remove() {
     if (child != null)
       removeChild(child);
     super.remove();
   }
 
+  @override
   void detachRoot() {
     if (child != null)
       child.detachRoot();
   }
 
 }
 
 class ParentDataNode extends TagNode {
   ParentDataNode(Widget child, this.parentData, { String key })
     : super(child, key: key);
   final ParentData parentData;
 }
 
 abstract class Inherited extends TagNode {
 
   Inherited({ String key, Widget child }) : super._withKey(child, key);
 
+  @override
   void _sync(Widget old, dynamic slot) {
     if (old != null && syncShouldNotify(old)) {
       final Type ourRuntimeType = runtimeType;
       void notifyChildren(Widget child) {
         if (child is Component &&
             child._dependencies != null &&
             child._dependencies.contains(ourRuntimeType))
           child._dependenciesChanged();
         if (child.runtimeType != ourRuntimeType)
           child.walkChildren(notifyChildren);
@@ skipping 106 matching lines @@
         super._withKey(key);
 
   static Component _currentlyBuilding;
   bool get _isBuilding => _currentlyBuilding == this;
 
   bool _dirty = true;
 
   Widget _built;
   dynamic _slot; // cached slot from the last time we were synced
 
+  @override
   void updateSlot(dynamic newSlot) {
     _slot = newSlot;
     if (_built != null)
       _built.updateSlot(newSlot);
   }
 
+  @override
   void walkChildren(WidgetTreeWalker walker) {
     if (_built != null)
       walker(_built);
   }
 
+  @override
   void remove() {
     assert(_built != null);
     assert(root != null);
     removeChild(_built);
     _built = null;
     super.remove();
   }
 
+  @override
   void detachRoot() {
     assert(_built != null);
     assert(root != null);
     _built.detachRoot();
   }
 
   Set<Type> _dependencies;
   Inherited inheritedOfType(Type targetType) {
     if (_dependencies == null)
       _dependencies = new Set<Type>();
@@ skipping 16 matching lines @@
   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)
+  @override
   void _sync(Component old, dynamic slot) {
     assert(_built == null || old == null);
 
     updateSlot(slot);
 
     var oldBuilt;
     if (old == null) {
       oldBuilt = _built;
     } else {
       assert(_built == null);
@@ skipping 34 matching lines @@
   Widget build();
 
 }
 
 abstract class StatefulComponent extends Component {
 
   StatefulComponent({ String key }) : super(key: key);
 
   bool _disqualifiedFromEverAppearingAgain = false;
 
+  @override
   void didMount() {
     assert(!_disqualifiedFromEverAppearingAgain);
     super.didMount();
   }
 
+  @override
   void _buildIfDirty() {
     assert(!_disqualifiedFromEverAppearingAgain);
     super._buildIfDirty();
   }
 
+  @override
   void _sync(Widget old, dynamic slot) {
     assert(!_disqualifiedFromEverAppearingAgain);
     super._sync(old, slot);
   }
 
+  @override
   Widget syncChild(Widget node, Widget oldNode, dynamic slot) {
     assert(!_disqualifiedFromEverAppearingAgain);
     return super.syncChild(node, oldNode, slot);
   }
 
+  @override
   bool retainStatefulNodeIfPossible(StatefulComponent newNode) {
     assert(!_disqualifiedFromEverAppearingAgain);
     assert(newNode != null);
     assert(runtimeType == newNode.runtimeType);
     assert(key == newNode.key);
     assert(_built != null);
     newNode._disqualifiedFromEverAppearingAgain = true;
 
     newNode._built = _built;
     _built = null;
@@ skipping 116 matching lines @@
 
   RenderObjectWrapper _ancestor;
   void insertChildRoot(RenderObjectWrapper child, dynamic slot);
   void detachChildRoot(RenderObjectWrapper child);
 
   void retainStatefulRenderObjectWrapper(RenderObjectWrapper newNode) {
     newNode._root = _root;
     newNode._ancestor = _ancestor;
   }
 
+  @override
   void _sync(RenderObjectWrapper old, dynamic slot) {
     // TODO(abarth): We should split RenderObjectWrapper into two pieces so that
     //               RenderViewObject doesn't need to inherit all this code it
     //               doesn't need.
     assert(parent != null || this is RenderViewWrapper);
     if (old == null) {
       _root = createNode();
       assert(_root != null);
       _ancestor = findAncestorRenderObjectWrapper();
       if (_ancestor is RenderObjectWrapper)
         _ancestor.insertChildRoot(this, slot);
     } else {
       assert(old is RenderObjectWrapper);
       _root = old.root;
       _ancestor = old._ancestor;
       assert(_root != null);
     }
     assert(_root == root); // in case a subclass reintroduces it
     assert(root != null);
     assert(mounted);
     _nodeMap[root] = this;
     syncRenderObject(old);
   }
 
+  @override
   void updateSlot(dynamic newSlot) {
     // We never use the slot except during sync(), in which
     // case our parent is handing it to us anyway.
     // We don't need to propagate this to our children, since
     // we give them their own slots for them to fit into us.
   }
 
   void syncRenderObject(RenderObjectWrapper old) {
     ParentData parentData = null;
     Widget ancestor = parent;
     while (ancestor != null && ancestor is! RenderObjectWrapper) {
       if (ancestor is ParentDataNode && ancestor.parentData != null) {
         if (parentData != null)
           parentData.merge(ancestor.parentData); // this will throw if the types aren't the same
         else
           parentData = ancestor.parentData;
       }
       ancestor = ancestor.parent;
     }
     if (parentData != null) {
       assert(root.parentData != null);
       root.parentData.merge(parentData); // this will throw if the types aren't appropriate
       if (parent.root != null)
         parent.root.markNeedsLayout();
     }
   }
 
+  @override
   void remove() {
     assert(root != null);
     _nodeMap.remove(root);
     super.remove();
   }
 
+  @override
   void detachRoot() {
     assert(_ancestor != null);
     assert(root != null);
     _ancestor.detachChildRoot(this);
   }
 
 }
 
 abstract class LeafRenderObjectWrapper extends RenderObjectWrapper {
 
   LeafRenderObjectWrapper({ String key }) : super(key: key);
 
+  @override
   void insertChildRoot(RenderObjectWrapper child, dynamic slot) {
     assert(false);
   }
 
+  @override
   void detachChildRoot(RenderObjectWrapper child) {
     assert(false);
   }
 
 }
 
 abstract class OneChildRenderObjectWrapper extends RenderObjectWrapper {
 
   OneChildRenderObjectWrapper({ String key, Widget child })
     : _child = child, super(key: key);
 
   Widget _child;
   Widget get child => _child;
 
+  @override
   void walkChildren(WidgetTreeWalker walker) {
     if (child != null)
       walker(child);
   }
 
+  @override
   void syncRenderObject(RenderObjectWrapper old) {
     super.syncRenderObject(old);
     Widget oldChild = old == null ? null : (old as OneChildRenderObjectWrapper).child;
     Widget newChild = child;
     _child = syncChild(newChild, oldChild, null);
     assert((newChild == null && child == null) || (newChild != null && child.parent == this));
     assert(oldChild == null || child == oldChild || oldChild.parent == null);
   }
 
+  @override
   void insertChildRoot(RenderObjectWrapper child, dynamic slot) {
     final root = this.root; // TODO(ianh): Remove this once the analyzer is cleverer
     assert(root is RenderObjectWithChildMixin);
     assert(slot == null);
     root.child = child.root;
     assert(root == this.root); // TODO(ianh): Remove this once the analyzer is cleverer
   }
 
+  @override
   void detachChildRoot(RenderObjectWrapper child) {
     final root = this.root; // TODO(ianh): Remove this once the analyzer is cleverer
     assert(root is RenderObjectWithChildMixin);
     assert(root.child == child.root);
     root.child = null;
     assert(root == this.root); // TODO(ianh): Remove this once the analyzer is cleverer
   }
 
+  @override
   void remove() {
     if (child != null)
       removeChild(child);
     super.remove();
   }
 }
 
 abstract class MultiChildRenderObjectWrapper extends RenderObjectWrapper {
 
   // In MultiChildRenderObjectWrapper subclasses, slots are RenderObject nodes
   // to use as the "insert before" sibling in ContainerRenderObjectMixin.add() calls
 
   MultiChildRenderObjectWrapper({ String key, List<Widget> children })
     : this.children = children == null ? const [] : children,
       super(key: key) {
     assert(!_debugHasDuplicateIds());
   }
 
   final List<Widget> children;
 
+  @override
   void walkChildren(WidgetTreeWalker walker) {
     for (Widget child in children)
       walker(child);
   }
 
+  @override
   void insertChildRoot(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
   }
 
+  @override
   void detachChildRoot(RenderObjectWrapper child) {
     final root = this.root; // TODO(ianh): Remove this once the analyzer is cleverer
     assert(root is ContainerRenderObjectMixin);
     assert(child.root.parent == root);
     root.remove(child.root);
     assert(root == this.root); // TODO(ianh): Remove this once the analyzer is cleverer
   }
 
+  @override
   void remove() {
     assert(children != null);
     for (var child in children) {
       assert(child != null);
       removeChild(child);
     }
     super.remove();
   }
 
   bool _debugHasDuplicateIds() {
     var idSet = new HashSet<String>();
     for (var child in children) {
       assert(child != null);
       if (child.key == null)
         continue; // when these nodes are reordered, we just reassign the data
 
       if (!idSet.add(child.key)) {
         throw '''If multiple keyed nodes exist as children of another node, they must have unique keys. $this has duplicate child key "${child.key}".''';
       }
     }
     return false;
   }
 
+  @override
   void syncRenderObject(MultiChildRenderObjectWrapper old) {
     super.syncRenderObject(old);
 
     final root = this.root; // TODO(ianh): Remove this once the analyzer is cleverer
     if (root is! ContainerRenderObjectMixin)
       return;
 
     var startIndex = 0;
     var endIndex = children.length;
 
@@ skipping 127 matching lines @@
 
   WidgetSkyBinding({ RenderView renderViewOverride: null })
       : super(renderViewOverride: renderViewOverride);
 
   static void initWidgetSkyBinding({ RenderView renderViewOverride: null }) {
     if (SkyBinding.instance == null)
       new WidgetSkyBinding(renderViewOverride: renderViewOverride);
     assert(SkyBinding.instance is WidgetSkyBinding);
   }
 
+  @override
   void dispatchEvent(sky.Event event, HitTestResult result) {
     assert(SkyBinding.instance == this);
     super.dispatchEvent(event, result);
     for (HitTestEntry entry in result.path.reversed) {
       Widget target = RenderObjectWrapper._getMounted(entry.target);
       if (target == null)
         continue;
       RenderObject targetRoot = target.root;
       while (target != null && target.root == targetRoot) {
         if (target is Listener)
           target._handleEvent(event);
         target = target._parent;
       }
     }
   }
 
 }
 
 abstract class App extends StatefulComponent {
 
   App({ String key }) : super(key: key);
 
   void _handleEvent(sky.Event event) {
     if (event.type == 'back')
       onBack();
   }
 
+  @override
   void didMount() {
     super.didMount();
     SkyBinding.instance.addEventListener(_handleEvent);
   }
 
+  @override
   void didUnmount() {
     super.didUnmount();
     SkyBinding.instance.removeEventListener(_handleEvent);
   }
 
+  @override
   void syncFields(Component source) { }
 
   // Override this to handle back button behavior in your app
   // Call super.onBack() to finish the activity
   void onBack() {
     activity.finishCurrentActivity();
   }
 }
 
 abstract class AbstractWidgetRoot extends StatefulComponent {
 
   AbstractWidgetRoot() {
     _mounted = true;
     _scheduleComponentForRender(this);
   }
 
+  @override
   void syncFields(AbstractWidgetRoot source) {
     assert(false);
     // if we get here, it implies that we have a parent
   }
 
+  @override
   void _buildIfDirty() {
     assert(_dirty);
     assert(_mounted);
     assert(parent == null);
     _sync(null, null);
   }
 
 }
 
 class RenderViewWrapper extends OneChildRenderObjectWrapper {
   RenderViewWrapper({ String key, Widget child }) : super(key: key, child: child);
+
+  @override
   RenderView get root => super.root;
+
+  @override
   RenderView createNode() => SkyBinding.instance.renderView;
 }
 
 class AppContainer extends AbstractWidgetRoot {
   AppContainer(this.app) {
     assert(SkyBinding.instance is WidgetSkyBinding);
   }
   final App app;
+
+  @override
   Widget build() => new RenderViewWrapper(child: app);
 }
 
 void runApp(App app, { RenderView renderViewOverride, bool enableProfilingLoop: false }) {
   WidgetSkyBinding.initWidgetSkyBinding(renderViewOverride: renderViewOverride);
   new AppContainer(app);
   if (enableProfilingLoop) {
     new Timer.periodic(const Duration(milliseconds: 20), (_) {
       app.scheduleBuild();
     });
@@ skipping 21 matching lines @@
       _container = value;
       if (root != null) {
         _container.child = root;
         assert(_container.child == root);
       }
     }
   }
 
   final Builder builder;
 
+  @override
   void _buildIfDirty() {
     super._buildIfDirty();
     if (root.parent == null) {
       // we haven't attached it yet
       assert(_container.child == null);
       _container.child = root;
     }
     assert(root.parent == _container);
   }
 
+  @override
   Widget build() => builder();
 }