[NFC] fix clang-tidy warning `prefer-isa-or-dyn-cast-in-conditionals` and `namespace-comment`

clang/lib/Sema/SemaDeclCXX.cpp

InitializingBinding(Sema &S, BindingDecl *BD) : S(S) {
     Ctx.PointOfInstantiation = BD->getLocation();
     Ctx.Entity = BD;
     S.pushCodeSynthesisContext(Ctx);
   }
   ~InitializingBinding() {
     S.popCodeSynthesisContext();
   }
 };
-}
+} // namespace
 
 static bool checkTupleLikeDecomposition(Sema &S,
                                         ArrayRef<BindingDecl *> Bindings,
                                         VarDecl *Src, QualType DecompType,
                                         const llvm::APSInt &TupleSize) {
   if ((int64_t)Bindings.size() != TupleSize) {
     S.Diag(Src->getLocation(), diag::err_decomp_decl_wrong_number_bindings)
         << DecompType << (unsigned)Bindings.size()
public:
   std::unique_ptr<CorrectionCandidateCallback> clone() override {
     return std::make_unique<MemInitializerValidatorCCC>(*this);
   }
 
 private:
   CXXRecordDecl *ClassDecl;
 };
 
-}
+} // namespace
 
 ValueDecl *Sema::tryLookupCtorInitMemberDecl(CXXRecordDecl *ClassDecl,
                                              CXXScopeSpec &SS,
                                              ParsedType TemplateTypeTy,
                                              IdentifierInfo *MemberOrBase) {
   if (SS.getScopeRep() || TemplateTypeTy)
     return nullptr;
   for (auto *D : ClassDecl->lookup(MemberOrBase))
bool isWithinInactiveUnionMember(FieldDecl *Field,
     for (auto *C : Indirect->chain()) {
       FieldDecl *Field = dyn_cast<FieldDecl>(C);
       if (Field && isInactiveUnionMember(Field))
         return true;
     }
     return false;
   }
 };
-}
+} // namespace
 
 /// Determine whether the given type is an incomplete or zero-lenfgth
 /// array type.
 static bool isIncompleteOrZeroLengthArrayType(ASTContext &Context, QualType T) {
   if (T->isIncompleteArrayType())
     return true;
 
   while (const ConstantArrayType *ArrayT = Context.getAsConstantArrayType(T)) {
#define CheckPolymorphic(Type) \
   }
 };
 
 void AbstractUsageInfo::CheckType(const NamedDecl *D, TypeLoc TL,
                                   Sema::AbstractDiagSelID Sel) {
   CheckAbstractUsage(*this, D).Visit(TL, Sel);
 }
 
-}
+} // namespace
 
 /// Check for invalid uses of an abstract type in a function declaration.
 static void CheckAbstractClassUsage(AbstractUsageInfo &Info,
                                     FunctionDecl *FD) {
   // No need to do the check on definitions, which require that
   // the return/param types be complete.
   if (FD->doesThisDeclarationHaveABody())
     return;
ComputingExceptionSpec(Sema &S, FunctionDecl *FD, SourceLocation Loc)
     Ctx.PointOfInstantiation = Loc;
     Ctx.Entity = FD;
     S.pushCodeSynthesisContext(Ctx);
   }
   ~ComputingExceptionSpec() {
     S.popCodeSynthesisContext();
   }
 };
-}
+} // namespace
 
 static Sema::ImplicitExceptionSpecification
 ComputeDefaultedSpecialMemberExceptionSpec(
     Sema &S, SourceLocation Loc, CXXMethodDecl *MD, Sema::CXXSpecialMember CSM,
     Sema::InheritedConstructorInfo *ICI);
 
 static Sema::ImplicitExceptionSpecification
 ComputeDefaultedComparisonExceptionSpec(Sema &S, SourceLocation Loc,
ExprResult buildStaticCastToR(Expr *E) {
     // Don't bother forming a no-op cast in the common case.
     if (E->isPRValue() && S.Context.hasSameType(E->getType(), R))
       return E;
     return S.BuildCXXNamedCast(Loc, tok::kw_static_cast,
                                S.Context.getTrivialTypeSourceInfo(R, Loc), E,
                                SourceRange(Loc, Loc), SourceRange(Loc, Loc));
   }
 };
