[clang] NFC: Fix trivial typo in comments and document

[kiszk]

Summary

the the -> the

[xgupta]

LGTM, Thank you!

[kiszk]

Thank you very much at https://github.com/llvm/llvm-project/commit/8f77dc459e31aad6daab89a124fa92067916274c

[jansvoboda11]

clang/lib/Lex/PPDirectives.cpp

127

This commit actually created new typo.

clang/docs/LibASTMatchersReference.html

 
 Stmt has pointer identity in the AST.
 </pre></td></tr>
 
 
 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('isExpandedFromMacro0')"><a name="isExpandedFromMacro0Anchor">isExpandedFromMacro</a></td><td>llvm::StringRef MacroName</td></tr>
 <tr><td colspan="4" class="doc" id="isExpandedFromMacro0"><pre>Matches statements that are (transitively) expanded from the named macro.
 Does not match if only part of the statement is expanded from that macro or
-if different parts of the the statement are expanded from different
+if different parts of the statement are expanded from different
 appearances of the macro.
 
 FIXME: Change to be a polymorphic matcher that works on any syntactic
 node. There's nothing `Stmt`-specific about it.
 </pre></td></tr>
 
 
 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('isExpansionInFileMatching1')"><a name="isExpansionInFileMatching1Anchor">isExpansionInFileMatching</a></td><td>std::string RegExp</td></tr>

clang/include/clang/AST/ASTStructuralEquivalence.h

struct StructuralEquivalenceContext {
   /// empty option if the context is not a record, i.e.. if the anonymous
   /// struct/union is at namespace or block scope.
   ///
   /// FIXME: This is needed by ASTImporter and ASTStructureEquivalence. It
   /// probably makes more sense in some other common place then here.
   static llvm::Optional<unsigned>
   findUntaggedStructOrUnionIndex(RecordDecl *Anon);
 
-  // If ErrorOnTagTypeMismatch is set, return the the error, otherwise get the
+  // If ErrorOnTagTypeMismatch is set, return the error, otherwise get the
   // relevant warning for the input error diagnostic.
   unsigned getApplicableDiagnostic(unsigned ErrorDiagnostic);
 
 private:
   /// Finish checking all of the structural equivalences.
   ///
   /// \returns true if the equivalence check failed (non-equivalence detected),
   /// false if equivalence was detected.

clang/include/clang/AST/ComparisonCategories.h

public:
   }
 
   /// True iff the comparison is not totally ordered.
   bool isPartial() const {
     using CCK = ComparisonCategoryType;
     return Kind == CCK::PartialOrdering;
   }
 
-  /// Converts the specified result kind into the the correct result kind
+  /// Converts the specified result kind into the correct result kind
   /// for this category. Specifically it lowers strong equality results to
   /// weak equivalence if needed.
   ComparisonCategoryResult makeWeakResult(ComparisonCategoryResult Res) const {
     using CCR = ComparisonCategoryResult;
     if (!isStrong() && Res == CCR::Equal)
       return CCR::Equivalent;
     return Res;
   }

clang/include/clang/AST/OpenMPClause.h

class OMPUpdateClause final
 
   /// Define the sizes of each trailing object array except the last one. This
   /// is required for TrailingObjects to work properly.
   size_t numTrailingObjects(OverloadToken<SourceLocation>) const {
     // 2 locations: for '(' and argument location.
     return IsExtended ? 2 : 0;
   }
 
-  /// Sets the the location of '(' in clause for 'depobj' directive.
+  /// Sets the location of '(' in clause for 'depobj' directive.
   void setLParenLoc(SourceLocation Loc) {
     assert(IsExtended && "Expected extended clause.");
     *getTrailingObjects<SourceLocation>() = Loc;
   }
 
