Add missing doc comments to Timestamp and GeoPoint to appease linter (#3474)

Author: var-const

Firestore/core/include/firebase/firestore/geo_point.h

@@ -32,28 +32,35 @@ namespace firestore {
  */
 class GeoPoint {
  public:
-  /**
-   * Creates a `GeoPoint` with both latitude and longitude being 0.
-   */
-  GeoPoint();
+  /** Creates a `GeoPoint` with both latitude and longitude set to 0. */
+  GeoPoint() = default;
 
   /**
-   * Creates a `GeoPoint` from the provided latitude and longitude degrees.
+   * Creates a `GeoPoint` from the provided latitude and longitude values.
    *
-   * @param latitude The latitude as number between -90 and 90.
-   * @param longitude The longitude as number between -180 and 180.
+   * @param latitude The latitude as number of degrees between -90 and 90.
+   * @param longitude The longitude as number of degrees between -180 and 180.
    */
   GeoPoint(double latitude, double longitude);
 
+  /** Copy constructor, `GeoPoint` is trivially copyable. */
   GeoPoint(const GeoPoint& other) = default;
+
+  /** Move constructor, equivalent to copying. */
   GeoPoint(GeoPoint&& other) = default;
+
+  /** Copy assignment operator, `GeoPoint` is trivially copyable. */
   GeoPoint& operator=(const GeoPoint& other) = default;
+
+  /** Move assignment operator, equivalent to copying. */
   GeoPoint& operator=(GeoPoint&& other) = default;
 
+  /** Returns the latitude value of this `GeoPoint`. */
   double latitude() const {
     return latitude_;
   }
 
+  /** Returns the latitude value of this `GeoPoint`. */
   double longitude() const {
     return longitude_;
   }
@@ -62,36 +69,47 @@ class GeoPoint {
    * Returns a string representation of this `GeoPoint` for logging/debugging
    * purposes.
    *
-   * Note: the exact string representation is unspecified and subject to change;
-   * don't rely on the format of the string.
+   * @note: the exact string representation is unspecified and subject to
+   * change; don't rely on the format of the string.
    */
   std::string ToString() const;
+
+  /**
+   * Outputs the string representation of this `GeoPoint` to the given stream.
+   *
+   * @see `ToString()` for comments on the representation format.
+   */
   friend std::ostream& operator<<(std::ostream& out, const GeoPoint& geo_point);
 
  private:
-  double latitude_;
-  double longitude_;
+  double latitude_ = 0.0;
+  double longitude_ = 0.0;
 };
 
-/** Compares against another GeoPoint. */
+/** Checks whether `lhs` and `rhs` are in ascending order. */
 bool operator<(const GeoPoint& lhs, const GeoPoint& rhs);
 
+/** Checks whether `lhs` and `rhs` are in descending order. */
 inline bool operator>(const GeoPoint& lhs, const GeoPoint& rhs) {
   return rhs < lhs;
 }
 
+/** Checks whether `lhs` and `rhs` are in non-ascending order. */
 inline bool operator>=(const GeoPoint& lhs, const GeoPoint& rhs) {
   return !(lhs < rhs);
 }
 
+/** Checks whether `lhs` and `rhs` are in non-descending order. */
 inline bool operator<=(const GeoPoint& lhs, const GeoPoint& rhs) {
   return !(lhs > rhs);
 }
 
+/** Checks `lhs` and `rhs` for inequality. */
 inline bool operator!=(const GeoPoint& lhs, const GeoPoint& rhs) {
   return lhs < rhs || lhs > rhs;
 }
 
+/** Checks `lhs` and `rhs` for equality. */
 inline bool operator==(const GeoPoint& lhs, const GeoPoint& rhs) {
   return !(lhs != rhs);
 }

Firestore/core/include/firebase/firestore/timestamp.h

@@ -63,6 +63,18 @@ class Timestamp {
    */
   Timestamp(int64_t seconds, int32_t nanoseconds);
 
+  /** Copy constructor, `Timestamp` is trivially copyable. */
+  Timestamp(const Timestamp& other) = default;
+
+  /** Move constructor, equivalent to copying. */
+  Timestamp(Timestamp&& other) = default;
+
+  /** Copy assignment operator, `Timestamp` is trivially copyable. */
+  Timestamp& operator=(const Timestamp& other) = default;
+
+  /** Move assignment operator, equivalent to copying. */
+  Timestamp& operator=(Timestamp&& other) = default;
+
   /**
    * Creates a new timestamp with the current date.
    *
@@ -145,10 +157,16 @@ class Timestamp {
    * Returns a string representation of this `Timestamp` for logging/debugging
    * purposes.
    *
-   * Note: the exact string representation is unspecified and subject to change;
-   * don't rely on the format of the string.
+   * @note: the exact string representation is unspecified and subject to
+   * change; don't rely on the format of the string.
    */
   std::string ToString() const;
+
+  /**
+   * Outputs the string representation of this `Timestamp` to the given stream.
+   *
+   * @see `ToString()` for comments on the representation format.
+   */
   friend std::ostream& operator<<(std::ostream& out,
                                   const Timestamp& timestamp);
 
@@ -161,28 +179,34 @@ class Timestamp {
   int32_t nanoseconds_ = 0;
 };
 
+/** Checks whether `lhs` and `rhs` are in ascending order. */
 inline bool operator<(const Timestamp& lhs, const Timestamp& rhs) {
   return lhs.seconds() < rhs.seconds() ||
          (lhs.seconds() == rhs.seconds() &&
           lhs.nanoseconds() < rhs.nanoseconds());
 }
 
+/** Checks whether `lhs` and `rhs` are in descending order. */
 inline bool operator>(const Timestamp& lhs, const Timestamp& rhs) {
   return rhs < lhs;
 }
 
+/** Checks whether `lhs` and `rhs` are in non-ascending order. */
 inline bool operator>=(const Timestamp& lhs, const Timestamp& rhs) {
   return !(lhs < rhs);
 }
 
+/** Checks whether `lhs` and `rhs` are in non-descending order. */
 inline bool operator<=(const Timestamp& lhs, const Timestamp& rhs) {
   return !(lhs > rhs);
 }
 
+/** Checks `lhs` and `rhs` for inequality. */
 inline bool operator!=(const Timestamp& lhs, const Timestamp& rhs) {
   return lhs < rhs || lhs > rhs;
 }
 
+/** Checks `lhs` and `rhs` for equality. */
 inline bool operator==(const Timestamp& lhs, const Timestamp& rhs) {
   return !(lhs != rhs);
 }
@@ -213,10 +237,15 @@ std::chrono::time_point<Clock, Duration> Timestamp::ToTimePoint() const {
 }  // namespace firebase
 
 namespace std {
+/** Convenience-only specialization of `std::hash`. */
 template <>
 struct hash<firebase::Timestamp> {
-  // Note: specialization of `std::hash` is provided for convenience only. The
-  // implementation is subject to change.
+  /**
+   * Hashes the given `timestamp`.
+   *
+   * @note: specialization of `std::hash` is provided for convenience only. The
+   * implementation is subject to change.
+   */
   size_t operator()(const firebase::Timestamp& timestamp) const;
 };
 }  // namespace std

Firestore/core/src/firebase/firestore/geo_point.cc

@@ -25,9 +25,6 @@
 namespace firebase {
 namespace firestore {
 
-GeoPoint::GeoPoint() : GeoPoint(0, 0) {
-}
-
 GeoPoint::GeoPoint(double latitude, double longitude)
     : latitude_(latitude), longitude_(longitude) {
   HARD_ASSERT(!std::isnan(latitude) && -90 <= latitude && latitude <= 90,