-}
+} // namespace
 
 /// Perform the unqualified lookups that might be needed to form a defaulted
 /// comparison function for the given operator.
 static void lookupOperatorsForDefaultedComparison(Sema &Self, Scope *S,
                                                   UnresolvedSetImpl &Operators,
                                                   OverloadedOperatorKind Op) {
   auto Lookup = [&](OverloadedOperatorKind OO) {
     Self.LookupOverloadedOperatorName(OO, S, Operators);
bool visit(BasesToVisit Bases) {
     for (auto *F : RD->fields())
       if (!F->isInvalidDecl() && !F->isUnnamedBitfield() &&
           getDerived().visitField(F))
         return true;
 
     return false;
   }
 };
-}
+} // namespace
 
 namespace {
 struct SpecialMemberDeletionInfo
     : SpecialMemberVisitor<SpecialMemberDeletionInfo> {
   bool Diagnose;
 
   SourceLocation Loc;
 
struct SpecialMemberDeletionInfo
   bool shouldDeleteForClassSubobject(CXXRecordDecl *Class, Subobject Subobj,
                                      unsigned Quals);
   bool shouldDeleteForSubobjectCall(Subobject Subobj,
                                     Sema::SpecialMemberOverloadResult SMOR,
                                     bool IsDtorCallInCtor);
 
   bool isAccessible(Subobject Subobj, CXXMethodDecl *D);
 };
-}
+} // namespace
 
 /// Is the given special member inaccessible when used on the given
 /// sub-object.
 bool SpecialMemberDeletionInfo::isAccessible(Subobject Subobj,
                                              CXXMethodDecl *target) {
   /// If we're operating on a base class, the object type is the
   /// type of this special member.
   QualType objectTy;
void check(SourceLocation SpecLoc, const char *Spec) {
     if (!Specifiers.empty()) Specifiers += " ";
     Specifiers += Spec;
   }
 
   Sema &S;
   Sema::SemaDiagnosticBuilder Diagnostic;
   std::string Specifiers;
 };
