Fix spelling mistakes

absl/container/flat_hash_set.h

@@ -343,7 +343,7 @@ class flat_hash_set
   // for the past-the-end iterator, which is invalidated.
   // for the past-the-end iterator, which is invalidated.
   //
   //
   // `swap()` requires that the flat hash set's hashing and key equivalence
   // `swap()` requires that the flat hash set's hashing and key equivalence
-  // functions be Swappable, and are exchaged using unqualified calls to
+  // functions be Swappable, and are exchanged using unqualified calls to
   // non-member `swap()`. If the set's allocator has
   // non-member `swap()`. If the set's allocator has
   // `std::allocator_traits<allocator_type>::propagate_on_container_swap::value`
   // `std::allocator_traits<allocator_type>::propagate_on_container_swap::value`
   // set to `true`, the allocators are also exchanged using an unqualified call
   // set to `true`, the allocators are also exchanged using an unqualified call

absl/container/inlined_vector.h

@@ -816,7 +816,7 @@ class InlinedVector {
 
 
   void MoveAssignment(MemcpyPolicy, InlinedVector&& other) {
   void MoveAssignment(MemcpyPolicy, InlinedVector&& other) {
     // Assumption check: we shouldn't be told to use memcpy to implement move
     // Assumption check: we shouldn't be told to use memcpy to implement move
-    // asignment unless we have trivially destructible elements and an allocator
+    // assignment unless we have trivially destructible elements and an allocator
     // that does nothing fancy.
     // that does nothing fancy.
     static_assert(absl::is_trivially_destructible<value_type>::value, "");
     static_assert(absl::is_trivially_destructible<value_type>::value, "");
     static_assert(std::is_same<A, std::allocator<value_type>>::value, "");
     static_assert(std::is_same<A, std::allocator<value_type>>::value, "");

absl/container/node_hash_map.h

@@ -404,7 +404,7 @@ class node_hash_map
   // for the past-the-end iterator, which is invalidated.
   // for the past-the-end iterator, which is invalidated.
   //
   //
   // `swap()` requires that the node hash map's hashing and key equivalence
   // `swap()` requires that the node hash map's hashing and key equivalence
-  // functions be Swappable, and are exchaged using unqualified calls to
+  // functions be Swappable, and are exchanged using unqualified calls to
   // non-member `swap()`. If the map's allocator has
   // non-member `swap()`. If the map's allocator has
   // `std::allocator_traits<allocator_type>::propagate_on_container_swap::value`
   // `std::allocator_traits<allocator_type>::propagate_on_container_swap::value`
   // set to `true`, the allocators are also exchanged using an unqualified call
   // set to `true`, the allocators are also exchanged using an unqualified call

absl/crc/internal/crc.h

@@ -68,7 +68,7 @@ class CRC {
   // any reduction of error-detection ability in the outer CRC.
   // any reduction of error-detection ability in the outer CRC.
   // Unscramble() performs the inverse transformation.
   // Unscramble() performs the inverse transformation.
   // It is strongly recommended that CRCs be scrambled before storage or
   // It is strongly recommended that CRCs be scrambled before storage or
-  // transmission, and unscrambled at the other end before futher manipulation.
+  // transmission, and unscrambled at the other end before further manipulation.
   virtual void Scramble(uint32_t* crc) const = 0;
   virtual void Scramble(uint32_t* crc) const = 0;
   virtual void Unscramble(uint32_t* crc) const = 0;
   virtual void Unscramble(uint32_t* crc) const = 0;
 
 

absl/crc/internal/crc_cord_state.h

@@ -109,7 +109,7 @@ class CrcCordState {
   // Returns true if the chunked CRC32C cached is normalized.
   // Returns true if the chunked CRC32C cached is normalized.
   bool IsNormalized() const { return rep().removed_prefix.length == 0; }
   bool IsNormalized() const { return rep().removed_prefix.length == 0; }
 
 
-  // Normalizes the chunked CRC32C checksum cache by substracting any removed
+  // Normalizes the chunked CRC32C checksum cache by subtracting any removed
   // prefix from the chunks.
   // prefix from the chunks.
   void Normalize();
   void Normalize();
 
 

absl/crc/internal/crc_internal.h

@@ -60,7 +60,7 @@ constexpr uint64_t kScrambleHi = (static_cast<uint64_t>(0x4f1bbcdcU) << 32) |
 constexpr uint64_t kScrambleLo = (static_cast<uint64_t>(0xf9ce6030U) << 32) |
 constexpr uint64_t kScrambleLo = (static_cast<uint64_t>(0xf9ce6030U) << 32) |
                                  static_cast<uint64_t>(0x2e76e41bU);
                                  static_cast<uint64_t>(0x2e76e41bU);
 
 
-class CRCImpl : public CRC {  // Implemention of the abstract class CRC
+class CRCImpl : public CRC {  // Implementation of the abstract class CRC
  public:
  public:
   using Uint32By256 = uint32_t[256];
   using Uint32By256 = uint32_t[256];
 
 

absl/crc/internal/crc_x86_arm_combined.cc

@@ -515,7 +515,7 @@ class CRC32AcceleratedX86ARMCombinedMultipleStreams
       }
       }
 
 
       for (size_t i = 1; i < bs; i++) {
       for (size_t i = 1; i < bs; i++) {
-        // Prefetch data for next itterations.
+        // Prefetch data for next iterations.
         for (size_t j = 0; j < num_crc_streams; j++) {
         for (size_t j = 0; j < num_crc_streams; j++) {
           PrefetchToLocalCache(
           PrefetchToLocalCache(
               reinterpret_cast<const char*>(crc_streams[j] + kPrefetchHorizon));
               reinterpret_cast<const char*>(crc_streams[j] + kPrefetchHorizon));

absl/flags/commandlineflag.h

@@ -186,7 +186,7 @@ class CommandLineFlag {
   // command line.
   // command line.
   virtual bool IsSpecifiedOnCommandLine() const = 0;
   virtual bool IsSpecifiedOnCommandLine() const = 0;
 
 
-  // Validates supplied value usign validator or parseflag routine
+  // Validates supplied value using validator or parseflag routine
   virtual bool ValidateInputValue(absl::string_view value) const = 0;
   virtual bool ValidateInputValue(absl::string_view value) const = 0;
 
 
   // Checks that flags default value can be converted to string and back to the
   // Checks that flags default value can be converted to string and back to the

absl/flags/internal/flag.cc

@@ -238,7 +238,7 @@ void FlagImpl::StoreValue(const void* src) {
   switch (ValueStorageKind()) {
   switch (ValueStorageKind()) {
     case FlagValueStorageKind::kValueAndInitBit:
     case FlagValueStorageKind::kValueAndInitBit:
     case FlagValueStorageKind::kOneWordAtomic: {
     case FlagValueStorageKind::kOneWordAtomic: {
-      // Load the current value to avoid setting 'init' bit manualy.
+      // Load the current value to avoid setting 'init' bit manually.
       int64_t one_word_val = OneWordValue().load(std::memory_order_acquire);
       int64_t one_word_val = OneWordValue().load(std::memory_order_acquire);
       std::memcpy(&one_word_val, src, Sizeof(op_));
       std::memcpy(&one_word_val, src, Sizeof(op_));
       OneWordValue().store(one_word_val, std::memory_order_release);
       OneWordValue().store(one_word_val, std::memory_order_release);

absl/flags/internal/flag.h

@@ -223,12 +223,12 @@ extern const char kStrippedFlagHelp[];
 // first overload if possible. If help message is evaluatable on constexpr
 // first overload if possible. If help message is evaluatable on constexpr
 // context We'll be able to make FixedCharArray out of it and we'll choose first
 // context We'll be able to make FixedCharArray out of it and we'll choose first
 // overload. In this case the help message expression is immediately evaluated
 // overload. In this case the help message expression is immediately evaluated
-// and is used to construct the absl::Flag. No additionl code is generated by
+// and is used to construct the absl::Flag. No additional code is generated by
 // ABSL_FLAG Otherwise SFINAE kicks in and first overload is dropped from the
 // ABSL_FLAG Otherwise SFINAE kicks in and first overload is dropped from the
 // consideration, in which case the second overload will be used. The second
 // consideration, in which case the second overload will be used. The second
 // overload does not attempt to evaluate the help message expression
 // overload does not attempt to evaluate the help message expression
-// immediately and instead delays the evaluation by returing the function
-// pointer (&T::NonConst) genering the help message when necessary. This is
+// immediately and instead delays the evaluation by returning the function
+// pointer (&T::NonConst) generating the help message when necessary. This is
 // evaluatable in constexpr context, but the cost is an extra function being
 // evaluatable in constexpr context, but the cost is an extra function being
 // generated in the ABSL_FLAG code.
 // generated in the ABSL_FLAG code.
 template <typename Gen, size_t N>
 template <typename Gen, size_t N>

absl/flags/internal/flag_msvc.inc

@@ -29,7 +29,7 @@
 // second level of protection is a global Mutex, so if two threads attempt to
 // second level of protection is a global Mutex, so if two threads attempt to
 // construct the flag concurrently only one wins.
 // construct the flag concurrently only one wins.
 //
 //
-// This solution is based on a recomendation here:
+// This solution is based on a recommendation here:
 // https://developercommunity.visualstudio.com/content/problem/336946/class-with-constexpr-constructor-not-using-static.html?childToView=648454#comment-648454
 // https://developercommunity.visualstudio.com/content/problem/336946/class-with-constexpr-constructor-not-using-static.html?childToView=648454#comment-648454
 
 
 namespace flags_internal {
 namespace flags_internal {

absl/functional/function_ref_test.cc

@@ -257,7 +257,7 @@ TEST(FunctionRef, PassByValueTypes) {
       "Reference types should be preserved");
       "Reference types should be preserved");
 
 
   // Make sure the address of an object received by reference is the same as the
   // Make sure the address of an object received by reference is the same as the
-  // addess of the object passed by the caller.
+  // address of the object passed by the caller.
   {
   {
     LargeTrivial obj;
     LargeTrivial obj;
     auto test = [&obj](LargeTrivial& input) { ASSERT_EQ(&input, &obj); };
     auto test = [&obj](LargeTrivial& input) { ASSERT_EQ(&input, &obj); };

absl/random/internal/uniform_helper.h

@@ -217,7 +217,7 @@ using UniformDistribution =
 // UniformDistributionWrapper is used as the underlying distribution type
 // UniformDistributionWrapper is used as the underlying distribution type
 // by the absl::Uniform template function. It selects the proper Abseil
 // by the absl::Uniform template function. It selects the proper Abseil
 // uniform distribution and provides constructor overloads that match the
 // uniform distribution and provides constructor overloads that match the
-// expected parameter order as well as adjusting distribtuion bounds based
+// expected parameter order as well as adjusting distribution bounds based
 // on the tag.
 // on the tag.
 template <typename NumType>
 template <typename NumType>
 struct UniformDistributionWrapper : public UniformDistribution<NumType> {
 struct UniformDistributionWrapper : public UniformDistribution<NumType> {

absl/strings/internal/stl_type_traits.h

@@ -13,7 +13,7 @@
 // limitations under the License.
 // limitations under the License.
 //
 //
 
 
-// Thie file provides the IsStrictlyBaseOfAndConvertibleToSTLContainer type
+// The file provides the IsStrictlyBaseOfAndConvertibleToSTLContainer type
 // trait metafunction to assist in working with the _GLIBCXX_DEBUG debug
 // trait metafunction to assist in working with the _GLIBCXX_DEBUG debug
 // wrappers of STL containers.
 // wrappers of STL containers.
 //
 //

absl/synchronization/mutex.h

@@ -273,7 +273,7 @@ class ABSL_LOCKABLE Mutex {
   // Aliases for `Mutex::Lock()`, `Mutex::Unlock()`, and `Mutex::TryLock()`.
   // Aliases for `Mutex::Lock()`, `Mutex::Unlock()`, and `Mutex::TryLock()`.
   //
   //
   // These methods may be used (along with the complementary `Reader*()`
   // These methods may be used (along with the complementary `Reader*()`
-  // methods) to distingish simple exclusive `Mutex` usage (`Lock()`,
+  // methods) to distinguish simple exclusive `Mutex` usage (`Lock()`,
   // etc.) from reader/writer lock usage.
   // etc.) from reader/writer lock usage.
   void WriterLock() ABSL_EXCLUSIVE_LOCK_FUNCTION() { this->Lock(); }
   void WriterLock() ABSL_EXCLUSIVE_LOCK_FUNCTION() { this->Lock(); }
 
 

absl/synchronization/mutex_method_pointer_test.cc

@@ -26,8 +26,8 @@ class IncompleteClass;
 
 
 #ifdef _MSC_VER
 #ifdef _MSC_VER
 // These tests verify expectations about sizes of MSVC pointers to methods.
 // These tests verify expectations about sizes of MSVC pointers to methods.
-// Pointers to methods are distinguished by whether their class hierachies
-// contain single inheritance, multiple inheritance, or virtual inheritence.
+// Pointers to methods are distinguished by whether their class hierarchies
+// contain single inheritance, multiple inheritance, or virtual inheritance.
 
 
 // Declare classes of the various MSVC inheritance types.
 // Declare classes of the various MSVC inheritance types.
 class __single_inheritance SingleInheritance{};
 class __single_inheritance SingleInheritance{};

absl/time/civil_time_test.cc

@@ -1228,7 +1228,7 @@ TEST(CivilTime, DocumentationExample) {
   EXPECT_EQ(0, day_floor.hour());  // 09:09:09 is floored
   EXPECT_EQ(0, day_floor.hour());  // 09:09:09 is floored
   EXPECT_EQ(absl::CivilDay(2015, 1, 2), day_floor);
   EXPECT_EQ(absl::CivilDay(2015, 1, 2), day_floor);
 
 
-  // Unspecified fields default to their minium value
+  // Unspecified fields default to their minimum value
   absl::CivilDay day_default(2015);  // Defaults to Jan 1
   absl::CivilDay day_default(2015);  // Defaults to Jan 1
   EXPECT_EQ(absl::CivilDay(2015, 1, 1), day_default);
   EXPECT_EQ(absl::CivilDay(2015, 1, 1), day_default);
 
 

absl/time/time.cc

@@ -137,7 +137,7 @@ inline TimeConversion InfinitePastTimeConversion() {
 }
 }
 
 
 // Makes a Time from sec, overflowing to InfiniteFuture/InfinitePast as
 // Makes a Time from sec, overflowing to InfiniteFuture/InfinitePast as
-// necessary. If sec is min/max, then consult cs+tz to check for overlow.
+// necessary. If sec is min/max, then consult cs+tz to check for overflow.
 Time MakeTimeWithOverflow(const cctz::time_point<cctz::seconds>& sec,
 Time MakeTimeWithOverflow(const cctz::time_point<cctz::seconds>& sec,
                           const cctz::civil_second& cs,
                           const cctz::civil_second& cs,
                           const cctz::time_zone& tz,
                           const cctz::time_zone& tz,