Move Rectangle and Point into dart:math.

tools/dom/templates/html/impl/impl_ClientRect.darttemplate

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of $LIBRARYNAME;
 
 @DocsEditable()
-$(ANNOTATIONS)$(CLASS_MODIFIERS)class $CLASSNAME$EXTENDS implements Rect$IMPLEMENTS$NATIVESPEC {
+$(ANNOTATIONS)$(CLASS_MODIFIERS)class $CLASSNAME$EXTENDS implements Rectangle$IMPLEMENTS$NATIVESPEC {
 
-  // NOTE! All code below should be common with Rect.
-  // TODO(blois): implement with mixins when available.
-
-  String toString() {
-    return '($left, $top, $width, $height)';
+  // NOTE! All code below should be common with RectangleBase.
+   String toString() {
+    return 'Rectangle ($left, $top) $width x $height';
   }
 
   bool operator ==(other) {
-    if (other is !Rect) return false;
+    if (other is !Rectangle) return false;
     return left == other.left && top == other.top && width == other.width &&
         height == other.height;
   }
 
-  int get hashCode => JenkinsSmiHash.hash4(left.hashCode, top.hashCode,
+  int get hashCode => _JenkinsSmiHash.hash4(left.hashCode, top.hashCode,
       width.hashCode, height.hashCode);
 
   /**
-   * Computes the intersection of this rectangle and the rectangle parameter.
-   * Returns null if there is no intersection.
+   * Computes the intersection of `this` and [other].
+   *
+   * The intersection of two axis-aligned rectangles, if any, is always another
+   * axis-aligned rectangle.
+   *
+   * Returns the intersection of this and `other`, or `null` if they don't
+   * intersect.
    */
-  Rect intersection(Rect rect) {
-    var x0 = max(left, rect.left);
-    var x1 = min(left + width, rect.left + rect.width);
+  Rectangle intersection(Rectangle other) {
+    var x0 = max(left, other.left);
+    var x1 = min(left + width, other.left + other.width);
 
     if (x0 <= x1) {
-      var y0 = max(top, rect.top);
-      var y1 = min(top + height, rect.top + rect.height);
+      var y0 = max(top, other.top);
+      var y1 = min(top + height, other.top + other.height);
 
       if (y0 <= y1) {
-        return new Rect(x0, y0, x1 - x0, y1 - y0);
+        return new Rectangle(x0, y0, x1 - x0, y1 - y0);
       }
     }
     return null;
   }
 
 
   /**
-   * Returns whether a rectangle intersects this rectangle.
+   * Returns true if `this` intersects [other].
    */
-  bool intersects(Rect other) {
-    return (left <= other.left + other.width && other.left <= left + width &&
-        top <= other.top + other.height && other.top <= top + height);
+  bool intersects(Rectangle<num> other) {
+    return (left <= other.left + other.width &&
+        other.left <= left + width &&
+        top <= other.top + other.height &&
+        other.top <= top + height);
   }
 
   /**
-   * Returns a new rectangle which completely contains this rectangle and the
-   * input rectangle.
+   * Returns a new rectangle which completely contains `this` and [other].
    */
-  Rect union(Rect rect) {
-    var right = max(this.left + this.width, rect.left + rect.width);
-    var bottom = max(this.top + this.height, rect.top + rect.height);
+  Rectangle boundingBox(Rectangle other) {
+    var right = max(this.left + this.width, other.left + other.width);
+    var bottom = max(this.top + this.height, other.top + other.height);
 
-    var left = min(this.left, rect.left);
-    var top = min(this.top, rect.top);
+    var left = min(this.left, other.left);
+    var top = min(this.top, other.top);
 
-    return new Rect(left, top, right - left, bottom - top);
+    return new Rectangle(left, top, right - left, bottom - top);
   }
 
   /**
-   * Tests whether this rectangle entirely contains another rectangle.
+   * Tests whether `this` entirely contains [another].
    */
-  bool containsRect(Rect another) {
+  bool contains(Rectangle<num> another) {
     return left <= another.left &&
            left + width >= another.left + another.width &&
            top <= another.top &&
            top + height >= another.top + another.height;
   }
 
   /**
-   * Tests whether this rectangle entirely contains a point.
+   * Tests whether [another] is inside or along the edges of `this`.
    */
-  bool containsPoint(Point another) {
+  bool containsPoint(Point<num> another) {
     return another.x >= left &&
            another.x <= left + width &&
            another.y >= top &&
            another.y <= top + height;
   }
 
-  Rect ceil() => new Rect(left.ceil(), top.ceil(), width.ceil(), height.ceil());
-  Rect floor() => new Rect(left.floor(), top.floor(), width.floor(),
-      height.floor());
-  Rect round() => new Rect(left.round(), top.round(), width.round(),
-      height.round());
-
-  /**
-   * Truncates coordinates to integers and returns the result as a new
-   * rectangle.
-   */
-  Rect toInt() => new Rect(left.toInt(), top.toInt(), width.toInt(),
-      height.toInt());
-
   Point get topLeft => new Point(this.left, this.top);
+  Point get topRight => new Point(this.left + this.width, this.top);
   Point get bottomRight => new Point(this.left + this.width,
       this.top + this.height);
-$!MEMBERS}
+  Point get bottomLeft => new Point(this.left,
+      this.top + this.height);
+
+  $!MEMBERS}
+
+/**
+ * This is the [Jenkins hash function][1] but using masking to keep
+ * values in SMI range.
+ *
+ * [1]: http://en.wikipedia.org/wiki/Jenkins_hash_function
+ *
+ * Use:
+ * Hash each value with the hash of the previous value, then get the final
+ * hash by calling finish.
+ *
+ *     var hash = 0;
+ *     for (var value in values) {
+ *       hash = JenkinsSmiHash.combine(hash, value.hashCode);
+ *     }
+ *     hash = JenkinsSmiHash.finish(hash);
+ */
+class _JenkinsSmiHash {
+  // TODO(11617): This class should be optimized and standardized elsewhere.
+
+  static int combine(int hash, int value) {
+    hash = 0x1fffffff & (hash + value);
+    hash = 0x1fffffff & (hash + ((0x0007ffff & hash) << 10));
+    return hash ^ (hash >> 6);
+  }
+
+  static int finish(int hash) {
+    hash = 0x1fffffff & (hash + ((0x03ffffff & hash) <<  3));
+    hash = hash ^ (hash >> 11);
+    return 0x1fffffff & (hash + ((0x00003fff & hash) << 15));
+  }
+
+  static int hash2(a, b) => finish(combine(combine(0, a), b));
+
+  static int hash4(a, b, c, d) =>
+      finish(combine(combine(combine(combine(0, a), b), c), d));
+}