-}
+} // namespace
 
 /// Check the validity of a declarator that we parsed for a deduction-guide.
 /// These aren't actually declarators in the grammar, so we need to check that
 /// the user didn't specify any pieces that are not part of the deduction-guide
 /// grammar.
 void Sema::CheckDeductionGuideDeclarator(Declarator &D, QualType &R,
                                          StorageClass &SC) {
   TemplateName GuidedTemplate = D.getName().TemplateName.get().get();
if (auto RetTST =
       bool SimplyWritten = TKind == TemplateName::Template ||
                            TKind == TemplateName::UsingTemplate;
       if (SimplyWritten && TemplateMatches)
         AcceptableReturnType = true;
       else {
         // This could still instantiate to the right type, unless we know it
         // names the wrong class template.
         auto *TD = SpecifiedName.getAsTemplateDecl();
-        MightInstantiateToSpecialization = !(TD && isa<ClassTemplateDecl>(TD) &&
+        MightInstantiateToSpecialization = !(isa_and_nonnull<ClassTemplateDecl>(TD) &&
                                              !TemplateMatches);
       }
     } else if (!RetTy.hasQualifiers() && RetTy->isDependentType()) {
       MightInstantiateToSpecialization = true;
     }
 
     if (!AcceptableReturnType) {
       Diag(TSI->getTypeLoc().getBeginLoc(),
bool ValidateCandidate(const TypoCorrection &candidate) override {
     return false;
   }
 
   std::unique_ptr<CorrectionCandidateCallback> clone() override {
     return std::make_unique<NamespaceValidatorCCC>(*this);
   }
 };
 
-}
+} // namespace
 
 static bool TryNamespaceTypoCorrection(Sema &S, LookupResult &R, Scope *Sc,
                                        CXXScopeSpec &SS,
                                        SourceLocation IdentLoc,
                                        IdentifierInfo *Ident) {
   R.clear();
   NamespaceValidatorCCC CCC{};
   if (TypoCorrection Corrected =
if (isa<UsingShadowDecl>(Target)) {
     assert(!isa<UsingShadowDecl>(Target) && "nested shadow declaration");
   }
 
   NamedDecl *NonTemplateTarget = Target;
   if (auto *TargetTD = dyn_cast<TemplateDecl>(Target))
     NonTemplateTarget = TargetTD->getTemplatedDecl();
 
   UsingShadowDecl *Shadow;
-  if (NonTemplateTarget && isa<CXXConstructorDecl>(NonTemplateTarget)) {
+  if (isa_and_nonnull<CXXConstructorDecl>(NonTemplateTarget)) {
     UsingDecl *Using = cast<UsingDecl>(BUD);
     bool IsVirtualBase =
         isVirtualDirectBase(cast<CXXRecordDecl>(CurContext),
                             Using->getQualifier()->getAsRecordDecl());
     Shadow = ConstructorUsingShadowDecl::Create(
         Context, CurContext, Using->getLocation(), Using, Orig, IsVirtualBase);
   } else {
     Shadow = UsingShadowDecl::Create(Context, CurContext, BUD->getLocation(),
struct SpecialMemberExceptionSpecInfo
   bool visitField(FieldDecl *FD);
 
   void visitClassSubobject(CXXRecordDecl *Class, Subobject Subobj,
                            unsigned Quals);
 
   void visitSubobjectCall(Subobject Subobj,
                           Sema::SpecialMemberOverloadResult SMOR);
 };
-}
+} // namespace
 
 bool SpecialMemberExceptionSpecInfo::visitBase(CXXBaseSpecifier *Base) {
   auto *RT = Base->getType()->getAs<RecordType>();
   if (!RT)
     return false;
 
   auto *BaseClass = cast<CXXRecordDecl>(RT->getDecl());
   Sema::SpecialMemberOverloadResult SMOR = lookupInheritedCtor(BaseClass);
~DeclaringSpecialMember() {
     }
   }
 
   /// Are we already trying to declare this special member?
   bool isAlreadyBeingDeclared() const {
     return WasAlreadyBeingDeclared;
   }
 };
-}
+} // namespace
 
 void Sema::CheckImplicitSpecialMemberDeclaration(Scope *S, FunctionDecl *FD) {
   // Look up any existing declarations, but don't trigger declaration of all
   // implicit special members with this name.
   DeclarationName Name = FD->getDeclName();
   LookupResult R(*this, Name, SourceLocation(), LookupOrdinaryName,
                  ForExternalRedeclaration);
   for (auto *D : FD->getParent()->lookup(Name))
if (!Failed && !Cond && !InTemplateDefinition) {
         else
           MsgStr->printPretty(Msg, nullptr, getPrintingPolicy());
       }
 
       Expr *InnerCond = nullptr;
       std::string InnerCondDescription;
       std::tie(InnerCond, InnerCondDescription) =
         findFailedBooleanCondition(Converted.get());
-      if (InnerCond && isa<ConceptSpecializationExpr>(InnerCond)) {
+      if (isa_and_nonnull<ConceptSpecializationExpr>(InnerCond)) {
         // Drill down into concept specialization expressions to see why they
         // weren't satisfied.
         Diag(AssertExpr->getBeginLoc(), diag::err_static_assert_failed)
             << !AssertMessage << Msg.str() << AssertExpr->getSourceRange();
         ConstraintSatisfaction Satisfaction;
         if (!CheckConstraintSatisfaction(InnerCond, Satisfaction))
           DiagnoseUnsatisfiedConstraint(Satisfaction);
       } else if (InnerCond && !isa<CXXBoolLiteralExpr>(InnerCond)
public:
     explicit FindCXXThisExpr(Sema &S) : S(S) { }
 
     bool VisitCXXThisExpr(CXXThisExpr *E) {
       S.Diag(E->getLocation(), diag::err_this_static_member_func)
         << E->isImplicit();
       return false;
     }
   };
-}
+} // namespace
 
 bool Sema::checkThisInStaticMemberFunctionType(CXXMethodDecl *Method) {
   TypeSourceInfo *TSInfo = Method->getTypeSourceInfo();
   if (!TSInfo)
     return false;
 
   TypeLoc TL = TSInfo->getTypeLoc();
   FunctionProtoTypeLoc ProtoTL = TL.getAs<FunctionProtoTypeLoc>();