-  /// Sets the the location of '(' in clause for 'depobj' directive.
+  /// Sets the location of '(' in clause for 'depobj' directive.
   void setArgumentLoc(SourceLocation Loc) {
     assert(IsExtended && "Expected extended clause.");
     *std::next(getTrailingObjects<SourceLocation>(), 1) = Loc;
   }
 
   /// Sets the dependence kind for the clause for 'depobj' directive.
   void setDependencyKind(OpenMPDependClauseKind DK) {
     assert(IsExtended && "Expected extended clause.");
public:
 
   child_range used_children() {
     return child_range(child_iterator(), child_iterator());
   }
   const_child_range used_children() const {
     return const_child_range(const_child_iterator(), const_child_iterator());
   }
 
-  /// Gets the the location of '(' in clause for 'depobj' directive.
+  /// Gets the location of '(' in clause for 'depobj' directive.
   SourceLocation getLParenLoc() const {
     assert(IsExtended && "Expected extended clause.");
     return *getTrailingObjects<SourceLocation>();
   }
 
-  /// Gets the the location of argument in clause for 'depobj' directive.
+  /// Gets the location of argument in clause for 'depobj' directive.
   SourceLocation getArgumentLoc() const {
     assert(IsExtended && "Expected extended clause.");
     return *std::next(getTrailingObjects<SourceLocation>(), 1);
   }
 
   /// Gets the dependence kind in clause for 'depobj' directive.
   OpenMPDependClauseKind getDependencyKind() const {
     assert(IsExtended && "Expected extended clause.");

clang/include/clang/ASTMatchers/ASTMatchers.h

AST_POLYMORPHIC_MATCHER_P(isExpansionInFileMatching,
 
   auto Filename = FileEntry->getName();
   llvm::Regex RE(RegExp);
   return RE.match(Filename);
 }
 
 /// Matches statements that are (transitively) expanded from the named macro.
 /// Does not match if only part of the statement is expanded from that macro or
-/// if different parts of the the statement are expanded from different
+/// if different parts of the statement are expanded from different
 /// appearances of the macro.
 ///
 /// FIXME: Change to be a polymorphic matcher that works on any syntactic
 /// node. There's nothing `Stmt`-specific about it.
 AST_MATCHER_P(Stmt, isExpandedFromMacro, llvm::StringRef, MacroName) {
   // Verifies that the statement' beginning and ending are both expanded from
   // the same instance of the given macro.
   auto& Context = Finder->getASTContext();

clang/include/clang/DirectoryWatcher/DirectoryWatcher.h

 #include <functional>
 #include <memory>
 #include <string>
 
 namespace clang {
 /// Provides notifications for file changes in a directory.
 ///
 /// Invokes client-provided function on every filesystem event in the watched
-/// directory. Initially the the watched directory is scanned and for every file
+/// directory. Initially the watched directory is scanned and for every file
 /// found, an event is synthesized as if the file was added.
 ///
 /// This is not a general purpose directory monitoring tool - list of
 /// limitations follows.
 ///
 /// Only flat directories with no subdirectories are supported. In case
 /// subdirectories are present the behavior is unspecified - events *might* be
 /// passed to Receiver on macOS (due to FSEvents being used) while they

clang/include/clang/Tooling/Transformer/RangeSelector.h

 RangeSelector range(RangeSelector Begin, RangeSelector End);
 
 /// Convenience version of \c range where end-points are bound nodes.
 RangeSelector range(std::string BeginID, std::string EndID);
 
 /// Selects the (empty) range [B,B) when \p Selector selects the range [B,E).
 RangeSelector before(RangeSelector Selector);
 
-/// Selects the the point immediately following \p Selector. That is, the
+/// Selects the point immediately following \p Selector. That is, the
 /// (empty) range [E,E), when \p Selector selects either
 /// * the CharRange [B,E) or
 /// * the TokenRange [B,E'] where the token at E' spans the range [E,E').
 RangeSelector after(RangeSelector Selector);
 
 /// Selects a node, including trailing semicolon (for non-expression
 /// statements). \p ID is the node's binding in the match result.
 RangeSelector node(std::string ID);

clang/lib/CodeGen/CGExprScalar.cpp

if (isa<llvm::Constant>(GEPVal)) {
     Value *GEPVal_int =
         Builder.CreatePtrToInt(GEPVal, DL.getIntPtrType(GEPVal->getType()));
     TotalOffset = Builder.CreateSub(GEPVal_int, BasePtr_int);
     return {TotalOffset, /*OffsetOverflows=*/Builder.getFalse()};
   }
 
   auto *GEP = cast<llvm::GEPOperator>(GEPVal);
   assert(GEP->getPointerOperand() == BasePtr &&
-         "BasePtr must be the the base of the GEP.");
+         "BasePtr must be the base of the GEP.");
   assert(GEP->isInBounds() && "Expected inbounds GEP");
 
   auto *IntPtrTy = DL.getIntPtrType(GEP->getPointerOperandType());
 
   // Grab references to the signed add/mul overflow intrinsics for intptr_t.
   auto *Zero = llvm::ConstantInt::getNullValue(IntPtrTy);
   auto *SAddIntrinsic =
       CGM.getIntrinsic(llvm::Intrinsic::sadd_with_overflow, IntPtrTy);

clang/lib/Lex/PPDirectives.cpp

static bool isReservedId(StringRef Text, const LangOptions &Lang) {
   }
   return false;
 }
 
 // The -fmodule-name option tells the compiler to textually include headers in
 // the specified module, meaning clang won't build the specified module. This is
 // useful in a number of situations, for instance, when building a library that
 // vends a module map, one might want to avoid hitting intermediate build
-// products containimg the the module map or avoid finding the system installed
+// products containimg the module map or avoid finding the system installed
 // modulemap for that library.
 static bool isForModuleBuilding(Module *M, StringRef CurrentModule,
                                 StringRef ModuleName) {
   StringRef TopLevelName = M->getTopLevelModuleName();
 
   // When building framework Foo, we wanna make sure that Foo *and* Foo_Private
   // are textually included and no modules are built for both.
   if (M->getTopLevelModule()->IsFramework && CurrentModule == ModuleName &&

clang/lib/Sema/SemaAvailability.cpp

 }
 
 /// The diagnostic we should emit for \c D, and the declaration that
 /// originated it, or \c AR_Available.
 ///
 /// \param D The declaration to check.
 /// \param Message If non-null, this will be populated with the message from
 /// the availability attribute that is selected.
-/// \param ClassReceiver If we're checking the the method of a class message
+/// \param ClassReceiver If we're checking the method of a class message
 /// send, the class. Otherwise nullptr.
 static std::pair<AvailabilityResult, const NamedDecl *>
 ShouldDiagnoseAvailabilityOfDecl(Sema &S, const NamedDecl *D,
                                  std::string *Message,
                                  ObjCInterfaceDecl *ClassReceiver) {
   AvailabilityResult Result = D->getAvailability(Message);
 
   // For typedefs, if the typedef declaration appears available look