Add @override annotation to known overriden methods

sky/sdk/lib/rendering/stack.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:math' as math;
 
 import 'box.dart';
 import 'object.dart';
 
 class StackParentData extends BoxParentData with ContainerParentDataMixin<RenderBox> {
   double top;
   double right;
   double bottom;
   double left;
 
+  @override
   void merge(StackParentData other) {
     if (other.top != null)
       top = other.top;
     if (other.right != null)
       right = other.right;
     if (other.bottom != null)
       bottom = other.bottom;
     if (other.left != null)
       left = other.left;
     super.merge(other);
   }
 
   bool get isPositioned => top != null || right != null || bottom != null || left != null;
 
+  @override
   String toString() => '${super.toString()}; top=$top; right=$right; bottom=$bottom, left=$left';
 }
 
 class RenderStack extends RenderBox with ContainerRenderObjectMixin<RenderBox, StackParentData>,
                                          RenderBoxContainerDefaultsMixin<RenderBox, StackParentData> {
   RenderStack({
     List<RenderBox> children
   }) {
     addAll(children);
   }
 
+  @override
   void setupParentData(RenderBox child) {
     if (child.parentData is! StackParentData)
       child.parentData = new StackParentData();
   }
 
-
+  @override
   double getMinIntrinsicWidth(BoxConstraints constraints) {
     double width = constraints.minWidth;
     RenderBox child = firstChild;
     while (child != null) {
       assert(child.parentData is StackParentData);
       if (!child.parentData.isPositioned)
         width = math.max(width, child.getMinIntrinsicWidth(constraints));
       child = child.parentData.nextSibling;
     }
     assert(width == constraints.constrainWidth(width));
     return width;
   }
 
+  @override
   double getMaxIntrinsicWidth(BoxConstraints constraints) {
     bool hasNonPositionedChildren = false;
     double width = constraints.minWidth;
     RenderBox child = firstChild;
     while (child != null) {
       assert(child.parentData is StackParentData);
       if (!child.parentData.isPositioned) {
         hasNonPositionedChildren = true;
         width = math.max(width, child.getMaxIntrinsicWidth(constraints));
       }
       child = child.parentData.nextSibling;
     }
     if (!hasNonPositionedChildren)
       return constraints.constrainWidth();
     assert(width == constraints.constrainWidth(width));
     return width;
   }
 
+  @override
   double getMinIntrinsicHeight(BoxConstraints constraints) {
     double height = constraints.minHeight;
     RenderBox child = firstChild;
     while (child != null) {
       assert(child.parentData is StackParentData);
       if (!child.parentData.isPositioned)
         height = math.max(height, child.getMinIntrinsicHeight(constraints));
       child = child.parentData.nextSibling;
     }
     assert(height == constraints.constrainHeight(height));
     return height;
   }
 
+  @override
   double getMaxIntrinsicHeight(BoxConstraints constraints) {
     bool hasNonPositionedChildren = false;
     double height = constraints.minHeight;
     RenderBox child = firstChild;
     while (child != null) {
       assert(child.parentData is StackParentData);
       if (!child.parentData.isPositioned) {
         hasNonPositionedChildren = true;
         height = math.max(height, child.getMaxIntrinsicHeight(constraints));
       }
       child = child.parentData.nextSibling;
     }
     if (!hasNonPositionedChildren)
       return constraints.constrainHeight();
     assert(height == constraints.constrainHeight(height));
     return height;
   }
 
+  @override
   double computeDistanceToActualBaseline(TextBaseline baseline) {
     return defaultComputeDistanceToHighestActualBaseline(baseline);
   }
 
+  @override
   void performLayout() {
     bool hasNonPositionedChildren = false;
 
     double width = 0.0;
     double height = 0.0;
 
     RenderBox child = firstChild;
     while (child != null) {
       assert(child.parentData is StackParentData);
       final StackParentData parentData = child.parentData;
@@ skipping 61 matching lines @@
           y = size.height - childData.bottom - child.size.height;
         assert(y >= 0.0 && y + child.size.height <= size.height);
 
         childData.position = new Point(x, y);
       }
 
       child = childData.nextSibling;
     }
   }
 
+  @override
   void hitTestChildren(HitTestResult result, { Point position }) {
     defaultHitTestChildren(result, position: position);
   }
 
+  @override
   void paint(PaintingCanvas canvas, Offset offset) {
     defaultPaint(canvas, offset);
   }
 }