   func intersects(rect: CGRect) -> Bool {
     return CGRectIntersectsRect(self, rect)
   }
+
+  @available(*, unavailable, renamed="zero")
+  static var zeroRect: CGRect = unavailableValue()
+
+  @available(*, unavailable, renamed="infinite")
+  static var infiniteRect: CGRect = unavailableValue()
+
+  @available(*, unavailable, renamed="null")
+  static var nullRect: CGRect = unavailableValue()
+
+  @available(*, unavailable, renamed="standardized")
+  var standardizedRect: CGRect {
+    fatalError("can't retrieve unavailable property")
+  }
+
+  @available(*, unavailable, renamed="integral")
+  var integralRect: CGRect {
+    fatalError("can't retrieve unavailable property")
+  }
+
+  @available(*, unavailable, renamed="standardizeInPlace")
+  mutating func standardize() -> CGRect {
+    fatalError("can't call unavailable function")
+  }
+
+  @available(*, unavailable, renamed="makeIntegralInPlace")
+  mutating func integerize() {
+    fatalError("can't call unavailable function")
+  }
+
+  @available(*, unavailable, renamed="insetBy")
+  func rectByInsetting(dx dx: CGFloat, dy: CGFloat) -> CGRect {
+    fatalError("can't call unavailable function")
+  }
+
+  @available(*, unavailable, renamed="insetInPlace")
+  func inset(dx dx: CGFloat, dy: CGFloat) {
+    fatalError("can't call unavailable function")
+  }
+
+  @available(*, unavailable, renamed="offsetBy")
+  func rectByOffsetting(dx dx: CGFloat, dy: CGFloat) -> CGRect {
+    fatalError("can't call unavailable function")
+  }
+
+  @available(*, unavailable, renamed="offsetInPlace")
+  func offset(dx dx: CGFloat, dy: CGFloat) {
+    fatalError("can't call unavailable function")
+  }
+
+  @available(*, unavailable, renamed="unionInPlace")
+  mutating func union(withRect: CGRect) {
+    fatalError("can't call unavailable function")
+  }
+
+  @available(*, unavailable, renamed="union")
+  func rectByUnion(withRect: CGRect) -> CGRect {
+    fatalError("can't call unavailable function")
+  }
+
+  @available(*, unavailable, renamed="intersectInPlace")
+  mutating func intersect(withRect: CGRect) {
+    fatalError("can't call unavailable function")
+  }
+
+  @available(*, unavailable, renamed="intersect")
+  func rectByIntersecting(withRect: CGRect) -> CGRect {
+    fatalError("can't call unavailable function")
+  }
+
+  @available(*, unavailable, renamed="divide")
+  func rectsByDividing(atDistance: CGFloat, fromEdge: CGRectEdge)
+    -> (slice: CGRect, remainder: CGRect) {
+    fatalError("can't call unavailable function")
+  }
 }
 
 extension CGRect : Equatable {}

  init(x: Double, y: Double) {
    self.init(x: CGFloat(x), y: CGFloat(y))
  }
}

extension CGPoint : Equatable {}

// CGGeometry
//===----------------------------------------------------------------------===//

private func unavailableValue<T>() -> T {
  fatalError("can't retrieve unavailable property")
}

public extension CGPoint {
  static var zero: CGPoint {
    @transparent // @fragile
