Module:ClangDiags/DiagsLongData8: Difference between revisions

[k]={{F,9609,"/// ActOnConversionDeclarator - Called by ActOnDeclarator to complete\n/// the declaration of the given C++ conversion function. This routine\n/// is responsible for recording the conversion function in the C++\n/// class, if possible.\nDecl *Sema::ActOnConversionDeclarator(CXXConversionDecl *Conversion) {\n  if (Conversion->getTemplateSpecializationKind() != TSK_Undeclared && Conversion->getTemplateSpecializationKind() != TSK_ExplicitSpecialization)\n  else if (Conversion->size_overridden_methods() != 0)\n  else if (ConvType->isRecordType()) {\n  } else if (ConvType->isVoidType()) {\n    Diag(Conversion->getLocation(), diag::warn_conv_to_void_not_used) << ClassType << ConvType;"}}

[k]={{"clang/lib/Sema/SemaCoroutine.cpp",306,"// See if return type is coroutine-handle and if so, invoke builtin coro-resume\n// on its address. This is to enable the support for coroutine-handle\n// returning await_suspend that results in a guaranteed tail call to the target\n// coroutine.\nstatic Expr *maybeTailCall(Sema &S, QualType RetType, Expr *E, SourceLocation Loc) {\n  // Check that the type of AddressExpr is void*\n  if (!JustAddress->getType().getTypePtr()->isVoidPointerType())\n    S.Diag(cast<CallExpr>(JustAddress)->getCalleeDecl()->getLocation(), diag::warn_coroutine_handle_address_invalid_return_type) << JustAddress->getType();"}}

[k]={{"clang/lib/Sema/SemaCoroutine.cpp",1487,"bool CoroutineStmtBuilder::makeOnException() {\n  if (!lookupMember(S, \"unhandled_exception\", PromiseRecordDecl, Loc)) {\n    auto DiagID = RequireUnhandledException ? diag::err_coroutine_promise_unhandled_exception_required : diag::warn_coroutine_promise_unhandled_exception_required_with_exceptions;"}}

[k]={{"clang/lib/AST/CommentLexer.cpp",389,"void Lexer::lexCommentText(Token &T) {\n  case \'@\': {\n    if (!Info) {\n      if ((Info = Traits.getTypoCorrectCommandInfo(CommandName))) {\n        Diag(Loc, diag::warn_correct_comment_command_name) << FullRange << CommandName << CorrectedName << FixItHint::CreateReplacement(CommandRange, CorrectedName);"}}

[k]={{w,11261,"/// Check for dangerous or invalid arguments to memset().\n///\n/// This issues warnings on known problematic, dangerous or unspecified\n/// arguments to the standard \'memset\', \'memcpy\', \'memmove\', and \'memcmp\'\n/// function calls.\n///\n/// \\param Call The call expression to diagnose.\nvoid Sema::CheckMemaccessArguments(const CallExpr *Call, unsigned BId, IdentifierInfo *FnName) {\n  for (unsigned ArgIdx = 0; ArgIdx != LastArg; ++ArgIdx) {\n    if (const CXXRecordDecl *ContainedRD = getContainedDynamicClass(PointeeTy, IsContained)) {\n    } else if (PointeeTy.hasNonTrivialObjCLifetime() && BId != Builtin::BImemset)\n    else if (const auto *RT = PointeeTy->getAs<RecordType>()) {\n      if ((BId == Builtin::BImemset || BId == Builtin::BIbzero) && RT->getDecl()->isNonTrivialToPrimitiveDefaultInitialize()) {\n        DiagRuntimeBehavior(Dest->getExprLoc(), Dest, PDiag(diag::warn_cstruct_memaccess) << ArgIdx << FnName << PointeeTy << 0);"},{w,11264,"/// Check for dangerous or invalid arguments to memset().\n///\n/// This issues warnings on known problematic, dangerous or unspecified\n/// arguments to the standard \'memset\', \'memcpy\', \'memmove\', and \'memcmp\'\n/// function calls.\n///\n/// \\param Call The call expression to diagnose.\nvoid Sema::CheckMemaccessArguments(const CallExpr *Call, unsigned BId, IdentifierInfo *FnName) {\n  for (unsigned ArgIdx = 0; ArgIdx != LastArg; ++ArgIdx) {\n    if (const CXXRecordDecl *ContainedRD = getContainedDynamicClass(PointeeTy, IsContained)) {\n    } else if (PointeeTy.hasNonTrivialObjCLifetime() && BId != Builtin::BImemset)\n    else if (const auto *RT = PointeeTy->getAs<RecordType>()) {\n      if ((BId == Builtin::BImemset || BId == Builtin::BIbzero) && RT->getDecl()->isNonTrivialToPrimitiveDefaultInitialize()) {\n      } else if ((BId == Builtin::BImemcpy || BId == Builtin::BImemmove) && RT->getDecl()->isNonTrivialToPrimitiveCopy()) {\n        DiagRuntimeBehavior(Dest->getExprLoc(), Dest, PDiag(diag::warn_cstruct_memaccess) << ArgIdx << FnName << PointeeTy << 1);"}}

[k]={{"clang/lib/Parse/ParseObjc.cpp",1404,"///  objc-method-decl:\n///    objc-selector\n///    objc-keyword-selector objc-parmlist[opt]\n///    objc-type-name objc-selector\n///    objc-type-name objc-keyword-selector objc-parmlist[opt]\n///\n///  objc-keyword-selector:\n///    objc-keyword-decl\n///    objc-keyword-selector objc-keyword-decl\n///\n///  objc-keyword-decl:\n///    objc-selector \':\' objc-type-name objc-keyword-attributes[opt] identifier\n///    objc-selector \':\' objc-keyword-attributes[opt] identifier\n///    \':\' objc-type-name objc-keyword-attributes[opt] identifier\n///    \':\' objc-keyword-attributes[opt] identifier\n///\n///  objc-parmlist:\n///    objc-parms objc-ellipsis[opt]\n///\n///  objc-parms:\n///    objc-parms , parameter-declaration\n///\n///  objc-ellipsis:\n///    , ...\n///\n///  objc-keyword-attributes:        [OBJC2]\n///    __attribute__((unused))\n///\nDecl *Parser::ParseObjCMethodDecl(SourceLocation mLoc, tok::TokenKind mType, tok::ObjCKeywordKind MethodImplKind, bool MethodDefinition) {\n  // Parse the (optional) parameter list.\n  while (Tok.is(tok::comma)) {\n    if (!cStyleParamWarned) {\n      Diag(Tok, diag::warn_cstyle_param);"}}

[k]={{fb,9219,"QualType Sema::DeduceTemplateSpecializationFromInitializer(TypeSourceInfo *TSInfo, const InitializedEntity &Entity, const InitializationKind &Kind, MultiExprArg Inits, ParenListExpr *PL) {\n  // Warn if CTAD was used on a type that does not have any user-defined\n  // deduction guides.\n  if (!FoundDeductionGuide) {\n    Diag(TSInfo->getTypeLoc().getBeginLoc(), diag::warn_ctad_maybe_unsupported) << TemplateName;"}}

[k]={{G,2054,"void Sema::ActOnPopScope(SourceLocation Loc, Scope *S) {\n  for (auto *TmpD : S->decls()) {\n    if (ShadowI != ShadowingDecls.end()) {\n      if (const auto *FD = dyn_cast<FieldDecl>(ShadowI->second)) {\n        addDiagWithPrev(D->getLocation(), FD->getLocation(), PDiag(diag::warn_ctor_parm_shadows_field) << D << FD << FD->getParent());"}}

[k]={{"clang/lib/CrossTU/CrossTranslationUnit.cpp",319,"void CrossTranslationUnitContext::emitCrossTUDiagnostics(const IndexError &IE) {\n  case index_error_code::triple_mismatch:\n    Context.getDiagnostics().Report(diag::warn_ctu_incompat_triple) << IE.getFileName() << IE.getTripleToName() << IE.getTripleFromName();"}}

[k]={{Rb,1197,"/// ParseLambdaExpressionAfterIntroducer - Parse the rest of a lambda\n/// expression.\nExprResult Parser::ParseLambdaExpressionAfterIntroducer(LambdaIntroducer &Intro) {\n  // Helper to emit a warning if we see a CUDA host/device/global attribute\n  // after \'(...)\'. nvcc doesn\'t accept this.\n  auto WarnIfHasCUDATargetAttr = [&] {\n    if (getLangOpts().CUDA)\n      for (const ParsedAttr &A : Attributes)\n        if (A.getKind() == ParsedAttr::AT_CUDADevice || A.getKind() == ParsedAttr::AT_CUDAHost || A.getKind() == ParsedAttr::AT_CUDAGlobal)\n          Diag(A.getLoc(), diag::warn_cuda_attr_lambda_position) << A.getAttrName()->getName();"}}

[k]={{Wc,1193,"/// ParseNumberStartingWithZero - This method is called when the first character\n/// of the number is found to be a zero.  This means it is either an octal\n/// number (like \'04\') or a hex number (\'0x123a\') a binary number (\'0b1010\') or\n/// a floating point number (01239.123e4).  Eat the prefix, determining the\n/// radix etc.\nvoid NumericLiteralParser::ParseNumberStartingWithZero(SourceLocation TokLoc) {\n  // Handle simple binary numbers 0b01010\n  if ((c1 == \'b\' || c1 == \'B\') && (s[1] == \'0\' || s[1] == \'1\')) {\n    Diags.Report(TokLoc, LangOpts.CPlusPlus14 ? diag::warn_cxx11_compat_binary_literal : LangOpts.CPlusPlus ? diag::ext_binary_literal_cxx14 : diag::ext_binary_literal);"}}

[k]={{F,1949,"/// Check the body for the given constexpr function declaration only contains\n/// the permitted types of statement. C++11 [dcl.constexpr]p3,p4.\n///\n/// \\return true if the body is OK, false if we have found or diagnosed a\n/// problem.\nstatic bool CheckConstexprFunctionBody(Sema &SemaRef, const FunctionDecl *Dcl, Stmt *Body, Sema::CheckConstexprKind Kind) {\n  if (Kind == Sema::CheckConstexprKind::CheckValid) {\n  } else if (Cxx2bLoc.isValid()) {\n  } else if (Cxx2aLoc.isValid()) {\n  } else if (Cxx1yLoc.isValid()) {\n    SemaRef.Diag(Cxx1yLoc, SemaRef.getLangOpts().CPlusPlus14 ? diag::warn_cxx11_compat_constexpr_body_invalid_stmt : diag::ext_constexpr_body_invalid_stmt) << isa<CXXConstructorDecl>(Dcl);"}}

[k]={{F,2028,"/// Check the body for the given constexpr function declaration only contains\n/// the permitted types of statement. C++11 [dcl.constexpr]p3,p4.\n///\n/// \\return true if the body is OK, false if we have found or diagnosed a\n/// problem.\nstatic bool CheckConstexprFunctionBody(Sema &SemaRef, const FunctionDecl *Dcl, Stmt *Body, Sema::CheckConstexprKind Kind) {\n  if (const CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(Dcl)) {\n  } else {\n    if (ReturnStmts.empty()) {\n    } else if (ReturnStmts.size() > 1) {\n      case Sema::CheckConstexprKind::Diagnose:\n        SemaRef.Diag(ReturnStmts.back(), SemaRef.getLangOpts().CPlusPlus14 ? diag::warn_cxx11_compat_constexpr_body_multiple_return : diag::ext_constexpr_body_multiple_return);"}}

[k]={{F,2012,"/// Check the body for the given constexpr function declaration only contains\n/// the permitted types of statement. C++11 [dcl.constexpr]p3,p4.\n///\n/// \\return true if the body is OK, false if we have found or diagnosed a\n/// problem.\nstatic bool CheckConstexprFunctionBody(Sema &SemaRef, const FunctionDecl *Dcl, Stmt *Body, Sema::CheckConstexprKind Kind) {\n  if (const CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(Dcl)) {\n  } else {\n    if (ReturnStmts.empty()) {\n      case Sema::CheckConstexprKind::Diagnose:\n        SemaRef.Diag(Dcl->getLocation(), OK ? diag::warn_cxx11_compat_constexpr_body_no_return : diag::err_constexpr_body_no_return) << Dcl->isConsteval();"}}

[k]={{F,1679,"/// Check the given declaration statement is legal within a constexpr function\n/// body. C++11 [dcl.constexpr]p3,p4, and C++1y [dcl.constexpr]p3.\n///\n/// \\return true if the body is OK (maybe only as an extension), false if we\n///        have diagnosed a problem.\nstatic bool CheckConstexprDeclStmt(Sema &SemaRef, const FunctionDecl *Dcl, DeclStmt *DS, SourceLocation &Cxx1yLoc, Sema::CheckConstexprKind Kind) {\n  // C++11 [dcl.constexpr]p3 and p4:\n  //  The definition of a constexpr function(p3) or constructor(p4) [...] shall\n  //  contain only\n  for (const auto *DclIt : DS->decls()) {\n    case Decl::Decomposition: {\n      if (Kind == Sema::CheckConstexprKind::Diagnose) {\n        SemaRef.Diag(VD->getLocation(), SemaRef.getLangOpts().CPlusPlus14 ? diag::warn_cxx11_compat_constexpr_local_var : diag::ext_constexpr_local_var) << isa<CXXConstructorDecl>(Dcl);"}}

[k]={{F,1634,"/// Check the given declaration statement is legal within a constexpr function\n/// body. C++11 [dcl.constexpr]p3,p4, and C++1y [dcl.constexpr]p3.\n///\n/// \\return true if the body is OK (maybe only as an extension), false if we\n///        have diagnosed a problem.\nstatic bool CheckConstexprDeclStmt(Sema &SemaRef, const FunctionDecl *Dcl, DeclStmt *DS, SourceLocation &Cxx1yLoc, Sema::CheckConstexprKind Kind) {\n  // C++11 [dcl.constexpr]p3 and p4:\n  //  The definition of a constexpr function(p3) or constructor(p4) [...] shall\n  //  contain only\n  for (const auto *DclIt : DS->decls()) {\n    case Decl::CXXRecord:\n      // C++1y allows types to be defined, not just declared.\n      if (cast<TagDecl>(DclIt)->isThisDeclarationADefinition()) {\n        if (Kind == Sema::CheckConstexprKind::Diagnose) {\n          SemaRef.Diag(DS->getBeginLoc(), SemaRef.getLangOpts().CPlusPlus14 ? diag::warn_cxx11_compat_constexpr_type_definition : diag::ext_constexpr_type_definition) << isa<CXXConstructorDecl>(Dcl);"}}

[k]={{db,959,"/// ParseDecltypeSpecifier - Parse a C++11 decltype specifier.\n///\n/// \'decltype\' ( expression )\n/// \'decltype\' ( \'auto\' )      [C++1y]\n///\nSourceLocation Parser::ParseDecltypeSpecifier(DeclSpec &DS) {\n  if (Tok.is(tok::annot_decltype)) {\n  } else {\n    // Check for C++1y \'decltype(auto)\'.\n    if (Tok.is(tok::kw_auto) && NextToken().is(tok::r_paren)) {\n      Diag(Tok.getLocation(), getLangOpts().CPlusPlus14 ? diag::warn_cxx11_compat_decltype_auto_type_specifier : diag::ext_decltype_auto_type_specifier);"}}

[k]={{Cb,3286,"static QualType GetDeclSpecTypeForDeclarator(TypeProcessingState &state, TypeSourceInfo *&ReturnTypeInfo) {\n  // C++11 [dcl.spec.auto]p5: reject \'auto\' if it is not in an allowed context.\n  if (Deduced) {\n    if (Error != -1) {\n    } else if (Auto && D.getContext() != DeclaratorContext::LambdaExpr) {\n      SemaRef.Diag(AutoRange.getBegin(), D.getContext() == DeclaratorContext::LambdaExprParameter ? diag::warn_cxx11_compat_generic_lambda : IsDeducedReturnType ? diag::warn_cxx11_compat_deduced_return_type : diag::warn_cxx98_compat_auto_type_specifier) << AutoRange;"},{Cb,4598,"static TypeSourceInfo *GetFullTypeForDeclarator(TypeProcessingState &state, QualType declSpecType, TypeSourceInfo *TInfo) {\n  for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i) {\n    case DeclaratorChunk::Function: {\n      // Check for auto functions and trailing return type and adjust the\n      // return type accordingly.\n      if (!D.isInvalidType()) {\n        // trailing-return-type is only required if we\'re declaring a function,\n        // and not, for instance, a pointer to a function.\n        if (D.getDeclSpec().hasAutoTypeSpec() && !FTI.hasTrailingReturnType() && chunkIndex == 0) {\n          if (!S.getLangOpts().CPlusPlus14) {\n          } else {\n            S.Diag(D.getDeclSpec().getTypeSpecTypeLoc(), diag::warn_cxx11_compat_deduced_return_type);"}}

[k]={{vb,1774,"/// LexNumericConstant - Lex the remainder of a integer or floating point\n/// constant. From[-1] is the first character lexed.  Return the end of the\n/// constant.\nbool Lexer::LexNumericConstant(Token &Result, const char *CurPtr) {\n  // If we have a digit separator, continue.\n  if (C == \'\\\'\' && (LangOpts.CPlusPlus14 || LangOpts.C2x)) {\n    if (isAsciiIdentifierContinue(Next)) {\n      if (!isLexingRawMode())\n        Diag(CurPtr, LangOpts.CPlusPlus ? diag::warn_cxx11_compat_digit_separator : diag::warn_c2x_compat_digit_separator);"}}

[k]={{Cb,3286,"static QualType GetDeclSpecTypeForDeclarator(TypeProcessingState &state, TypeSourceInfo *&ReturnTypeInfo) {\n  // C++11 [dcl.spec.auto]p5: reject \'auto\' if it is not in an allowed context.\n  if (Deduced) {\n    if (Error != -1) {\n    } else if (Auto && D.getContext() != DeclaratorContext::LambdaExpr) {\n      SemaRef.Diag(AutoRange.getBegin(), D.getContext() == DeclaratorContext::LambdaExprParameter ? diag::warn_cxx11_compat_generic_lambda : IsDeducedReturnType ? diag::warn_cxx11_compat_deduced_return_type : diag::warn_cxx98_compat_auto_type_specifier) << AutoRange;"}}

[k]={{td,921,"void Sema::ActOnLambdaExpressionAfterIntroducer(LambdaIntroducer &Intro, Scope *CurrentScope) {\n  for (auto C = Intro.Captures.begin(), E = Intro.Captures.end(); C != E; PrevCaptureLoc = C->Loc, ++C) {\n    if (C->Init.isUsable()) {\n      Diag(C->Loc, getLangOpts().CPlusPlus14 ? diag::warn_cxx11_compat_init_capture : diag::ext_init_capture);"}}

[k]={{vb,1815,"/// LexUDSuffix - Lex the ud-suffix production for user-defined literal suffixes\n/// in C++11, or warn on a ud-suffix in C++98.\nconst char *Lexer::LexUDSuffix(Token &Result, const char *CurPtr, bool IsStringLiteral) {\n  if (!LangOpts.CPlusPlus11) {\n    if (!isLexingRawMode())\n      Diag(CurPtr, C == \'_\' ? diag::warn_cxx11_compat_user_defined_literal : diag::warn_cxx11_compat_reserved_user_defined_literal) << FixItHint::CreateInsertion(getSourceLocation(CurPtr), \" \");"}}

[k]={{vb,1815,"/// LexUDSuffix - Lex the ud-suffix production for user-defined literal suffixes\n/// in C++11, or warn on a ud-suffix in C++98.\nconst char *Lexer::LexUDSuffix(Token &Result, const char *CurPtr, bool IsStringLiteral) {\n  if (!LangOpts.CPlusPlus11) {\n    if (!isLexingRawMode())\n      Diag(CurPtr, C == \'_\' ? diag::warn_cxx11_compat_user_defined_literal : diag::warn_cxx11_compat_reserved_user_defined_literal) << FixItHint::CreateInsertion(getSourceLocation(CurPtr), \" \");"}}

[k]={{G,6797,"NamedDecl *Sema::ActOnVariableDeclarator(Scope *S, Declarator &D, DeclContext *DC, TypeSourceInfo *TInfo, LookupResult &Previous, MultiTemplateParamsArg TemplateParamLists, bool &AddToScope, ArrayRef<BindingDecl *> Bindings) {\n  if (!getLangOpts().CPlusPlus) {\n  } else {\n    if (TemplateParams) {\n      if (!TemplateParams->size() && D.getName().getKind() != UnqualifiedIdKind::IK_TemplateId) {\n      } else {\n        if (D.getName().getKind() == UnqualifiedIdKind::IK_TemplateId) {\n        } else { // if (TemplateParams->size() > 0)\n          Diag(D.getIdentifierLoc(), getLangOpts().CPlusPlus14 ? diag::warn_cxx11_compat_variable_template : diag::ext_variable_template);"}}

[k]={{Cb,7553,"static void processTypeAttrs(TypeProcessingState &state, QualType &type, TypeAttrLocation TAL, const ParsedAttributesView &attrs) {\n  for (ParsedAttr &attr : AttrsCopy) {\n    if (attr.isStandardAttributeSyntax() || attr.isRegularKeywordAttribute()) {\n      // [[gnu::...]] attributes are treated as declaration attributes, so may\n      // not appertain to a DeclaratorChunk. If we handle them as type\n      // attributes, accept them in that position and diagnose the GCC\n      // incompatibility.\n      if (attr.isGNUScope()) {\n        if (TAL == TAL_DeclChunk) {\n          state.getSema().Diag(attr.getLoc(), IsTypeAttr ? diag::warn_gcc_ignores_type_attr : diag::warn_cxx11_gnu_attribute_on_type) << attr;"}}

[k]={{"clang/lib/Basic/IdentifierTable.cpp",870,"#include \"clang/Basic/TokenKinds.def\"\n  if (LangOpts.CPlusPlus) {\n    if ((Flags & KEYCXX11) == KEYCXX11)\n      return diag::warn_cxx11_keyword;"}}

[k]={{qc,559,"/// Parse a binary expression that starts with \\p LHS and has a\n/// precedence of at least \\p MinPrec.\nExprResult Parser::ParseRHSOfBinaryExpression(ExprResult LHS, prec::Level MinPrec) {\n  while (true) {\n    if (!LHS.isInvalid()) {\n      // Combine the LHS and RHS into the LHS (e.g. build AST).\n      if (TernaryMiddle.isInvalid()) {\n        // If we\'re using \'>>\' as an operator within a template\n        // argument list (in C++98), suggest the addition of\n        // parentheses so that the code remains well-formed in C++0x.\n        if (!GreaterThanIsOperator && OpToken.is(tok::greatergreater))\n          SuggestParentheses(OpToken.getLocation(), diag::warn_cxx11_right_shift_in_template_arg, SourceRange(Actions.getExprRange(LHS.get()).getBegin(), Actions.getExprRange(RHS.get()).getEnd()));"}}

[k]={{fb,8938,"QualType Sema::DeduceTemplateSpecializationFromInitializer(TypeSourceInfo *TSInfo, const InitializedEntity &Entity, const InitializationKind &Kind, MultiExprArg Inits, ParenListExpr *PL) {\n  // Can\'t deduce from dependent arguments.\n  if (Expr::hasAnyTypeDependentArguments(Inits)) {\n    Diag(TSInfo->getTypeLoc().getBeginLoc(), diag::warn_cxx14_compat_class_template_argument_deduction) << TSInfo->getTypeLoc().getSourceRange() << 0;"},{fb,9214,"QualType Sema::DeduceTemplateSpecializationFromInitializer(TypeSourceInfo *TSInfo, const InitializedEntity &Entity, const InitializationKind &Kind, MultiExprArg Inits, ParenListExpr *PL) {\n  Diag(TSInfo->getTypeLoc().getBeginLoc(), diag::warn_cxx14_compat_class_template_argument_deduction) << TSInfo->getTypeLoc().getSourceRange() << 1 << DeducedType;"}}

[k]={{Yb,1358,"/// ParseIfStatement\n///      if-statement: [C99 6.8.4.1]\n///        \'if\' \'(\' expression \')\' statement\n///        \'if\' \'(\' expression \')\' statement \'else\' statement\n/// [C++]  \'if\' \'(\' condition \')\' statement\n/// [C++]  \'if\' \'(\' condition \')\' statement \'else\' statement\n/// [C++23] \'if\' \'!\' [opt] consteval compound-statement\n/// [C++23] \'if\' \'!\' [opt] consteval compound-statement \'else\' statement\n///\nStmtResult Parser::ParseIfStatement(SourceLocation *TrailingElseLoc) {\n  if (Tok.is(tok::kw_constexpr)) {\n    Diag(Tok, getLangOpts().CPlusPlus17 ? diag::warn_cxx14_compat_constexpr_if : diag::ext_constexpr_if);"}}

[k]={{G,10293,"/// Perform semantic checking of a new function declaration.\n///\n/// Performs semantic analysis of the new function declaration\n/// NewFD. This routine performs all semantic checking that does not\n/// require the actual declarator involved in the declaration, and is\n/// used both for the declaration of functions as they are parsed\n/// (called via ActOnDeclarator) and for the declaration of functions\n/// that have been instantiated via C++ template instantiation (called\n/// via InstantiateDecl).\n///\n/// \\param IsMemberSpecialization whether this new function declaration is\n/// a member specialization (that replaces any definition provided by the\n/// previous declaration).\n///\n/// This sets NewFD->isInvalidDecl() to true if there was an error.\n///\n/// \\returns true if the function declaration is a redeclaration.\nbool Sema::CheckFunctionDeclaration(Scope *S, FunctionDecl *NewFD, LookupResult &Previous, bool IsMemberSpecialization, bool DeclIsDefn) {\n  if (!getLangOpts().CPlusPlus14 && MD && MD->isConstexpr() && !MD->isStatic() && !isa<CXXConstructorDecl>(MD) && !isa<CXXDestructorDecl>(MD) && !MD->getMethodQualifiers().hasConst()) {\n    if (!OldMD || !OldMD->isStatic()) {\n      // Warn that we did this, if we\'re not performing template instantiation.\n      // In that case, we\'ll have warned already when the template was defined.\n      if (!inTemplateInstantiation()) {\n        Diag(MD->getLocation(), diag::warn_cxx14_compat_constexpr_not_const) << FixItHint::CreateInsertion(AddConstLoc, \" const\");"}}

[k]={{Rb,1117,"static void addConstexprToLambdaDeclSpecifier(Parser &P, SourceLocation ConstexprLoc, DeclSpec &DS) {\n  if (ConstexprLoc.isValid()) {\n    P.Diag(ConstexprLoc, !P.getLangOpts().CPlusPlus17 ? diag::ext_constexpr_on_lambda_cxx17 : diag::warn_cxx14_compat_constexpr_on_lambda);"}}

[k]={{F,670,"NamedDecl *Sema::ActOnDecompositionDeclarator(Scope *S, Declarator &D, MultiTemplateParamsArg TemplateParamLists) {\n  Diag(Decomp.getLSquareLoc(), !getLangOpts().CPlusPlus17 ? diag::ext_decomp_decl : D.getContext() == DeclaratorContext::Condition ? diag::ext_decomp_decl_cond : diag::warn_cxx14_compat_decomp_decl) << Decomp.getSourceRange();"}}

[k]={{qc,3132,"/// Parse A C++1z fold-expression after the opening paren and optional\n/// left-hand-side expression.\n///\n/// \\verbatim\n///  fold-expression:\n///      ( cast-expression fold-operator ... )\n///      ( ... fold-operator cast-expression )\n///      ( cast-expression fold-operator ... fold-operator cast-expression )\nExprResult Parser::ParseFoldExpression(ExprResult LHS, BalancedDelimiterTracker &T) {\n  Diag(EllipsisLoc, getLangOpts().CPlusPlus17 ? diag::warn_cxx14_compat_fold_expression : diag::ext_fold_expression);"}}

[k]={{Rb,1876,"/// ParseCXXCondition - if/switch/while condition expression.\n///\n///      condition:\n///        expression\n///        type-specifier-seq declarator \'=\' assignment-expression\n/// [C++11] type-specifier-seq declarator \'=\' initializer-clause\n/// [C++11] type-specifier-seq declarator braced-init-list\n/// [Clang] type-specifier-seq ref-qualifier[opt] \'[\' identifier-list \']\'\n///            brace-or-equal-initializer\n/// [GNU]  type-specifier-seq declarator simple-asm-expr[opt] attributes[opt]\n///            \'=\' assignment-expression\n///\n/// In C++1z, a condition may in some contexts be preceded by an\n/// optional init-statement. This function will parse that too.\n///\n/// \\param InitStmt If non-null, an init-statement is permitted, and if present\n/// will be parsed and stored here.\n///\n/// \\param Loc The location of the start of the statement that requires this\n/// condition, e.g., the \"for\" in a for loop.\n///\n/// \\param MissingOK Whether an empty condition is acceptable here. Otherwise\n/// it is considered an error to be recovered from.\n///\n/// \\param FRI If non-null, a for range declaration is permitted, and if\n/// present will be parsed and stored here, and a null result will be returned.\n///\n/// \\param EnterForConditionScope If true, enter a continue/break scope at the\n/// appropriate moment for a \'for\' loop.\n///\n/// \\returns The parsed condition.\nSema::ConditionResult Parser::ParseCXXCondition(StmtResult *InitStmt, SourceLocation Loc, Sema::ConditionKind CK, bool MissingOK, ForRangeInfo *FRI, bool EnterForConditionScope) {\n  const auto WarnOnInit = [this, &CK] { Diag(Tok.getLocation(), getLangOpts().CPlusPlus17 ? diag::warn_cxx14_compat_init_statement : diag::ext_init_statement) << (CK == Sema::ConditionKind::Switch); };"}}

[k]={{G,6855,"NamedDecl *Sema::ActOnVariableDeclarator(Scope *S, Declarator &D, DeclContext *DC, TypeSourceInfo *TInfo, LookupResult &Previous, MultiTemplateParamsArg TemplateParamLists, bool &AddToScope, ArrayRef<BindingDecl *> Bindings) {\n  if (D.getDeclSpec().isInlineSpecified()) {\n    if (!getLangOpts().CPlusPlus) {\n    } else if (CurContext->isFunctionOrMethod()) {\n    } else {\n      Diag(D.getDeclSpec().getInlineSpecLoc(), getLangOpts().CPlusPlus17 ? diag::warn_cxx14_compat_inline_variable : diag::ext_inline_variable);"}}

[k]={{db,162,"/// ParseNamespace - We know that the current token is a namespace keyword. This\n/// may either be a top level namespace or a block-level namespace alias. If\n/// there was an inline keyword, it has already been parsed.\n///\n///      namespace-definition: [C++: namespace.def]\n///        named-namespace-definition\n///        unnamed-namespace-definition\n///        nested-namespace-definition\n///\n///      named-namespace-definition:\n///        \'inline\'[opt] \'namespace\' attributes[opt] identifier \'{\'\n///        namespace-body \'}\'\n///\n///      unnamed-namespace-definition:\n///        \'inline\'[opt] \'namespace\' attributes[opt] \'{\' namespace-body \'}\'\n///\n///      nested-namespace-definition:\n///        \'namespace\' enclosing-namespace-specifier \'::\' \'inline\'[opt]\n///        identifier \'{\' namespace-body \'}\'\n///\n///      enclosing-namespace-specifier:\n///        identifier\n///        enclosing-namespace-specifier \'::\' \'inline\'[opt] identifier\n///\n///      namespace-alias-definition:  [C++ 7.3.2: namespace.alias]\n///        \'namespace\' identifier \'=\' qualified-namespace-specifier \';\'\n///\nParser::DeclGroupPtrTy Parser::ParseNamespace(DeclaratorContext Context, SourceLocation &DeclEnd, SourceLocation InlineLoc) {\n  if (ExtraNSs.empty()) {\n  } else if (InlineLoc.isValid()) {\n  } else if (getLangOpts().CPlusPlus20) {\n    Diag(ExtraNSs[0].NamespaceLoc, diag::warn_cxx14_compat_nested_namespace_definition);"},{db,166,"/// ParseNamespace - We know that the current token is a namespace keyword. This\n/// may either be a top level namespace or a block-level namespace alias. If\n/// there was an inline keyword, it has already been parsed.\n///\n///      namespace-definition: [C++: namespace.def]\n///        named-namespace-definition\n///        unnamed-namespace-definition\n///        nested-namespace-definition\n///\n///      named-namespace-definition:\n///        \'inline\'[opt] \'namespace\' attributes[opt] identifier \'{\'\n///        namespace-body \'}\'\n///\n///      unnamed-namespace-definition:\n///        \'inline\'[opt] \'namespace\' attributes[opt] \'{\' namespace-body \'}\'\n///\n///      nested-namespace-definition:\n///        \'namespace\' enclosing-namespace-specifier \'::\' \'inline\'[opt]\n///        identifier \'{\' namespace-body \'}\'\n///\n///      enclosing-namespace-specifier:\n///        identifier\n///        enclosing-namespace-specifier \'::\' \'inline\'[opt] identifier\n///\n///      namespace-alias-definition:  [C++ 7.3.2: namespace.alias]\n///        \'namespace\' identifier \'=\' qualified-namespace-specifier \';\'\n///\nParser::DeclGroupPtrTy Parser::ParseNamespace(DeclaratorContext Context, SourceLocation &DeclEnd, SourceLocation InlineLoc) {\n  if (ExtraNSs.empty()) {\n  } else if (InlineLoc.isValid()) {\n  } else if (getLangOpts().CPlusPlus20) {\n  } else if (getLangOpts().CPlusPlus17) {\n    Diag(ExtraNSs[0].NamespaceLoc, diag::warn_cxx14_compat_nested_namespace_definition);"}}

[k]={{Mb,4702,"/// ParseEnumBody - Parse a {} enclosed enumerator-list.\n///      enumerator-list:\n///        enumerator\n///        enumerator-list \',\' enumerator\n///      enumerator:\n///        enumeration-constant attributes[opt]\n///        enumeration-constant attributes[opt] \'=\' constant-expression\n///      enumeration-constant:\n///        identifier\n///\nvoid Parser::ParseEnumBody(SourceLocation StartLoc, Decl *EnumDecl) {\n  // Parse the enumerator-list.\n  while (Tok.isNot(tok::r_brace)) {\n    if (isAllowedCXX11AttributeSpecifier()) {\n      if (getLangOpts().CPlusPlus)\n        Diag(Tok.getLocation(), getLangOpts().CPlusPlus17 ? diag::warn_cxx14_compat_ns_enum_attribute : diag::ext_ns_enum_attribute) << 1 /*enumerator*/;"},{db,89,"/// ParseNamespace - We know that the current token is a namespace keyword. This\n/// may either be a top level namespace or a block-level namespace alias. If\n/// there was an inline keyword, it has already been parsed.\n///\n///      namespace-definition: [C++: namespace.def]\n///        named-namespace-definition\n///        unnamed-namespace-definition\n///        nested-namespace-definition\n///\n///      named-namespace-definition:\n///        \'inline\'[opt] \'namespace\' attributes[opt] identifier \'{\'\n///        namespace-body \'}\'\n///\n///      unnamed-namespace-definition:\n///        \'inline\'[opt] \'namespace\' attributes[opt] \'{\' namespace-body \'}\'\n///\n///      nested-namespace-definition:\n///        \'namespace\' enclosing-namespace-specifier \'::\' \'inline\'[opt]\n///        identifier \'{\' namespace-body \'}\'\n///\n///      enclosing-namespace-specifier:\n///        identifier\n///        enclosing-namespace-specifier \'::\' \'inline\'[opt] identifier\n///\n///      namespace-alias-definition:  [C++ 7.3.2: namespace.alias]\n///        \'namespace\' identifier \'=\' qualified-namespace-specifier \';\'\n///\nParser::DeclGroupPtrTy Parser::ParseNamespace(DeclaratorContext Context, SourceLocation &DeclEnd, SourceLocation InlineLoc) {\n  auto ReadAttributes = [&] {\n    do {\n      if (getLangOpts().CPlusPlus11 && isCXX11AttributeSpecifier()) {\n        Diag(Tok.getLocation(), getLangOpts().CPlusPlus17 ? diag::warn_cxx14_compat_ns_enum_attribute : diag::ext_ns_enum_attribute) << 0 /*namespace*/;"}}

[k]={{td,880,"void Sema::ActOnLambdaExpressionAfterIntroducer(LambdaIntroducer &Intro, Scope *CurrentScope) {\n  for (auto C = Intro.Captures.begin(), E = Intro.Captures.end(); C != E; PrevCaptureLoc = C->Loc, ++C) {\n    if (C->Kind == LCK_This || C->Kind == LCK_StarThis) {\n      if (C->Kind == LCK_StarThis)\n        Diag(C->Loc, !getLangOpts().CPlusPlus17 ? diag::ext_star_this_lambda_capture_cxx17 : diag::warn_cxx14_compat_star_this_lambda_capture);"}}

[k]={{db,869,"/// ParseStaticAssertDeclaration - Parse C++0x or C11 static_assert-declaration.\n///\n/// [C++0x] static_assert-declaration:\n///          static_assert ( constant-expression  ,  string-literal  ) ;\n///\n/// [C11]  static_assert-declaration:\n///          _Static_assert ( constant-expression  ,  string-literal  ) ;\n///\nDecl *Parser::ParseStaticAssertDeclaration(SourceLocation &DeclEnd) {\n  if (Tok.is(tok::r_paren)) {\n    if (getLangOpts().CPlusPlus17)\n      DiagVal = diag::warn_cxx14_compat_static_assert_no_message;"}}

[k]={{wb,1311,"NamedDecl *Sema::ActOnNonTypeTemplateParameter(Scope *S, Declarator &D, unsigned Depth, unsigned Position, SourceLocation EqualLoc, Expr *Default) {\n  if (const auto *T = TInfo->getType()->getContainedDeducedType())\n    if (isa<AutoType>(T))\n      Diag(D.getIdentifierLoc(), diag::warn_cxx14_compat_template_nontype_parm_auto_type) << QualType(TInfo->getType()->getContainedAutoType(), 0);"}}

[k]={{"clang/lib/Parse/ParseTemplate.cpp",825,"/// ParseTemplateTemplateParameter - Handle the parsing of template\n/// template parameters.\n///\n///      type-parameter:    [C++ temp.param]\n///        template-head type-parameter-key ...[opt] identifier[opt]\n///        template-head type-parameter-key identifier[opt] = id-expression\n///      type-parameter-key:\n///        \'class\'\n///        \'typename\'      [C++1z]\n///      template-head:    [C++2a]\n///        \'template\' \'<\' template-parameter-list \'>\'\n///            requires-clause[opt]\nNamedDecl *Parser::ParseTemplateTemplateParameter(unsigned Depth, unsigned Position) {\n  // Provide an ExtWarn if the C++1z feature of using \'typename\' here is used.\n  // Generate a meaningful error if the user forgot to put class before the\n  // identifier, comma, or greater. Provide a fixit if the identifier, comma,\n  // or greater appear immediately or after \'struct\'. In the latter case,\n  // replace the keyword with \'class\'.\n  if (!TryConsumeToken(tok::kw_class)) {\n    if (Tok.is(tok::kw_typename)) {\n      Diag(Tok.getLocation(), getLangOpts().CPlusPlus17 ? diag::warn_cxx14_compat_template_template_param_typename : diag::ext_template_template_param_typename) << (!getLangOpts().CPlusPlus17 ? FixItHint::CreateReplacement(Tok.getLocation(), \"class\") : FixItHint());"}}

[k]={{vb,2091,"/// LexCharConstant - Lex the remainder of a character constant, after having\n/// lexed either \' or L\' or u8\' or u\' or U\'.\nbool Lexer::LexCharConstant(Token &Result, const char *CurPtr, tok::TokenKind Kind) {\n  if (!isLexingRawMode()) {\n    if (Kind == tok::utf16_char_constant || Kind == tok::utf32_char_constant)\n    else if (Kind == tok::utf8_char_constant)\n      Diag(BufferPtr, diag::warn_cxx14_compat_u8_character_literal);"}}

[k]={{db,3955,"/// Parse a C++11 or C2x attribute-specifier.\n///\n/// [C++11] attribute-specifier:\n///        \'[\' \'[\' attribute-list \']\' \']\'\n///        alignment-specifier\n///\n/// [C++11] attribute-list:\n///        attribute[opt]\n///        attribute-list \',\' attribute[opt]\n///        attribute \'...\'\n///        attribute-list \',\' attribute \'...\'\n///\n/// [C++11] attribute:\n///        attribute-token attribute-argument-clause[opt]\n///\n/// [C++11] attribute-token:\n///        identifier\n///        attribute-scoped-token\n///\n/// [C++11] attribute-scoped-token:\n///        attribute-namespace \'::\' identifier\n///\n/// [C++11] attribute-namespace:\n///        identifier\nvoid Parser::ParseCXX11AttributeSpecifierInternal(ParsedAttributes &Attrs, CachedTokens &OpenMPTokens, SourceLocation *EndLoc) {\n  if (Tok.is(tok::kw_using)) {\n    Diag(Tok.getLocation(), getLangOpts().CPlusPlus17 ? diag::warn_cxx14_compat_using_attribute_ns : diag::ext_using_attribute_ns);"}}

[k]={{M,6080,"ExprResult Sema::ActOnCallExpr(Scope *Scope, Expr *Fn, SourceLocation LParenLoc, MultiExprArg ArgExprs, SourceLocation RParenLoc, Expr *ExecConfig) {\n  // Diagnose uses of the C++20 \"ADL-only template-id call\" feature in earlier\n  // language modes.\n  if (auto *ULE = dyn_cast<UnresolvedLookupExpr>(Fn)) {\n    if (ULE->hasExplicitTemplateArgs() && ULE->decls_begin() == ULE->decls_end()) {\n      Diag(Fn->getExprLoc(), getLangOpts().CPlusPlus20 ? diag::warn_cxx17_compat_adl_only_template_id : diag::ext_adl_only_template_id) << ULE->getName();"}}

[k]={{fb,4795,"static void TryOrBuildParenListInitialization(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, ArrayRef<Expr *> Args, InitializationSequence &Sequence, bool VerifyOnly, ExprResult *Result = nullptr) {\n  if (VerifyOnly) {\n  } else if (Result) {\n    S.Diag(Kind.getLocation(), diag::warn_cxx17_compat_aggregate_init_paren_list) << Kind.getLocation() << SR << ResultType;"}}

[k]={{db,2609,"/// ParseCXXClassMemberDeclaration - Parse a C++ class member declaration.\n///\n///      member-declaration:\n///        decl-specifier-seq[opt] member-declarator-list[opt] \';\'\n///        function-definition \';\'[opt]\n///        ::[opt] nested-name-specifier template[opt] unqualified-id \';\'[TODO]\n///        using-declaration                                            [TODO]\n/// [C++0x] static_assert-declaration\n///        template-declaration\n/// [GNU]  \'__extension__\' member-declaration\n///\n///      member-declarator-list:\n///        member-declarator\n///        member-declarator-list \',\' member-declarator\n///\n///      member-declarator:\n///        declarator virt-specifier-seq[opt] pure-specifier[opt]\n/// [C++2a] declarator requires-clause\n///        declarator constant-initializer[opt]\n/// [C++11] declarator brace-or-equal-initializer[opt]\n///        identifier[opt] \':\' constant-expression\n///\n///      virt-specifier-seq:\n///        virt-specifier\n///        virt-specifier-seq virt-specifier\n///\n///      virt-specifier:\n///        override\n///        final\n/// [MS]    sealed\n///\n///      pure-specifier:\n///        \'= 0\'\n///\n///      constant-initializer:\n///        \'=\' constant-expression\n///\nParser::DeclGroupPtrTy Parser::ParseCXXClassMemberDeclaration(AccessSpecifier AS, ParsedAttributes &AccessAttrs, const ParsedTemplateInfo &TemplateInfo, ParsingDeclRAIIObject *TemplateDiags) {\n  while (true) {\n    if (Tok.isOneOf(tok::equal, tok::l_brace) && PureSpecLoc.isInvalid()) {\n      // DRXXXX: Anonymous bit-fields cannot have a brace-or-equal-initializer.\n      if (BitfieldSize.isUsable() && !DeclaratorInfo.hasName()) {\n      } else if (DeclaratorInfo.isDeclarationOfFunction()) {\n      } else if (DeclaratorInfo.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_static && DeclaratorInfo.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_typedef && !DS.isFriendSpecified()) {\n        // It\'s a default member initializer.\n        if (BitfieldSize.get())\n          Diag(Tok, getLangOpts().CPlusPlus20 ? diag::warn_cxx17_compat_bitfield_member_init : diag::ext_bitfield_member_init);"}}

[k]={{M,16668,"// Certain capturing entities (lambdas, blocks etc.) are not allowed to capture\n// certain types of variables (unnamed, variably modified types etc.)\n// so check for eligibility.\nstatic bool isVariableCapturable(CapturingScopeInfo *CSI, ValueDecl *Var, SourceLocation Loc, const bool Diagnose, Sema &S) {\n  if (isa<BindingDecl>(Var)) {\n    if (!IsLambda || !S.getLangOpts().CPlusPlus) {\n    } else if (Diagnose && S.getLangOpts().CPlusPlus) {\n      S.Diag(Loc, S.LangOpts.CPlusPlus20 ? diag::warn_cxx17_compat_capture_binding : diag::ext_capture_binding) << Var;"}}

[k]={{F,1947,"/// Check the body for the given constexpr function declaration only contains\n/// the permitted types of statement. C++11 [dcl.constexpr]p3,p4.\n///\n/// \\return true if the body is OK, false if we have found or diagnosed a\n/// problem.\nstatic bool CheckConstexprFunctionBody(Sema &SemaRef, const FunctionDecl *Dcl, Stmt *Body, Sema::CheckConstexprKind Kind) {\n  if (Kind == Sema::CheckConstexprKind::CheckValid) {\n  } else if (Cxx2bLoc.isValid()) {\n  } else if (Cxx2aLoc.isValid()) {\n    SemaRef.Diag(Cxx2aLoc, SemaRef.getLangOpts().CPlusPlus20 ? diag::warn_cxx17_compat_constexpr_body_invalid_stmt : diag::ext_constexpr_body_invalid_stmt_cxx20) << isa<CXXConstructorDecl>(Dcl);"}}

[k]={{F,1738,"/// Check that the given field is initialized within a constexpr constructor.\n///\n/// \\param Dcl The constexpr constructor being checked.\n/// \\param Field The field being checked. This may be a member of an anonymous\n///        struct or union nested within the class being checked.\n/// \\param Inits All declarations, including anonymous struct/union members and\n///        indirect members, for which any initialization was provided.\n/// \\param Diagnosed Whether we\'ve emitted the error message yet. Used to attach\n///        multiple notes for different members to the same error.\n/// \\param Kind Whether we\'re diagnosing a constructor as written or determining\n///        whether the formal requirements are satisfied.\n/// \\return \\c false if we\'re checking for validity and the constructor does\n///        not satisfy the requirements on a constexpr constructor.\nstatic bool CheckConstexprCtorInitializer(Sema &SemaRef, const FunctionDecl *Dcl, FieldDecl *Field, llvm::SmallSet<Decl *, 16> &Inits, bool &Diagnosed, Sema::CheckConstexprKind Kind) {\n  if (!Inits.count(Field)) {\n    if (Kind == Sema::CheckConstexprKind::Diagnose) {\n      if (!Diagnosed) {\n        SemaRef.Diag(Dcl->getLocation(), SemaRef.getLangOpts().CPlusPlus20 ? diag::warn_cxx17_compat_constexpr_ctor_missing_init : diag::ext_constexpr_ctor_missing_init);"}}

[k]={{F,1923,"/// Check the body for the given constexpr function declaration only contains\n/// the permitted types of statement. C++11 [dcl.constexpr]p3,p4.\n///\n/// \\return true if the body is OK, false if we have found or diagnosed a\n/// problem.\nstatic bool CheckConstexprFunctionBody(Sema &SemaRef, const FunctionDecl *Dcl, Stmt *Body, Sema::CheckConstexprKind Kind) {\n  if (isa<CXXTryStmt>(Body)) {\n    case Sema::CheckConstexprKind::Diagnose:\n      SemaRef.Diag(Body->getBeginLoc(), !SemaRef.getLangOpts().CPlusPlus20 ? diag::ext_constexpr_function_try_block_cxx20 : diag::warn_cxx17_compat_constexpr_function_try_block) << isa<CXXConstructorDecl>(Dcl);"}}

[k]={{F,1671,"/// Check the given declaration statement is legal within a constexpr function\n/// body. C++11 [dcl.constexpr]p3,p4, and C++1y [dcl.constexpr]p3.\n///\n/// \\return true if the body is OK (maybe only as an extension), false if we\n///        have diagnosed a problem.\nstatic bool CheckConstexprDeclStmt(Sema &SemaRef, const FunctionDecl *Dcl, DeclStmt *DS, SourceLocation &Cxx1yLoc, Sema::CheckConstexprKind Kind) {\n  // C++11 [dcl.constexpr]p3 and p4:\n  //  The definition of a constexpr function(p3) or constructor(p4) [...] shall\n  //  contain only\n  for (const auto *DclIt : DS->decls()) {\n    case Decl::Decomposition: {\n      if (VD->isThisDeclarationADefinition()) {\n        if (!VD->getType()->isDependentType() && !VD->hasInit() && !VD->isCXXForRangeDecl()) {\n          if (Kind == Sema::CheckConstexprKind::Diagnose) {\n            SemaRef.Diag(VD->getLocation(), SemaRef.getLangOpts().CPlusPlus20 ? diag::warn_cxx17_compat_constexpr_local_var_no_init : diag::ext_constexpr_local_var_no_init) << isa<CXXConstructorDecl>(Dcl);"}}

[k]={{F,1963,"/// Check the body for the given constexpr function declaration only contains\n/// the permitted types of statement. C++11 [dcl.constexpr]p3,p4.\n///\n/// \\return true if the body is OK, false if we have found or diagnosed a\n/// problem.\nstatic bool CheckConstexprFunctionBody(Sema &SemaRef, const FunctionDecl *Dcl, Stmt *Body, Sema::CheckConstexprKind Kind) {\n  if (const CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(Dcl)) {\n    // DR1359:\n    // - every non-variant non-static data member and base class sub-object\n    //  shall be initialized;\n    // DR1460:\n    // - if the class is a union having variant members, exactly one of them\n    //  shall be initialized;\n    if (RD->isUnion()) {\n      if (Constructor->getNumCtorInitializers() == 0 && RD->hasVariantMembers()) {\n        if (Kind == Sema::CheckConstexprKind::Diagnose) {\n          SemaRef.Diag(Dcl->getLocation(), SemaRef.getLangOpts().CPlusPlus20 ? diag::warn_cxx17_compat_constexpr_union_ctor_no_init : diag::ext_constexpr_union_ctor_no_init);"}}

[k]={{F,1544,"// Check whether a function declaration satisfies the requirements of a\n// constexpr function definition or a constexpr constructor definition. If so,\n// return true. If not, produce appropriate diagnostics (unless asked not to by\n// Kind) and return false.\n//\n// This implements C++11 [dcl.constexpr]p3,4, as amended by DR1360.\nbool Sema::CheckConstexprFunctionDefinition(const FunctionDecl *NewFD, CheckConstexprKind Kind) {\n  if (!isa<CXXConstructorDecl>(NewFD)) {\n    if (Method && Method->isVirtual()) {\n      if (getLangOpts().CPlusPlus20) {\n        if (Kind == CheckConstexprKind::Diagnose)\n          Diag(Method->getLocation(), diag::warn_cxx17_compat_constexpr_virtual);"}}

[k]={{F,722,"NamedDecl *Sema::ActOnDecompositionDeclarator(Scope *S, Declarator &D, MultiTemplateParamsArg TemplateParamLists) {\n  {\n    if (!BadSpecifiers.empty()) {\n    } else if (!CPlusPlus20Specifiers.empty()) {\n      auto &&Warn = Diag(CPlusPlus20SpecifierLocs.front(), getLangOpts().CPlusPlus20 ? diag::warn_cxx17_compat_decomp_decl_spec : diag::ext_decomp_decl_spec);"}}

[k]={{F,15277,"void Sema::SetDeclDefaulted(Decl *Dcl, SourceLocation DefaultLoc) {\n  // Issue compatibility warning. We already warned if the operator is\n  // \'operator<=>\' when parsing the \'<=>\' token.\n  if (DefKind.isComparison() && DefKind.asComparison() != DefaultedComparisonKind::ThreeWay) {\n    Diag(DefaultLoc, getLangOpts().CPlusPlus20 ? diag::warn_cxx17_compat_defaulted_comparison : diag::ext_defaulted_comparison);"}}

[k]={{F,6647,"bool Sema::CheckExplicitlyDefaultedSpecialMember(CXXMethodDecl *MD, CXXSpecialMember CSM, SourceLocation DefaultLoc) {\n  if (ShouldDeleteForTypeMismatch || ShouldDeleteSpecialMember(MD, CSM)) {\n    if (First) {\n      if (ShouldDeleteForTypeMismatch && !HadError) {\n        Diag(MD->getLocation(), diag::warn_cxx17_compat_defaulted_method_type_mismatch) << CSM;"}}

[k]={{M,6740,"ExprResult Sema::ActOnInitList(SourceLocation LBraceLoc, MultiExprArg InitArgList, SourceLocation RBraceLoc) {\n  if (FirstDesignator.isValid()) {\n    // Only diagnose designated initiaization as a C++20 extension if we didn\'t\n    // already diagnose use of (non-C++20) C99 designator syntax.\n    if (getLangOpts().CPlusPlus && !DiagnosedArrayDesignator && !DiagnosedNestedDesignator && !DiagnosedMixedDesignator) {\n      Diag(FirstDesignator, getLangOpts().CPlusPlus20 ? diag::warn_cxx17_compat_designated_init : diag::ext_cxx_designated_init);"}}

[k]={{td,896,"void Sema::ActOnLambdaExpressionAfterIntroducer(LambdaIntroducer &Intro, Scope *CurrentScope) {\n  for (auto C = Intro.Captures.begin(), E = Intro.Captures.end(); C != E; PrevCaptureLoc = C->Loc, ++C) {\n    if (C->Kind == LCK_This || C->Kind == LCK_StarThis) {\n      // C++20 [expr.prim.lambda]p8:\n      //  If a lambda-capture includes a capture-default that is =,\n      //  each simple-capture of that lambda-capture shall be of the form\n      //  \"&identifier\", \"this\", or \"* this\". [ Note: The form [&,this] is\n      //  redundant but accepted for compatibility with ISO C++14. --end note ]\n      if (Intro.Default == LCD_ByCopy && C->Kind != LCK_StarThis)\n        Diag(C->Loc, !getLangOpts().CPlusPlus20 ? diag::ext_equals_this_lambda_capture_cxx20 : diag::warn_cxx17_compat_equals_this_lambda_capture);"}}

[k]={{G,10514,"/// Perform semantic checking of a new function declaration.\n///\n/// Performs semantic analysis of the new function declaration\n/// NewFD. This routine performs all semantic checking that does not\n/// require the actual declarator involved in the declaration, and is\n/// used both for the declaration of functions as they are parsed\n/// (called via ActOnDeclarator) and for the declaration of functions\n/// that have been instantiated via C++ template instantiation (called\n/// via InstantiateDecl).\n///\n/// \\param IsMemberSpecialization whether this new function declaration is\n/// a member specialization (that replaces any definition provided by the\n/// previous declaration).\n///\n/// This sets NewFD->isInvalidDecl() to true if there was an error.\n///\n/// \\returns true if the function declaration is a redeclaration.\nbool Sema::CheckFunctionDeclaration(Scope *S, FunctionDecl *NewFD, LookupResult &Previous, bool IsMemberSpecialization, bool DeclIsDefn) {\n  if (getLangOpts().CPlusPlus) {\n    // C++1z [dcl.fct]p6:\n    //  [...] whether the function has a non-throwing exception-specification\n    //  [is] part of the function type\n    //\n    // This results in an ABI break between C++14 and C++17 for functions whose\n    // declared type includes an exception-specification in a parameter or\n    // return type. (Exception specifications on the function itself are OK in\n    // most cases, and exception specifications are not permitted in most other\n    // contexts where they could make it into a mangling.)\n    if (!getLangOpts().CPlusPlus17 && !NewFD->getPrimaryTemplate()) {\n      if (AnyNoexcept)\n        Diag(NewFD->getLocation(), diag::warn_cxx17_compat_exception_spec_in_signature) << NewFD;"}}

[k]={{Mb,3664,"/// ParseDeclarationSpecifiers\n///      declaration-specifiers: [C99 6.7]\n///        storage-class-specifier declaration-specifiers[opt]\n///        type-specifier declaration-specifiers[opt]\n/// [C99]  function-specifier declaration-specifiers[opt]\n/// [C11]  alignment-specifier declaration-specifiers[opt]\n/// [GNU]  attributes declaration-specifiers[opt]\n/// [Clang] \'__module_private__\' declaration-specifiers[opt]\n/// [ObjC1] \'__kindof\' declaration-specifiers[opt]\n///\n///      storage-class-specifier: [C99 6.7.1]\n///        \'typedef\'\n///        \'extern\'\n///        \'static\'\n///        \'auto\'\n///        \'register\'\n/// [C++]  \'mutable\'\n/// [C++11] \'thread_local\'\n/// [C11]  \'_Thread_local\'\n/// [GNU]  \'__thread\'\n///      function-specifier: [C99 6.7.4]\n/// [C99]  \'inline\'\n/// [C++]  \'virtual\'\n/// [C++]  \'explicit\'\n/// [OpenCL] \'__kernel\'\n///      \'friend\': [C++ dcl.friend]\n///      \'constexpr\': [C++0x dcl.constexpr]\nvoid Parser::ParseDeclarationSpecifiers(DeclSpec &DS, const ParsedTemplateInfo &TemplateInfo, AccessSpecifier AS, DeclSpecContext DSContext, LateParsedAttrList *LateAttrs, ImplicitTypenameContext AllowImplicitTypename) {\n  while (true) {\n    case tok::kw_explicit: {\n      if (Tok.is(tok::l_paren)) {\n        if (getLangOpts().CPlusPlus20 || isExplicitBool() == TPResult::True) {\n          Diag(Tok.getLocation(), getLangOpts().CPlusPlus20 ? diag::warn_cxx17_compat_explicit_bool : diag::ext_explicit_bool);"}}

[k]={{Yb,2017,"/// ParseForStatement\n///      for-statement: [C99 6.8.5.3]\n///        \'for\' \'(\' expr[opt] \';\' expr[opt] \';\' expr[opt] \')\' statement\n///        \'for\' \'(\' declaration expr[opt] \';\' expr[opt] \')\' statement\n/// [C++]  \'for\' \'(\' for-init-statement condition[opt] \';\' expression[opt] \')\'\n/// [C++]      statement\n/// [C++0x] \'for\'\n///            \'co_await\'[opt]    [Coroutines]\n///            \'(\' for-range-declaration \':\' for-range-initializer \')\'\n///            statement\n/// [OBJC2] \'for\' \'(\' declaration \'in\' expr \')\' statement\n/// [OBJC2] \'for\' \'(\' expr \'in\' expr \')\' statement\n///\n/// [C++] for-init-statement:\n/// [C++]  expression-statement\n/// [C++]  simple-declaration\n/// [C++23] alias-declaration\n///\n/// [C++0x] for-range-declaration:\n/// [C++0x]  attribute-specifier-seq[opt] type-specifier-seq declarator\n/// [C++0x] for-range-initializer:\n/// [C++0x]  expression\n/// [C++0x]  braced-init-list            [TODO]\nStmtResult Parser::ParseForStatement(SourceLocation *TrailingElseLoc) {\n  // Parse the second part of the for specifier.\n  if (!ForEach && !ForRangeInfo.ParsedForRangeDecl() && !SecondPart.isInvalid()) {\n    // Parse the second part of the for specifier.\n    if (Tok.is(tok::semi)) { // for (...;;\n    } else if (Tok.is(tok::r_paren)) {\n    } else {\n      if (getLangOpts().CPlusPlus) {\n        if (ForRangeInfo.ParsedForRangeDecl()) {\n          Diag(FirstPart.get() ? FirstPart.get()->getBeginLoc() : ForRangeInfo.ColonLoc, getLangOpts().CPlusPlus20 ? diag::warn_cxx17_compat_for_range_init_stmt : diag::ext_for_range_init_stmt) << (FirstPart.get() ? FirstPart.get()->getSourceRange() : SourceRange());"}}

[k]={{G,335,"/// If the identifier refers to a type name within this scope,\n/// return the declaration of that type.\n///\n/// This routine performs ordinary name lookup of the identifier II\n/// within the given scope, with optional C++ scope specifier SS, to\n/// determine whether the name refers to a type. If so, returns an\n/// opaque pointer (actually a QualType) corresponding to that\n/// type. Otherwise, returns NULL.\nParsedType Sema::getTypeName(const IdentifierInfo &II, SourceLocation NameLoc, Scope *S, CXXScopeSpec *SS, bool isClassName, bool HasTrailingDot, ParsedType ObjectTypePtr, bool IsCtorOrDtorName, bool WantNontrivialTypeSourceInfo, bool IsClassTemplateDeductionContext, ImplicitTypenameContext AllowImplicitTypename, IdentifierInfo **CorrectedII) {\n  if (ObjectTypePtr) {\n  } else if (SS && SS->isNotEmpty()) {\n    if (!LookupCtx) {\n      if (isDependentScopeSpecifier(*SS)) {\n        if (IsImplicitTypename) {\n          if (getLangOpts().CPlusPlus20)\n            Diag(QualifiedLoc, diag::warn_cxx17_compat_implicit_typename);"},{wb,3475,"TypeResult Sema::ActOnTemplateIdType(Scope *S, CXXScopeSpec &SS, SourceLocation TemplateKWLoc, TemplateTy TemplateD, IdentifierInfo *TemplateII, SourceLocation TemplateIILoc, SourceLocation LAngleLoc, ASTTemplateArgsPtr TemplateArgsIn, SourceLocation RAngleLoc, bool IsCtorOrDtorName, bool IsClassName, ImplicitTypenameContext AllowImplicitTypename) {\n  if (!IsCtorOrDtorName && !IsClassName && SS.isSet()) {\n    // C++ [temp.res]p3:\n    //  A qualified-id that refers to a type and in which the\n    //  nested-name-specifier depends on a template-parameter (14.6.2)\n    //  shall be prefixed by the keyword typename to indicate that the\n    //  qualified-id denotes a type, forming an\n    //  elaborated-type-specifier (7.1.5.3).\n    if (!LookupCtx && isDependentScopeSpecifier(SS)) {\n      // C++2a relaxes some of those restrictions in [temp.res]p5.\n      if (AllowImplicitTypename == ImplicitTypenameContext::Yes) {\n        if (getLangOpts().CPlusPlus20)\n          Diag(SS.getBeginLoc(), diag::warn_cxx17_compat_implicit_typename);"}}

[k]={{td,637,"QualType Sema::buildLambdaInitCaptureInitialization(SourceLocation Loc, bool ByRef, SourceLocation EllipsisLoc, std::optional<unsigned> NumExpansions, IdentifierInfo *Id, bool IsDirectInit, Expr *&Init) {\n  if (EllipsisLoc.isValid()) {\n    if (Init->containsUnexpandedParameterPack()) {\n      Diag(EllipsisLoc, getLangOpts().CPlusPlus20 ? diag::warn_cxx17_compat_init_capture_pack : diag::ext_init_capture_pack);"}}

[k]={{db,164,"/// ParseNamespace - We know that the current token is a namespace keyword. This\n/// may either be a top level namespace or a block-level namespace alias. If\n/// there was an inline keyword, it has already been parsed.\n///\n///      namespace-definition: [C++: namespace.def]\n///        named-namespace-definition\n///        unnamed-namespace-definition\n///        nested-namespace-definition\n///\n///      named-namespace-definition:\n///        \'inline\'[opt] \'namespace\' attributes[opt] identifier \'{\'\n///        namespace-body \'}\'\n///\n///      unnamed-namespace-definition:\n///        \'inline\'[opt] \'namespace\' attributes[opt] \'{\' namespace-body \'}\'\n///\n///      nested-namespace-definition:\n///        \'namespace\' enclosing-namespace-specifier \'::\' \'inline\'[opt]\n///        identifier \'{\' namespace-body \'}\'\n///\n///      enclosing-namespace-specifier:\n///        identifier\n///        enclosing-namespace-specifier \'::\' \'inline\'[opt] identifier\n///\n///      namespace-alias-definition:  [C++ 7.3.2: namespace.alias]\n///        \'namespace\' identifier \'=\' qualified-namespace-specifier \';\'\n///\nParser::DeclGroupPtrTy Parser::ParseNamespace(DeclaratorContext Context, SourceLocation &DeclEnd, SourceLocation InlineLoc) {\n  if (ExtraNSs.empty()) {\n  } else if (InlineLoc.isValid()) {\n  } else if (getLangOpts().CPlusPlus20) {\n    if (FirstNestedInlineLoc.isValid())\n      Diag(FirstNestedInlineLoc, diag::warn_cxx17_compat_inline_nested_namespace_definition);"}}

[k]={{M,293,"/// Determine whether the use of this declaration is valid, and\n/// emit any corresponding diagnostics.\n///\n/// This routine diagnoses various problems with referencing\n/// declarations that can occur when using a declaration. For example,\n/// it might warn if a deprecated or unavailable declaration is being\n/// used, or produce an error (and return true) if a C++0x deleted\n/// function is being used.\n///\n/// \\returns true if there was an error (this declaration cannot be\n/// referenced), false otherwise.\n///\nbool Sema::DiagnoseUseOfDecl(NamedDecl *D, ArrayRef<SourceLocation> Locs, const ObjCInterfaceDecl *UnknownObjCClass, bool ObjCPropertyAccess, bool AvoidPartialAvailabilityChecks, ObjCInterfaceDecl *ClassReceiver, bool SkipTrailingRequiresClause) {\n  if (auto *MD = dyn_cast<CXXMethodDecl>(D)) {\n    // Lambdas are only default-constructible or assignable in C++2a onwards.\n    if (MD->getParent()->isLambda() && ((isa<CXXConstructorDecl>(MD) && cast<CXXConstructorDecl>(MD)->isDefaultConstructor()) || MD->isCopyAssignmentOperator() || MD->isMoveAssignmentOperator())) {\n      Diag(Loc, diag::warn_cxx17_compat_lambda_def_ctor_assign) << !isa<CXXConstructorDecl>(MD);"}}

[k]={{Rb,1202,"/// ParseLambdaExpressionAfterIntroducer - Parse the rest of a lambda\n/// expression.\nExprResult Parser::ParseLambdaExpressionAfterIntroducer(LambdaIntroducer &Intro) {\n  if (Tok.is(tok::less)) {\n    Diag(Tok, getLangOpts().CPlusPlus20 ? diag::warn_cxx17_compat_lambda_template_parameter_list : diag::ext_lambda_template_parameter_list);"}}

[k]={{"clang/lib/Lex/PPMacroExpansion.cpp",939,"/// ReadFunctionLikeMacroArgs - After reading \"MACRO\" and knowing that the next\n/// token is the \'(\' of the macro, this method is invoked to read all of the\n/// actual arguments specified for the macro invocation.  This returns null on\n/// error.\nMacroArgs *Preprocessor::ReadMacroCallArgumentList(Token &MacroName, MacroInfo *MI, SourceLocation &MacroEnd) {\n  if (NumActuals < MinArgsExpected) {\n    // There are several cases where too few arguments is ok, handle them now.\n    if (NumActuals == 0 && MinArgsExpected == 1) {\n    } else if ((FoundElidedComma || MI->isVariadic()) && (NumActuals + 1 == MinArgsExpected ||          // A(x, ...) -> A(X)\n      // Varargs where the named vararg parameter is missing: OK as extension.\n      //  #define A(x, ...)\n      //  A(\"blah\")\n      //\n      // If the macro contains the comma pasting extension, the diagnostic\n      // is suppressed; we know we\'ll get another diagnostic later.\n      if (!MI->hasCommaPasting()) {\n        Diag(Tok, getLangOpts().CPlusPlus20 ? diag::warn_cxx17_compat_missing_varargs_arg : diag::ext_missing_varargs_arg);"}}

[k]={{db,750,"/// ParseUsingDeclaration - Parse C++ using-declaration or alias-declaration.\n/// Assumes that \'using\' was already seen.\n///\n///    using-declaration: [C++ 7.3.p3: namespace.udecl]\n///      \'using\' using-declarator-list[opt] ;\n///\n///    using-declarator-list: [C++1z]\n///      using-declarator \'...\'[opt]\n///      using-declarator-list \',\' using-declarator \'...\'[opt]\n///\n///    using-declarator-list: [C++98-14]\n///      using-declarator\n///\n///    alias-declaration: C++11 [dcl.dcl]p1\n///      \'using\' identifier attribute-specifier-seq[opt] = type-id ;\n///\n///    using-enum-declaration: [C++20, dcl.enum]\n///      \'using\' elaborated-enum-specifier ;\n///      The terminal name of the elaborated-enum-specifier undergoes\n///      ordinary lookup\n///\n///    elaborated-enum-specifier:\n///      \'enum\' nested-name-specifier[opt] identifier\nParser::DeclGroupPtrTy Parser::ParseUsingDeclaration(DeclaratorContext Context, const ParsedTemplateInfo &TemplateInfo, SourceLocation UsingLoc, SourceLocation &DeclEnd, ParsedAttributes &PrefixAttrs, AccessSpecifier AS) {\n  if (DeclsInGroup.size() > 1)\n    Diag(Tok.getLocation(), getLangOpts().CPlusPlus17 ? diag::warn_cxx17_compat_multi_using_declaration : diag::ext_multi_using_declaration);"}}

[k]={{Sb,5250,"QualType Sema::CheckPointerToMemberOperands(ExprResult &LHS, ExprResult &RHS, ExprValueKind &VK, SourceLocation Loc, bool isIndirect) {\n  // C++0x [expr.mptr.oper]p6:\n  //  In a .* expression whose object expression is an rvalue, the program is\n  //  ill-formed if the second operand is a pointer to member function with\n  //  ref-qualifier &. In a ->* expression or in a .* expression whose object\n  //  expression is an lvalue, the program is ill-formed if the second operand\n  //  is a pointer to member function with ref-qualifier &&.\n  if (const FunctionProtoType *Proto = Result->getAs<FunctionProtoType>()) {\n    case RQ_LValue:\n      if (!isIndirect && !LHS.get()->Classify(Context).isLValue()) {\n        // C++2a allows functions with ref-qualifier & if their cv-qualifier-seq\n        // is (exactly) \'const\'.\n        if (Proto->isConst() && !Proto->isVolatile())\n          Diag(Loc, getLangOpts().CPlusPlus20 ? diag::warn_cxx17_compat_pointer_to_const_ref_member_on_rvalue : diag::ext_pointer_to_const_ref_member_on_rvalue);"}}

[k]={{vb,3852,"LexStart:\n  case \'<\':\n    if (ParsingFilename) {\n    } else if (Char == \'<\') {\n    } else if (Char == \'=\') {\n      if (After == \'>\') {\n        if (LangOpts.CPlusPlus20) {\n          if (!isLexingRawMode())\n            Diag(BufferPtr, diag::warn_cxx17_compat_spaceship);"}}

[k]={{wb,1251,"QualType Sema::CheckNonTypeTemplateParameterType(QualType T, SourceLocation Loc) {\n  Diag(Loc, diag::warn_cxx17_compat_template_nontype_parm_type) << T;"}}

[k]={{dc,1230,"/// Finish - This does final analysis of the declspec, rejecting things like\n/// \"_Imaginary\" (lacking an FP type). After calling this method, DeclSpec is\n/// guaranteed to be self-consistent, even if an error occurred.\nvoid DeclSpec::Finish(Sema &S, const PrintingPolicy &Policy) {\n  if (TypeSpecType == TST_char8)\n    S.Diag(TSTLoc, diag::warn_cxx17_compat_unicode_type);"}}

[k]={{F,11232,"/// Checks that the given nested-name qualifier used in a using decl\n/// in the current context is appropriately related to the current\n/// scope.  If an error is found, diagnoses it and returns true.\n/// R is nullptr, if the caller has not (yet) done a lookup, otherwise it\'s the\n/// result of that lookup. UD is likewise nullptr, except when we have an\n/// already-populated UsingDecl whose shadow decls contain the same information\n/// (i.e. we\'re instantiating a UsingDecl with non-dependent scope).\nbool Sema::CheckUsingDeclQualifier(SourceLocation UsingLoc, bool HasTypename, const CXXScopeSpec &SS, const DeclarationNameInfo &NameInfo, SourceLocation NameLoc, const LookupResult *R, const UsingDecl *UD) {\n  if (!CurContext->isRecord()) {\n    Diag(NameLoc, Cxx20Enumerator ? diag::warn_cxx17_compat_using_decl_class_member_enumerator : diag::err_using_decl_can_not_refer_to_class_member) << SS.getRange();"}}

[k]={{F,11299,"/// Checks that the given nested-name qualifier used in a using decl\n/// in the current context is appropriately related to the current\n/// scope.  If an error is found, diagnoses it and returns true.\n/// R is nullptr, if the caller has not (yet) done a lookup, otherwise it\'s the\n/// result of that lookup. UD is likewise nullptr, except when we have an\n/// already-populated UsingDecl whose shadow decls contain the same information\n/// (i.e. we\'re instantiating a UsingDecl with non-dependent scope).\nbool Sema::CheckUsingDeclQualifier(SourceLocation UsingLoc, bool HasTypename, const CXXScopeSpec &SS, const DeclarationNameInfo &NameInfo, SourceLocation NameLoc, const LookupResult *R, const UsingDecl *UD) {\n  // The current scope is a record.\n  if (!NamedContext->isRecord()) {\n    Diag(SS.getBeginLoc(), Cxx20Enumerator ? diag::warn_cxx17_compat_using_decl_non_member_enumerator : diag::err_using_decl_nested_name_specifier_is_not_class) << SS.getScopeRep() << SS.getRange();"},{F,11319,"/// Checks that the given nested-name qualifier used in a using decl\n/// in the current context is appropriately related to the current\n/// scope.  If an error is found, diagnoses it and returns true.\n/// R is nullptr, if the caller has not (yet) done a lookup, otherwise it\'s the\n/// result of that lookup. UD is likewise nullptr, except when we have an\n/// already-populated UsingDecl whose shadow decls contain the same information\n/// (i.e. we\'re instantiating a UsingDecl with non-dependent scope).\nbool Sema::CheckUsingDeclQualifier(SourceLocation UsingLoc, bool HasTypename, const CXXScopeSpec &SS, const DeclarationNameInfo &NameInfo, SourceLocation NameLoc, const LookupResult *R, const UsingDecl *UD) {\n  if (getLangOpts().CPlusPlus11) {\n    if (cast<CXXRecordDecl>(CurContext)->isProvablyNotDerivedFrom(cast<CXXRecordDecl>(NamedContext))) {\n      if (Cxx20Enumerator) {\n        Diag(NameLoc, diag::warn_cxx17_compat_using_decl_non_member_enumerator) << SS.getRange();"}}

[k]={{F,11212,"/// Checks that the given nested-name qualifier used in a using decl\n/// in the current context is appropriately related to the current\n/// scope.  If an error is found, diagnoses it and returns true.\n/// R is nullptr, if the caller has not (yet) done a lookup, otherwise it\'s the\n/// result of that lookup. UD is likewise nullptr, except when we have an\n/// already-populated UsingDecl whose shadow decls contain the same information\n/// (i.e. we\'re instantiating a UsingDecl with non-dependent scope).\nbool Sema::CheckUsingDeclQualifier(SourceLocation UsingLoc, bool HasTypename, const CXXScopeSpec &SS, const DeclarationNameInfo &NameInfo, SourceLocation NameLoc, const LookupResult *R, const UsingDecl *UD) {\n  if (NamedContext) {\n    if (auto *ED = dyn_cast<EnumDecl>(NamedContext)) {\n      // C++14 [namespace.udecl]p7:\n      // A using-declaration shall not name a scoped enumerator.\n      // C++20 p1099 permits enumerators.\n      if (EC && R && ED->isScoped())\n        Diag(SS.getBeginLoc(), getLangOpts().CPlusPlus20 ? diag::warn_cxx17_compat_using_decl_scoped_enumerator : diag::ext_using_decl_scoped_enumerator) << SS.getRange();"}}

[k]={{db,583,"/// Parse a using-declarator (or the identifier in a C++11 alias-declaration).\n///\n///    using-declarator:\n///      \'typename\'[opt] nested-name-specifier unqualified-id\n///\nbool Parser::ParseUsingDeclarator(DeclaratorContext Context, UsingDeclarator &D) {\n  if (TryConsumeToken(tok::ellipsis, D.EllipsisLoc))\n    Diag(Tok.getLocation(), getLangOpts().CPlusPlus17 ? diag::warn_cxx17_compat_using_declaration_pack : diag::ext_using_declaration_pack);"}}

[k]={{db,617,"/// ParseUsingDeclaration - Parse C++ using-declaration or alias-declaration.\n/// Assumes that \'using\' was already seen.\n///\n///    using-declaration: [C++ 7.3.p3: namespace.udecl]\n///      \'using\' using-declarator-list[opt] ;\n///\n///    using-declarator-list: [C++1z]\n///      using-declarator \'...\'[opt]\n///      using-declarator-list \',\' using-declarator \'...\'[opt]\n///\n///    using-declarator-list: [C++98-14]\n///      using-declarator\n///\n///    alias-declaration: C++11 [dcl.dcl]p1\n///      \'using\' identifier attribute-specifier-seq[opt] = type-id ;\n///\n///    using-enum-declaration: [C++20, dcl.enum]\n///      \'using\' elaborated-enum-specifier ;\n///      The terminal name of the elaborated-enum-specifier undergoes\n///      ordinary lookup\n///\n///    elaborated-enum-specifier:\n///      \'enum\' nested-name-specifier[opt] identifier\nParser::DeclGroupPtrTy Parser::ParseUsingDeclaration(DeclaratorContext Context, const ParsedTemplateInfo &TemplateInfo, SourceLocation UsingLoc, SourceLocation &DeclEnd, ParsedAttributes &PrefixAttrs, AccessSpecifier AS) {\n  if (TryConsumeToken(tok::kw_enum, UELoc) && !InInitStatement) {\n    Diag(UELoc, getLangOpts().CPlusPlus20 ? diag::warn_cxx17_compat_using_enum_declaration : diag::ext_using_enum_declaration);"}}

[k]={{Wc,1182,"/// ParseNumberStartingWithZero - This method is called when the first character\n/// of the number is found to be a zero.  This means it is either an octal\n/// number (like \'04\') or a hex number (\'0x123a\') a binary number (\'0b1010\') or\n/// a floating point number (01239.123e4).  Eat the prefix, determining the\n/// radix etc.\nvoid NumericLiteralParser::ParseNumberStartingWithZero(SourceLocation TokLoc) {\n  // Handle a hex number like 0x1234.\n  if ((c1 == \'x\' || c1 == \'X\') && (isHexDigit(s[1]) || s[1] == \'.\')) {\n    // A binary exponent can appear with or with a \'.\'. If dotted, the\n    // binary exponent is required.\n    if (*s == \'p\' || *s == \'P\') {\n      if (!LangOpts.HexFloats)\n      else if (LangOpts.CPlusPlus17)\n        Diags.Report(TokLoc, diag::warn_cxx17_hex_literal);"}}

[k]={{Rb,1812,"Parser::DeclGroupPtrTy Parser::ParseAliasDeclarationInInitStatement(DeclaratorContext Context, ParsedAttributes &Attrs) {\n  Diag(DeclStart, !getLangOpts().CPlusPlus23 ? diag::ext_alias_in_init_statement : diag::warn_cxx20_alias_in_init_statement) << SourceRange(DeclStart, DeclEnd);"}}

[k]={{fb,932,"/// Check whether the range of the initializer \\p ParentIList from element\n/// \\p Index onwards can be used to initialize an object of type \\p T. Update\n/// \\p Index to indicate how many elements of the list were consumed.\n///\n/// This also fills in \\p StructuredList, from element \\p StructuredIndex\n/// onwards, with the fully-braced, desugared form of the initialization.\nvoid InitListChecker::CheckImplicitInitList(const InitializedEntity &Entity, InitListExpr *ParentIList, QualType T, unsigned &Index, InitListExpr *StructuredList, unsigned &StructuredIndex) {\n  if (StructuredSubobjectInitList) {\n    if (!VerifyOnly && CXXRD && CXXRD->hasUserDeclaredConstructor()) {\n      SemaRef.Diag(StructuredSubobjectInitList->getBeginLoc(), diag::warn_cxx20_compat_aggregate_init_with_ctors) << StructuredSubobjectInitList->getSourceRange() << T;"},{fb,1056,"/// Check whether the initializer \\p IList (that was written with explicit\n/// braces) can be used to initialize an object of type \\p T.\n///\n/// This also fills in \\p StructuredList with the fully-braced, desugared\n/// form of the initialization.\nvoid InitListChecker::CheckExplicitInitList(const InitializedEntity &Entity, InitListExpr *IList, QualType &T, InitListExpr *StructuredList, bool TopLevelObject) {\n  if (!VerifyOnly) {\n    if (CXXRD && CXXRD->hasUserDeclaredConstructor()) {\n      if (!HasEquivCtor) {\n        SemaRef.Diag(IList->getBeginLoc(), diag::warn_cxx20_compat_aggregate_init_with_ctors) << IList->getSourceRange() << T;"}}

[k]={{Sb,1342,"ExprResult Sema::BuildCXXTypeConstructExpr(TypeSourceInfo *TInfo, SourceLocation LParenOrBraceLoc, MultiExprArg Exprs, SourceLocation RParenOrBraceLoc, bool ListInitialization) {\n  if (Deduced && !Deduced->isDeduced() && isa<DeducedTemplateSpecializationType>(Deduced)) {\n  } else if (Deduced && !Deduced->isDeduced()) {\n    if (getLangOpts().CPlusPlus23) {\n      if (Ty->getAs<AutoType>())\n        Diag(TyBeginLoc, diag::warn_cxx20_compat_auto_expr) << FullRange;"}}

[k]={{Rb,1127,"static void addConstevalToLambdaDeclSpecifier(Parser &P, SourceLocation ConstevalLoc, DeclSpec &DS) {\n  if (ConstevalLoc.isValid()) {\n    P.Diag(ConstevalLoc, diag::warn_cxx20_compat_consteval);"},{dc,1236,"/// Finish - This does final analysis of the declspec, rejecting things like\n/// \"_Imaginary\" (lacking an FP type). After calling this method, DeclSpec is\n/// guaranteed to be self-consistent, even if an error occurred.\nvoid DeclSpec::Finish(Sema &S, const PrintingPolicy &Policy) {\n  if (getConstexprSpecifier() == ConstexprSpecKind::Constexpr)\n  else if (getConstexprSpecifier() == ConstexprSpecKind::Consteval)\n    S.Diag(ConstexprLoc, diag::warn_cxx20_compat_consteval);"}}

[k]={{Yb,1367,"/// ParseIfStatement\n///      if-statement: [C99 6.8.4.1]\n///        \'if\' \'(\' expression \')\' statement\n///        \'if\' \'(\' expression \')\' statement \'else\' statement\n/// [C++]  \'if\' \'(\' condition \')\' statement\n/// [C++]  \'if\' \'(\' condition \')\' statement \'else\' statement\n/// [C++23] \'if\' \'!\' [opt] consteval compound-statement\n/// [C++23] \'if\' \'!\' [opt] consteval compound-statement \'else\' statement\n///\nStmtResult Parser::ParseIfStatement(SourceLocation *TrailingElseLoc) {\n  if (Tok.is(tok::kw_constexpr)) {\n  } else {\n    if (Tok.is(tok::kw_consteval)) {\n      Diag(Tok, getLangOpts().CPlusPlus23 ? diag::warn_cxx20_compat_consteval_if : diag::ext_consteval_if);"}}

[k]={{F,1945,"/// Check the body for the given constexpr function declaration only contains\n/// the permitted types of statement. C++11 [dcl.constexpr]p3,p4.\n///\n/// \\return true if the body is OK, false if we have found or diagnosed a\n/// problem.\nstatic bool CheckConstexprFunctionBody(Sema &SemaRef, const FunctionDecl *Dcl, Stmt *Body, Sema::CheckConstexprKind Kind) {\n  if (Kind == Sema::CheckConstexprKind::CheckValid) {\n  } else if (Cxx2bLoc.isValid()) {\n    SemaRef.Diag(Cxx2bLoc, SemaRef.getLangOpts().CPlusPlus23 ? diag::warn_cxx20_compat_constexpr_body_invalid_stmt : diag::ext_constexpr_body_invalid_stmt_cxx23) << isa<CXXConstructorDecl>(Dcl);"}}

[k]={{F,1658,"/// Check the given declaration statement is legal within a constexpr function\n/// body. C++11 [dcl.constexpr]p3,p4, and C++1y [dcl.constexpr]p3.\n///\n/// \\return true if the body is OK (maybe only as an extension), false if we\n///        have diagnosed a problem.\nstatic bool CheckConstexprDeclStmt(Sema &SemaRef, const FunctionDecl *Dcl, DeclStmt *DS, SourceLocation &Cxx1yLoc, Sema::CheckConstexprKind Kind) {\n  // C++11 [dcl.constexpr]p3 and p4:\n  //  The definition of a constexpr function(p3) or constructor(p4) [...] shall\n  //  contain only\n  for (const auto *DclIt : DS->decls()) {\n    case Decl::Decomposition: {\n      if (VD->isThisDeclarationADefinition()) {\n        if (VD->isStaticLocal()) {\n          if (Kind == Sema::CheckConstexprKind::Diagnose) {\n            SemaRef.Diag(VD->getLocation(), SemaRef.getLangOpts().CPlusPlus23 ? diag::warn_cxx20_compat_constexpr_var : diag::ext_constexpr_static_var) << isa<CXXConstructorDecl>(Dcl) << (VD->getTLSKind() == VarDecl::TLS_Dynamic);"},{F,1664,"/// Check the given declaration statement is legal within a constexpr function\n/// body. C++11 [dcl.constexpr]p3,p4, and C++1y [dcl.constexpr]p3.\n///\n/// \\return true if the body is OK (maybe only as an extension), false if we\n///        have diagnosed a problem.\nstatic bool CheckConstexprDeclStmt(Sema &SemaRef, const FunctionDecl *Dcl, DeclStmt *DS, SourceLocation &Cxx1yLoc, Sema::CheckConstexprKind Kind) {\n  // C++11 [dcl.constexpr]p3 and p4:\n  //  The definition of a constexpr function(p3) or constructor(p4) [...] shall\n  //  contain only\n  for (const auto *DclIt : DS->decls()) {\n    case Decl::Decomposition: {\n      if (VD->isThisDeclarationADefinition()) {\n        if (SemaRef.LangOpts.CPlusPlus23) {\n          CheckLiteralType(SemaRef, Kind, VD->getLocation(), VD->getType(), diag::warn_cxx20_compat_constexpr_var, isa<CXXConstructorDecl>(Dcl),"}}

[k]={{dc,1238,"/// Finish - This does final analysis of the declspec, rejecting things like\n/// \"_Imaginary\" (lacking an FP type). After calling this method, DeclSpec is\n/// guaranteed to be self-consistent, even if an error occurred.\nvoid DeclSpec::Finish(Sema &S, const PrintingPolicy &Policy) {\n  if (getConstexprSpecifier() == ConstexprSpecKind::Constexpr)\n  else if (getConstexprSpecifier() == ConstexprSpecKind::Consteval)\n  else if (getConstexprSpecifier() == ConstexprSpecKind::Constinit)\n    S.Diag(ConstexprLoc, diag::warn_cxx20_compat_constinit);"}}

[k]={{Rb,1232,"/// ParseLambdaExpressionAfterIntroducer - Parse the rest of a lambda\n/// expression.\nExprResult Parser::ParseLambdaExpressionAfterIntroducer(LambdaIntroducer &Intro) {\n  // Implement WG21 P2173, which allows attributes immediately before the\n  // lambda declarator and applies them to the corresponding function operator\n  // or operator template declaration. We accept this as a conforming extension\n  // in all language modes that support lambdas.\n  if (isCXX11AttributeSpecifier()) {\n    Diag(Tok, getLangOpts().CPlusPlus23 ? diag::warn_cxx20_compat_decl_attrs_on_lambda : diag::ext_decl_attrs_on_lambda) << Tok.getIdentifierInfo() << Tok.isRegularKeywordAttribute();"}}

[k]={{Mb,3678,"/// ParseDeclarationSpecifiers\n///      declaration-specifiers: [C99 6.7]\n///        storage-class-specifier declaration-specifiers[opt]\n///        type-specifier declaration-specifiers[opt]\n/// [C99]  function-specifier declaration-specifiers[opt]\n/// [C11]  alignment-specifier declaration-specifiers[opt]\n/// [GNU]  attributes declaration-specifiers[opt]\n/// [Clang] \'__module_private__\' declaration-specifiers[opt]\n/// [ObjC1] \'__kindof\' declaration-specifiers[opt]\n///\n///      storage-class-specifier: [C99 6.7.1]\n///        \'typedef\'\n///        \'extern\'\n///        \'static\'\n///        \'auto\'\n///        \'register\'\n/// [C++]  \'mutable\'\n/// [C++11] \'thread_local\'\n/// [C11]  \'_Thread_local\'\n/// [GNU]  \'__thread\'\n///      function-specifier: [C99 6.7.4]\n/// [C99]  \'inline\'\n/// [C++]  \'virtual\'\n/// [C++]  \'explicit\'\n/// [OpenCL] \'__kernel\'\n///      \'friend\': [C++ dcl.friend]\n///      \'constexpr\': [C++0x dcl.constexpr]\nvoid Parser::ParseDeclarationSpecifiers(DeclSpec &DS, const ParsedTemplateInfo &TemplateInfo, AccessSpecifier AS, DeclSpecContext DSContext, LateParsedAttrList *LateAttrs, ImplicitTypenameContext AllowImplicitTypename) {\n  while (true) {\n    case tok::kw_explicit: {\n      if (Tok.is(tok::l_paren)) {\n        if (getLangOpts().CPlusPlus20 || isExplicitBool() == TPResult::True) {\n        } else {\n          Diag(Tok.getLocation(), diag::warn_cxx20_compat_explicit_bool);"}}

[k]={{Yb,1010,"void Parser::DiagnoseLabelAtEndOfCompoundStatement() {\n  if (getLangOpts().CPlusPlus) {\n    Diag(Tok, getLangOpts().CPlusPlus23 ? diag::warn_cxx20_compat_label_end_of_compound_statement : diag::ext_cxx_label_end_of_compound_statement);"}}

[k]={{F,13791,"/// CheckOverloadedOperatorDeclaration - Check whether the declaration\n/// of this overloaded operator is well-formed. If so, returns false;\n/// otherwise, emits appropriate diagnostics and returns true.\nbool Sema::CheckOverloadedOperatorDeclaration(FunctionDecl *FnDecl) {\n  // C++ [over.oper]p7:\n  //  An operator function shall either be a member function or\n  //  be a non-member function and have at least one parameter\n  //  whose type is a class, a reference to a class, an enumeration,\n  //  or a reference to an enumeration.\n  // Note: Before C++23, a member function could not be static. The only member\n  //      function allowed to be static is the call operator function.\n  if (CXXMethodDecl *MethodDecl = dyn_cast<CXXMethodDecl>(FnDecl)) {\n    if (MethodDecl->isStatic()) {\n      if (Op == OO_Call || Op == OO_Subscript)\n        Diag(FnDecl->getLocation(), (LangOpts.CPlusPlus23 ? diag::warn_cxx20_compat_operator_overload_static : diag::ext_operator_overload_static)) << FnDecl;"}}

[k]={{"clang/lib/Lex/PPExpressions.cpp",310,"/// EvaluateValue - Evaluate the token PeekTok (and any others needed) and\n/// return the computed value in Result.  Return true if there was an error\n/// parsing.  This function also returns information about the form of the\n/// expression in DT.  See above for information on what DT means.\n///\n/// If ValueLive is false, then this value is being evaluated in a context where\n/// the result is not used.  As such, avoid diagnostics that relate to\n/// evaluation.\nstatic bool EvaluateValue(PPValue &Result, Token &PeekTok, DefinedTracker &DT, bool ValueLive, Preprocessor &PP) {\n  case tok::numeric_constant: {\n    // \'z/uz\' literals are a C++23 feature.\n    if (Literal.isSizeT)\n      PP.Diag(PeekTok, PP.getLangOpts().CPlusPlus ? PP.getLangOpts().CPlusPlus23 ? diag::warn_cxx20_compat_size_t_suffix : diag::ext_cxx23_size_t_suffix : diag::err_cxx23_size_t_suffix);"},{M,3546,"ExprResult Sema::ActOnNumericConstant(const Token &Tok, Scope *UDLScope) {\n  if (Literal.isFixedPointLiteral()) {\n  } else if (Literal.isFloatingLiteral()) {\n  } else if (!Literal.isIntegerLiteral()) {\n  } else {\n    // \'z/uz\' literals are a C++23 feature.\n    if (Literal.isSizeT)\n      Diag(Tok.getLocation(), getLangOpts().CPlusPlus ? getLangOpts().CPlusPlus23 ? diag::warn_cxx20_compat_size_t_suffix : diag::ext_cxx23_size_t_suffix : diag::err_cxx23_size_t_suffix);"}}

[k]={{vb,3860,"LexStart:\n  case \'<\':\n    if (ParsingFilename) {\n    } else if (Char == \'<\') {\n    } else if (Char == \'=\') {\n      if (After == \'>\') {\n        // Suggest adding a space between the \'<=\' and the \'>\' to avoid a\n        // change in semantics if this turns up in C++ <=17 mode.\n        if (LangOpts.CPlusPlus && !isLexingRawMode()) {\n          Diag(BufferPtr, diag::warn_cxx20_compat_spaceship) << FixItHint::CreateInsertion(getSourceLocation(CurPtr + SizeTmp, SizeTmp2), \" \");"}}

[k]={{Rb,1107,"static void addStaticToLambdaDeclSpecifier(Parser &P, SourceLocation StaticLoc, DeclSpec &DS) {\n  if (StaticLoc.isValid()) {\n    P.Diag(StaticLoc, !P.getLangOpts().CPlusPlus23 ? diag::err_static_lambda : diag::warn_cxx20_compat_static_lambda);"}}

[k]={{M,18795,"/// Check for operands with placeholder types and complain if found.\n/// Returns ExprError() if there was an error and no recovery was possible.\nExprResult Sema::CheckPlaceholderExpr(Expr *E) {\n  case BuiltinType::BuiltinFn: {\n    if (DRE) {\n      if (Context.BuiltinInfo.isInStdNamespace(BuiltinID)) {\n        Diag(E->getBeginLoc(), getLangOpts().CPlusPlus20 ? diag::err_use_of_unaddressable_function : diag::warn_cxx20_compat_use_of_unaddressable_function);"}}

[k]={{M,1709,"/// ActOnStringLiteral - The specified tokens were lexed as pasted string\n/// fragments (e.g. \"foo\" \"bar\" L\"baz\").  The result string has to handle string\n/// concatenation ([C99 5.1.1.2, translation phase #6]), so it may come from\n/// multiple tokens.  However, the common case is that StringToks points to one\n/// string.\n///\nExprResult Sema::ActOnStringLiteral(ArrayRef<Token> StringToks, Scope *UDLScope) {\n  // Warn on initializing an array of char from a u8 string literal; this\n  // becomes ill-formed in C++2a.\n  if (getLangOpts().CPlusPlus && !getLangOpts().CPlusPlus20 && !getLangOpts().Char8 && Kind == StringLiteral::UTF8) {\n    Diag(StringTokLocs.front(), diag::warn_cxx20_compat_utf8_string);"}}

[k]={{"clang/lib/Basic/IdentifierTable.cpp",876,"#include \"clang/Basic/TokenKinds.def\"\n  if (LangOpts.CPlusPlus) {\n    // char8_t is not modeled as a CXX20_KEYWORD because it\'s not\n    // unconditionally enabled in C++20 mode. (It can be disabled\n    // by -fno-char8_t.)\n    if (((Flags & KEYCXX20) == KEYCXX20) || ((Flags & CHAR8SUPPORT) == CHAR8SUPPORT))\n      return diag::warn_cxx20_keyword;"}}

[k]={{F,7634,"bool Sema::CheckExplicitlyDefaultedComparison(Scope *S, FunctionDecl *FD, DefaultedComparisonKind DCK) {\n  // C++2a [dcl.fct.def.default]p3 [P2002R0]:\n  //  An explicitly-defaulted function that is not defined as deleted may be\n  //  declared constexpr or consteval only if it is constexpr-compatible.\n  // C++2a [class.compare.default]p3 [P2002R0]:\n  //  A defaulted comparison function is constexpr-compatible if it satisfies\n  //  the requirements for a constexpr function [...]\n  // The only relevant requirements are that the parameter and return types are\n  // literal types. The remaining conditions are checked by the analyzer.\n  //\n  // We support P2448R2 in language modes earlier than C++23 as an extension.\n  // The concept of constexpr-compatible was removed.\n  // C++23 [dcl.fct.def.default]p3 [P2448R2]\n  //  A function explicitly defaulted on its first declaration is implicitly\n  //  inline, and is implicitly constexpr if it is constexpr-suitable.\n  // C++23 [dcl.constexpr]p3\n  //  A function is constexpr-suitable if\n  //    - it is not a coroutine, and\n  //    - if the function is a constructor or destructor, its class does not\n  //      have any virtual base classes.\n  if (FD->isConstexpr()) {\n    if (CheckConstexprReturnType(*this, FD, CheckConstexprKind::Diagnose) && CheckConstexprParameterTypes(*this, FD, CheckConstexprKind::Diagnose) && !Info.Constexpr) {\n      Diag(FD->getBeginLoc(), getLangOpts().CPlusPlus23 ? diag::warn_cxx23_compat_defaulted_comparison_constexpr_mismatch : diag::ext_defaulted_comparison_constexpr_mismatch) << FD->isImplicit() << (int)DCK << FD->isConsteval();"}}

[k]={{pd,700,"/// SkipExcludedConditionalBlock - We just read a \\#if or related directive and\n/// decided that the subsequent tokens are in the \\#if\'d out portion of the\n/// file.  Lex the rest of the file, until we see an \\#endif.  If\n/// FoundNonSkipPortion is true, then we have already emitted code for part of\n/// this \\#if directive, so \\#else/\\#elif blocks should never be entered.\n/// If ElseOk is true, then \\#else directives are ok, if not, then we have\n/// already seen one so a \\#else directive is a duplicate.  When this returns,\n/// the caller can lex the first valid token.\nvoid Preprocessor::SkipExcludedConditionalBlock(SourceLocation HashTokenLoc, SourceLocation IfTokenLoc, bool FoundNonSkipPortion, bool FoundElse, SourceLocation ElseLoc) {\n  while (true) {\n    if (Directive.startswith(\"if\")) {\n    } else if (Directive[0] == \'e\') {\n      if (Sub == \"ndif\") { // \"endif\"\n      } else if (Sub == \"lse\") { // \"else\".\n      } else if (Sub == \"lif\") { // \"elif\".\n      } else if (Sub == \"lifdef\" ||  // \"elifdef\"\n        if (LangOpts.CPlusPlus)\n          DiagID = LangOpts.CPlusPlus23 ? diag::warn_cxx23_compat_pp_directive : diag::ext_cxx23_pp_directive;"},{pd,3162,"/// Implements the \\#elif, \\#elifdef, and \\#elifndef directives.\nvoid Preprocessor::HandleElifFamilyDirective(Token &ElifToken, const Token &HashToken, tok::PPKeywordKind Kind) {\n  case PED_Elifndef:\n    if (LangOpts.CPlusPlus)\n      DiagID = LangOpts.CPlusPlus23 ? diag::warn_cxx23_compat_pp_directive : diag::ext_cxx23_pp_directive;"}}

[k]={{pd,1159,"/// HandleDirective - This callback is invoked when the lexer sees a # token\n/// at the start of a line.  This consumes the directive, modifies the\n/// lexer/preprocessor state, and advances the lexer(s) so that the next token\n/// read is the correct one.\nvoid Preprocessor::HandleDirective(Token &Result) {\n  default:\n    case tok::pp_warning:\n      if (LangOpts.CPlusPlus)\n        Diag(Result, LangOpts.CPlusPlus23 ? diag::warn_cxx23_compat_warning_directive : diag::ext_pp_warning_directive) << /*C++23*/ 1;"}}

[k]={{vb,3099,"std::optional<uint32_t> Lexer::tryReadNumericUCN(const char *&StartPtr, const char *SlashLoc, Token *Result) {\n  if (Delimited && PP) {\n    Diag(SlashLoc, PP->getLangOpts().CPlusPlus23 ? diag::warn_cxx23_delimited_escape_sequence : diag::ext_delimited_escape_sequence) << /*delimited*/ 0 << (PP->getLangOpts().CPlusPlus ? 1 : 0);"},{vb,3174,"std::optional<uint32_t> Lexer::tryReadNamedUCN(const char *&StartPtr, const char *SlashLoc, Token *Result) {\n  if (Diagnose && Match)\n    Diag(SlashLoc, PP->getLangOpts().CPlusPlus23 ? diag::warn_cxx23_delimited_escape_sequence : diag::ext_delimited_escape_sequence) << /*named*/ 1 << (PP->getLangOpts().CPlusPlus ? 1 : 0);"},{Wc,322,"/// ProcessCharEscape - Parse a standard C escape sequence, which can occur in\n/// either a character or a string literal.\nstatic unsigned ProcessCharEscape(const char *ThisTokBegin, const char *&ThisTokBuf, const char *ThisTokEnd, bool &HadError, FullSourceLoc Loc, unsigned CharWidth, DiagnosticsEngine *Diags, const LangOptions &Features, StringLiteralEvalMethod EvalMethod) {\n  if (Delimited && Diags) {\n    if (!EndDelimiterFound)\n    else if (!HadError) {\n      Diag(Diags, Features, Loc, ThisTokBegin, EscapeBegin, ThisTokBuf, Features.CPlusPlus23 ? diag::warn_cxx23_delimited_escape_sequence : diag::ext_delimited_escape_sequence) << /*delimited*/ 0 << (Features.CPlusPlus ? 1 : 0);"},{Wc,585,"/// ProcessUCNEscape - Read the Universal Character Name, check constraints and\n/// return the UTF32.\nstatic bool ProcessUCNEscape(const char *ThisTokBegin, const char *&ThisTokBuf, const char *ThisTokEnd, uint32_t &UcnVal, unsigned short &UcnLen, FullSourceLoc Loc, DiagnosticsEngine *Diags, const LangOptions &Features, bool in_char_string_literal = false) {\n  if ((IsDelimitedEscapeSequence || IsNamedEscapeSequence) && Diags)\n    Diag(Diags, Features, Loc, ThisTokBegin, UcnBegin, ThisTokBuf, Features.CPlusPlus23 ? diag::warn_cxx23_delimited_escape_sequence : diag::ext_delimited_escape_sequence) << (IsNamedEscapeSequence ? 1 : 0) << (Features.CPlusPlus ? 1 : 0);"}}

[k]={{db,766,"Decl *Parser::ParseAliasDeclarationAfterDeclarator(const ParsedTemplateInfo &TemplateInfo, SourceLocation UsingLoc, UsingDeclarator &D, SourceLocation &DeclEnd, AccessSpecifier AS, ParsedAttributes &Attrs, Decl **OwnedType) {\n  Diag(Tok.getLocation(), getLangOpts().CPlusPlus11 ? diag::warn_cxx98_compat_alias_declaration : diag::ext_alias_declaration);"}}

[k]={{db,3926,"/// Parse a C++11 or C2x attribute-specifier.\n///\n/// [C++11] attribute-specifier:\n///        \'[\' \'[\' attribute-list \']\' \']\'\n///        alignment-specifier\n///\n/// [C++11] attribute-list:\n///        attribute[opt]\n///        attribute-list \',\' attribute[opt]\n///        attribute \'...\'\n///        attribute-list \',\' attribute \'...\'\n///\n/// [C++11] attribute:\n///        attribute-token attribute-argument-clause[opt]\n///\n/// [C++11] attribute-token:\n///        identifier\n///        attribute-scoped-token\n///\n/// [C++11] attribute-scoped-token:\n///        attribute-namespace \'::\' identifier\n///\n/// [C++11] attribute-namespace:\n///        identifier\nvoid Parser::ParseCXX11AttributeSpecifierInternal(ParsedAttributes &Attrs, CachedTokens &OpenMPTokens, SourceLocation *EndLoc) {\n  if (Tok.is(tok::kw_alignas)) {\n    if (getLangOpts().C2x)\n    else\n      Diag(Tok.getLocation(), diag::warn_cxx98_compat_alignas);"}}

[k]={{qc,2252,"/// Parse a sizeof or alignof expression.\n///\n/// \\verbatim\n///      unary-expression:  [C99 6.5.3]\n///        \'sizeof\' unary-expression\n///        \'sizeof\' \'(\' type-name \')\'\n/// [C++11] \'sizeof\' \'...\' \'(\' identifier \')\'\n/// [GNU]  \'__alignof\' unary-expression\n/// [GNU]  \'__alignof\' \'(\' type-name \')\'\n/// [C11]  \'_Alignof\' \'(\' type-name \')\'\n/// [C++11] \'alignof\' \'(\' type-id \')\'\n/// \\endverbatim\nExprResult Parser::ParseUnaryExprOrTypeTraitExpression() {\n  if (getLangOpts().CPlusPlus && OpTok.isOneOf(tok::kw_alignof, tok::kw__Alignof))\n    Diag(OpTok, diag::warn_cxx98_compat_alignof);"}}

[k]={{Sb,1845,"ExprResult Sema::BuildCXXNew(SourceRange Range, bool UseGlobal, SourceLocation PlacementLParen, MultiExprArg PlacementArgs, SourceLocation PlacementRParen, SourceRange TypeIdParens, QualType AllocType, TypeSourceInfo *AllocTypeInfo, std::optional<Expr *> ArraySize, SourceRange DirectInitRange, Expr *Initializer) {\n  if (ArraySize && *ArraySize && !(*ArraySize)->isTypeDependent()) {\n    if (getLangOpts().CPlusPlus14) {\n      if (!ConvertedSize.isInvalid() && (*ArraySize)->getType()->getAs<RecordType>())\n        Diag(StartLoc, diag::warn_cxx98_compat_array_size_conversion) << (*ArraySize)->getType() << 0 << \"\'size_t\'\";"},{Sb,1866,"ExprResult Sema::BuildCXXNew(SourceRange Range, bool UseGlobal, SourceLocation PlacementLParen, MultiExprArg PlacementArgs, SourceLocation PlacementRParen, SourceRange TypeIdParens, QualType AllocType, TypeSourceInfo *AllocTypeInfo, std::optional<Expr *> ArraySize, SourceRange DirectInitRange, Expr *Initializer) {\n  if (ArraySize && *ArraySize && !(*ArraySize)->isTypeDependent()) {\n    if (getLangOpts().CPlusPlus14) {\n    } else {\n      class SizeConvertDiagnoser : public ICEConvertDiagnoser {\n        SemaDiagnosticBuilder diagnoseConversion(Sema &S, SourceLocation Loc, QualType T, QualType ConvTy) override { return S.Diag(Loc, S.getLangOpts().CPlusPlus11 ? diag::warn_cxx98_compat_array_size_conversion : diag::ext_array_size_conversion) << T << ConvTy->isEnumeralType() << ConvTy; }"}}

[k]={{db,3943,"/// Parse a C++11 or C2x attribute-specifier.\n///\n/// [C++11] attribute-specifier:\n///        \'[\' \'[\' attribute-list \']\' \']\'\n///        alignment-specifier\n///\n/// [C++11] attribute-list:\n///        attribute[opt]\n///        attribute-list \',\' attribute[opt]\n///        attribute \'...\'\n///        attribute-list \',\' attribute \'...\'\n///\n/// [C++11] attribute:\n///        attribute-token attribute-argument-clause[opt]\n///\n/// [C++11] attribute-token:\n///        identifier\n///        attribute-scoped-token\n///\n/// [C++11] attribute-scoped-token:\n///        attribute-namespace \'::\' identifier\n///\n/// [C++11] attribute-namespace:\n///        identifier\nvoid Parser::ParseCXX11AttributeSpecifierInternal(ParsedAttributes &Attrs, CachedTokens &OpenMPTokens, SourceLocation *EndLoc) {\n  if (getLangOpts().CPlusPlus) {\n    Diag(OpenLoc, getLangOpts().CPlusPlus11 ? diag::warn_cxx98_compat_attribute : diag::warn_ext_cxx11_attributes);"}}

[k]={{Cb,3286,"static QualType GetDeclSpecTypeForDeclarator(TypeProcessingState &state, TypeSourceInfo *&ReturnTypeInfo) {\n  // C++11 [dcl.spec.auto]p5: reject \'auto\' if it is not in an allowed context.\n  if (Deduced) {\n    if (Error != -1) {\n    } else if (Auto && D.getContext() != DeclaratorContext::LambdaExpr) {\n      SemaRef.Diag(AutoRange.getBegin(), D.getContext() == DeclaratorContext::LambdaExprParameter ? diag::warn_cxx11_compat_generic_lambda : IsDeducedReturnType ? diag::warn_cxx11_compat_deduced_return_type : diag::warn_cxx98_compat_auto_type_specifier) << AutoRange;"}}

[k]={{"clang/lib/Sema/SemaCast.cpp",2216,"static TryCastResult TryReinterpretCast(Sema &Self, ExprResult &SrcExpr, QualType DestType, bool CStyle, SourceRange OpRange, unsigned &msg, CastKind &Kind) {\n  if (SrcType->isFunctionPointerType()) {\n    Self.Diag(OpRange.getBegin(), Self.getLangOpts().CPlusPlus11 ? diag::warn_cxx98_compat_cast_fn_obj : diag::ext_cast_fn_obj) << OpRange;"},{"clang/lib/Sema/SemaCast.cpp",2222,"static TryCastResult TryReinterpretCast(Sema &Self, ExprResult &SrcExpr, QualType DestType, bool CStyle, SourceRange OpRange, unsigned &msg, CastKind &Kind) {\n  if (DestType->isFunctionPointerType()) {\n    Self.Diag(OpRange.getBegin(), Self.getLangOpts().CPlusPlus11 ? diag::warn_cxx98_compat_cast_fn_obj : diag::ext_cast_fn_obj) << OpRange;"}}

[k]={{dc,1234,"/// Finish - This does final analysis of the declspec, rejecting things like\n/// \"_Imaginary\" (lacking an FP type). After calling this method, DeclSpec is\n/// guaranteed to be self-consistent, even if an error occurred.\nvoid DeclSpec::Finish(Sema &S, const PrintingPolicy &Policy) {\n  if (getConstexprSpecifier() == ConstexprSpecKind::Constexpr)\n    S.Diag(ConstexprLoc, diag::warn_cxx98_compat_constexpr);"}}

[k]={{fb,7709,"ExprResult InitializationSequence::Perform(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, MultiExprArg Args, QualType *ResultType) {\n  for (step_iterator Step = step_begin(), StepEnd = step_end(); Step != StepEnd; ++Step) {\n    case SK_ConstructorInitializationFromList: {\n      S.Diag(InitList->getExprLoc(), diag::warn_cxx98_compat_ctor_list_init) << InitList->getSourceRange();"}}

[k]={{db,945,"/// ParseDecltypeSpecifier - Parse a C++11 decltype specifier.\n///\n/// \'decltype\' ( expression )\n/// \'decltype\' ( \'auto\' )      [C++1y]\n///\nSourceLocation Parser::ParseDecltypeSpecifier(DeclSpec &DS) {\n  if (Tok.is(tok::annot_decltype)) {\n  } else {\n    if (Tok.getIdentifierInfo()->isStr(\"decltype\"))\n      Diag(Tok, diag::warn_cxx98_compat_decltype);"}}

[k]={{"clang/lib/Parse/ParseCXXInlineMethods.cpp",59,"/// ParseCXXInlineMethodDef - We parsed and verified that the specified\n/// Declarator is a well formed C++ inline method definition. Now lex its body\n/// and store its tokens for parsing after the C++ class is complete.\nNamedDecl *Parser::ParseCXXInlineMethodDef(AccessSpecifier AS, const ParsedAttributesView &AccessAttrs, ParsingDeclarator &D, const ParsedTemplateInfo &TemplateInfo, const VirtSpecifiers &VS, SourceLocation PureSpecLoc) {\n  if (TryConsumeToken(tok::equal)) {\n    if (TryConsumeToken(tok::kw_delete, KWLoc)) {\n      Diag(KWLoc, getLangOpts().CPlusPlus11 ? diag::warn_cxx98_compat_defaulted_deleted_function : diag::ext_defaulted_deleted_function) << 1 /* deleted */;"},{"clang/lib/Parse/ParseCXXInlineMethods.cpp",66,"/// ParseCXXInlineMethodDef - We parsed and verified that the specified\n/// Declarator is a well formed C++ inline method definition. Now lex its body\n/// and store its tokens for parsing after the C++ class is complete.\nNamedDecl *Parser::ParseCXXInlineMethodDef(AccessSpecifier AS, const ParsedAttributesView &AccessAttrs, ParsingDeclarator &D, const ParsedTemplateInfo &TemplateInfo, const VirtSpecifiers &VS, SourceLocation PureSpecLoc) {\n  if (TryConsumeToken(tok::equal)) {\n    if (TryConsumeToken(tok::kw_delete, KWLoc)) {\n    } else if (TryConsumeToken(tok::kw_default, KWLoc)) {\n      Diag(KWLoc, getLangOpts().CPlusPlus11 ? diag::warn_cxx98_compat_defaulted_deleted_function : diag::ext_defaulted_deleted_function) << 0 /* defaulted */;"},{tc,1247,"/// ParseFunctionDefinition - We parsed and verified that the specified\n/// Declarator is well formed.  If this is a K&R-style function, read the\n/// parameters declaration-list, then start the compound-statement.\n///\n///      function-definition: [C99 6.9.1]\n///        decl-specs      declarator declaration-list[opt] compound-statement\n/// [C90] function-definition: [C99 6.7.1] - implicit int result\n/// [C90]  decl-specs[opt] declarator declaration-list[opt] compound-statement\n/// [C++] function-definition: [C++ 8.4]\n///        decl-specifier-seq[opt] declarator ctor-initializer[opt]\n///        function-body\n/// [C++] function-definition: [C++ 8.4]\n///        decl-specifier-seq[opt] declarator function-try-block\n///\nDecl *Parser::ParseFunctionDefinition(ParsingDeclarator &D, const ParsedTemplateInfo &TemplateInfo, LateParsedAttrList *LateParsedAttrs) {\n  if (TryConsumeToken(tok::equal)) {\n    if (TryConsumeToken(tok::kw_delete, KWLoc)) {\n      Diag(KWLoc, getLangOpts().CPlusPlus11 ? diag::warn_cxx98_compat_defaulted_deleted_function : diag::ext_defaulted_deleted_function) << 1 /* deleted */;"},{tc,1250,"/// ParseFunctionDefinition - We parsed and verified that the specified\n/// Declarator is well formed.  If this is a K&R-style function, read the\n/// parameters declaration-list, then start the compound-statement.\n///\n///      function-definition: [C99 6.9.1]\n///        decl-specs      declarator declaration-list[opt] compound-statement\n/// [C90] function-definition: [C99 6.7.1] - implicit int result\n/// [C90]  decl-specs[opt] declarator declaration-list[opt] compound-statement\n/// [C++] function-definition: [C++ 8.4]\n///        decl-specifier-seq[opt] declarator ctor-initializer[opt]\n///        function-body\n/// [C++] function-definition: [C++ 8.4]\n///        decl-specifier-seq[opt] declarator function-try-block\n///\nDecl *Parser::ParseFunctionDefinition(ParsingDeclarator &D, const ParsedTemplateInfo &TemplateInfo, LateParsedAttrList *LateParsedAttrs) {\n  if (TryConsumeToken(tok::equal)) {\n    if (TryConsumeToken(tok::kw_delete, KWLoc)) {\n    } else if (TryConsumeToken(tok::kw_default, KWLoc)) {\n      Diag(KWLoc, getLangOpts().CPlusPlus11 ? diag::warn_cxx98_compat_defaulted_deleted_function : diag::ext_defaulted_deleted_function) << 0 /* defaulted */;"}}

[k]={{F,3931,"MemInitResult Sema::BuildDelegatingInitializer(TypeSourceInfo *TInfo, Expr *Init, CXXRecordDecl *ClassDecl) {\n  Diag(NameLoc, diag::warn_cxx98_compat_delegating_ctor);"}}

[k]={{"clang/lib/Lex/PPMacroExpansion.cpp",851,"/// ReadFunctionLikeMacroArgs - After reading \"MACRO\" and knowing that the next\n/// token is the \'(\' of the macro, this method is invoked to read all of the\n/// actual arguments specified for the macro invocation.  This returns null on\n/// error.\nMacroArgs *Preprocessor::ReadMacroCallArgumentList(Token &MacroName, MacroInfo *MI, SourceLocation &MacroEnd) {\n  while (Tok.isNot(tok::r_paren)) {\n    // Empty arguments are standard in C99 and C++0x, and are supported as an\n    // extension in other modes.\n    if (ArgTokens.size() == ArgTokenStart && !getLangOpts().C99)\n      Diag(Tok, getLangOpts().CPlusPlus11 ? diag::warn_cxx98_compat_empty_fnmacro_arg : diag::ext_empty_fnmacro_arg);"}}

[k]={{fb,1306,"void InitListChecker::CheckScalarType(const InitializedEntity &Entity, InitListExpr *IList, QualType DeclType, unsigned &Index, InitListExpr *StructuredList, unsigned &StructuredIndex) {\n  if (Index >= IList->getNumInits()) {\n    if (!VerifyOnly) {\n      if (SemaRef.getLangOpts().CPlusPlus) {\n        if (DeclType->isSizelessBuiltinType())\n        else\n          SemaRef.Diag(IList->getBeginLoc(), SemaRef.getLangOpts().CPlusPlus11 ? diag::warn_cxx98_compat_empty_scalar_initializer : diag::err_empty_scalar_initializer) << IList->getSourceRange();"}}

[k]={{fb,1304,"void InitListChecker::CheckScalarType(const InitializedEntity &Entity, InitListExpr *IList, QualType DeclType, unsigned &Index, InitListExpr *StructuredList, unsigned &StructuredIndex) {\n  if (Index >= IList->getNumInits()) {\n    if (!VerifyOnly) {\n      if (SemaRef.getLangOpts().CPlusPlus) {\n        if (DeclType->isSizelessBuiltinType())\n          SemaRef.Diag(IList->getBeginLoc(), SemaRef.getLangOpts().CPlusPlus11 ? diag::warn_cxx98_compat_empty_sizeless_initializer : diag::err_empty_sizeless_initializer) << DeclType << IList->getSourceRange();"}}

[k]={{Mb,4479,"/// ParseEnumSpecifier\n///      enum-specifier: [C99 6.7.2.2]\n///        \'enum\' identifier[opt] \'{\' enumerator-list \'}\'\n///[C99/C++]\'enum\' identifier[opt] \'{\' enumerator-list \',\' \'}\'\n/// [GNU]  \'enum\' attributes[opt] identifier[opt] \'{\' enumerator-list \',\' [opt]\n///                                                \'}\' attributes[opt]\n/// [MS]    \'enum\' __declspec[opt] identifier[opt] \'{\' enumerator-list \',\' [opt]\n///                                                \'}\'\n///        \'enum\' identifier\n/// [GNU]  \'enum\' attributes[opt] identifier\n///\n/// [C++11] enum-head \'{\' enumerator-list[opt] \'}\'\n/// [C++11] enum-head \'{\' enumerator-list \',\'  \'}\'\n///\n///      enum-head: [C++11]\n///        enum-key attribute-specifier-seq[opt] identifier[opt] enum-base[opt]\n///        enum-key attribute-specifier-seq[opt] nested-name-specifier\n///            identifier enum-base[opt]\n///\n///      enum-key: [C++11]\n///        \'enum\'\n///        \'enum\' \'class\'\n///        \'enum\' \'struct\'\n///\n///      enum-base: [C++11]\n///        \':\' type-specifier-seq\n///\n/// [C++] elaborated-type-specifier:\n/// [C++]  \'enum\' nested-name-specifier[opt] identifier\n///\nvoid Parser::ParseEnumSpecifier(SourceLocation StartLoc, DeclSpec &DS, const ParsedTemplateInfo &TemplateInfo, AccessSpecifier AS, DeclSpecContext DSC) {\n  // Parse the fixed underlying type.\n  if (Tok.is(tok::colon)) {\n    if (CanBeBitfield && !isEnumBase(CanBeOpaqueEnumDeclaration)) {\n    } else if (CanHaveEnumBase || !ColonIsSacred) {\n      if (!getLangOpts().ObjC) {\n        if (getLangOpts().CPlusPlus11)\n          Diag(ColonLoc, diag::warn_cxx98_compat_enum_fixed_underlying_type) << BaseRange;"}}

[k]={{F,14673,"/// Perform semantic analysis of the given friend type declaration.\n///\n/// \\returns A friend declaration that.\nFriendDecl *Sema::CheckFriendTypeDecl(SourceLocation LocStart, SourceLocation FriendLoc, TypeSourceInfo *TSInfo) {\n  // C++03 [class.friend]p2:\n  //  An elaborated-type-specifier shall be used in a friend declaration\n  //  for a class.*\n  //\n  //  * The class-key of the elaborated-type-specifier is required.\n  if (!CodeSynthesisContexts.empty()) {\n  } else {\n    if (!T->isElaboratedTypeSpecifier()) {\n    } else if (T->getAs<EnumType>()) {\n      Diag(FriendLoc, getLangOpts().CPlusPlus11 ? diag::warn_cxx98_compat_enum_friend : diag::ext_enum_friend) << T << TypeRange;"}}

[k]={{"clang/lib/Sema/SemaCXXScopeSpec.cpp",648,"/// Build a new nested-name-specifier for \"identifier::\", as described\n/// by ActOnCXXNestedNameSpecifier.\n///\n/// \\param S Scope in which the nested-name-specifier occurs.\n/// \\param IdInfo Parser information about an identifier in the\n///        nested-name-spec.\n/// \\param EnteringContext If true, enter the context specified by the\n///        nested-name-specifier.\n/// \\param SS Optional nested name specifier preceding the identifier.\n/// \\param ScopeLookupResult Provides the result of name lookup within the\n///        scope of the nested-name-specifier that was computed at template\n///        definition time.\n/// \\param ErrorRecoveryLookup Specifies if the method is called to improve\n///        error recovery and what kind of recovery is performed.\n/// \\param IsCorrectedToColon If not null, suggestion of replace \'::\' -> \':\'\n///        are allowed.  The bool value pointed by this parameter is set to\n///      \'true\' if the identifier is treated as if it was followed by \':\',\n///        not \'::\'.\n/// \\param OnlyNamespace If true, only considers namespaces in lookup.\n///\n/// This routine differs only slightly from ActOnCXXNestedNameSpecifier, in\n/// that it contains an extra parameter \\p ScopeLookupResult, which provides\n/// the result of name lookup within the scope of the nested-name-specifier\n/// that was computed at template definition time.\n///\n/// If ErrorRecoveryLookup is true, then this call is used to improve error\n/// recovery.  This means that it should not emit diagnostics, it should\n/// just return true on failure.  It also means it should only return a valid\n/// scope if it *knows* that the result is correct.  It should not return in a\n/// dependent context, for example. Nor will it extend \\p SS with the scope\n/// specifier.\nbool Sema::BuildCXXNestedNameSpecifier(Scope *S, NestedNameSpecInfo &IdInfo, bool EnteringContext, CXXScopeSpec &SS, NamedDecl *ScopeLookupResult, bool ErrorRecoveryLookup, bool *IsCorrectedToColon, bool OnlyNamespace) {\n  if (AcceptSpec) {\n    if (T->isEnumeralType())\n      Diag(IdInfo.IdentifierLoc, diag::warn_cxx98_compat_enum_nested_name_spec);"}}

[k]={{Mb,4752,"/// ParseEnumBody - Parse a {} enclosed enumerator-list.\n///      enumerator-list:\n///        enumerator\n///        enumerator-list \',\' enumerator\n///      enumerator:\n///        enumeration-constant attributes[opt]\n///        enumeration-constant attributes[opt] \'=\' constant-expression\n///      enumeration-constant:\n///        identifier\n///\nvoid Parser::ParseEnumBody(SourceLocation StartLoc, Decl *EnumDecl) {\n  // Parse the enumerator-list.\n  while (Tok.isNot(tok::r_brace)) {\n    // If comma is followed by r_brace, emit appropriate warning.\n    if (Tok.is(tok::r_brace) && CommaLoc.isValid()) {\n      if (!getLangOpts().C99 && !getLangOpts().CPlusPlus11)\n      else if (getLangOpts().CPlusPlus11)\n        Diag(CommaLoc, diag::warn_cxx98_compat_enumerator_list_comma) << FixItHint::CreateRemoval(CommaLoc);"}}

[k]={{F,9575,"/// CheckConversionDeclarator - Called by ActOnDeclarator to check the\n/// well-formednes of the conversion function declarator @p D with\n/// type @p R. If there are any errors in the declarator, this routine\n/// will emit diagnostics and return true. Otherwise, it will return\n/// false. Either way, the type @p R will be updated to reflect a\n/// well-formed type for the conversion operator.\nvoid Sema::CheckConversionDeclarator(Declarator &D, QualType &R, StorageClass &SC) {\n  // C++0x explicit conversion operators.\n  if (DS.hasExplicitSpecifier() && !getLangOpts().CPlusPlus20)\n    Diag(DS.getExplicitSpecLoc(), getLangOpts().CPlusPlus11 ? diag::warn_cxx98_compat_explicit_conversion_functions : diag::ext_explicit_conversion_functions) << SourceRange(DS.getExplicitSpecRange());"}}

[k]={{tc,938,"/// ParseExternalDeclaration:\n///\n/// The `Attrs` that are passed in are C++11 attributes and appertain to the\n/// declaration.\n///\n///      external-declaration: [C99 6.9], declaration: [C++ dcl.dcl]\n///        function-definition\n///        declaration\n/// [GNU]  asm-definition\n/// [GNU]  __extension__ external-declaration\n/// [OBJC]  objc-class-definition\n/// [OBJC]  objc-class-declaration\n/// [OBJC]  objc-alias-declaration\n/// [OBJC]  objc-protocol-definition\n/// [OBJC]  objc-method-definition\n/// [OBJC]  @end\n/// [C++]  linkage-specification\n/// [GNU] asm-definition:\n///        simple-asm-expr \';\'\n/// [C++11] empty-declaration\n/// [C++11] attribute-declaration\n///\n/// [C++11] empty-declaration:\n///          \';\'\n///\n/// [C++0x/GNU] \'extern\' \'template\' declaration\n///\n/// [C++20] module-import-declaration\n///\nParser::DeclGroupPtrTy Parser::ParseExternalDeclaration(ParsedAttributes &Attrs, ParsedAttributes &DeclSpecAttrs, ParsingDeclSpec *DS) {\n  case tok::kw_extern:\n    if (getLangOpts().CPlusPlus && NextToken().is(tok::kw_template)) {\n      Diag(ExternLoc, getLangOpts().CPlusPlus11 ? diag::warn_cxx98_compat_extern_template : diag::ext_extern_template) << SourceRange(ExternLoc, TemplateLoc);"}}

[k]={{Yb,1928,"/// ParseForStatement\n///      for-statement: [C99 6.8.5.3]\n///        \'for\' \'(\' expr[opt] \';\' expr[opt] \';\' expr[opt] \')\' statement\n///        \'for\' \'(\' declaration expr[opt] \';\' expr[opt] \')\' statement\n/// [C++]  \'for\' \'(\' for-init-statement condition[opt] \';\' expression[opt] \')\'\n/// [C++]      statement\n/// [C++0x] \'for\'\n///            \'co_await\'[opt]    [Coroutines]\n///            \'(\' for-range-declaration \':\' for-range-initializer \')\'\n///            statement\n/// [OBJC2] \'for\' \'(\' declaration \'in\' expr \')\' statement\n/// [OBJC2] \'for\' \'(\' expr \'in\' expr \')\' statement\n///\n/// [C++] for-init-statement:\n/// [C++]  expression-statement\n/// [C++]  simple-declaration\n/// [C++23] alias-declaration\n///\n/// [C++0x] for-range-declaration:\n/// [C++0x]  attribute-specifier-seq[opt] type-specifier-seq declarator\n/// [C++0x] for-range-initializer:\n/// [C++0x]  expression\n/// [C++0x]  braced-init-list            [TODO]\nStmtResult Parser::ParseForStatement(SourceLocation *TrailingElseLoc) {\n  // Parse the first part of the for specifier.\n  if (Tok.is(tok::semi)) { // for (;\n  } else if (getLangOpts().CPlusPlus && Tok.is(tok::identifier) && isForRangeIdentifier()) {\n  } else if (isForInitDeclaration()) { // for (int X = 4;\n    if (Tok.is(tok::kw_using)) {\n    } else {\n      if (ForRangeInfo.ParsedForRangeDecl()) {\n        Diag(ForRangeInfo.ColonLoc, getLangOpts().CPlusPlus11 ? diag::warn_cxx98_compat_for_range : diag::ext_for_range);"}}

[k]={{F,15055,"NamedDecl *Sema::ActOnFriendFunctionDecl(Scope *S, Declarator &D, MultiTemplateParamsArg TemplateParams) {\n  if ((SS.isInvalid() || !SS.isSet()) && (FunctionContainingLocalClass = cast<CXXRecordDecl>(CurContext)->isLocalClass())) {\n  } else if (SS.isInvalid() || !SS.isSet()) {\n  } else if (!SS.getScopeRep()->isDependent()) {\n    // C++ [class.friend]p1: A friend of a class is a function or\n    //  class that is not a member of the class . . .\n    if (DC->Equals(CurContext))\n      Diag(DS.getFriendSpecLoc(), getLangOpts().CPlusPlus11 ? diag::warn_cxx98_compat_friend_is_member : diag::err_friend_is_member);"}}

[k]={{"clang/lib/Parse/ParseCXXInlineMethods.cpp",331,"void Parser::ParseLexedMethodDeclaration(LateParsedMethodDeclaration &LM) {\n  for (unsigned I = 0, N = LM.DefaultArgs.size(); I != N; ++I) {\n    if (Toks) {\n      if (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace)) {\n        Diag(Tok, diag::warn_cxx98_compat_generalized_initializer_lists);"},{Mb,2367,"Decl *Parser::ParseDeclarationAfterDeclaratorAndAttributes(Declarator &D, const ParsedTemplateInfo &TemplateInfo, ForRangeInit *FRI) {\n  case InitKind::CXXBraced: {\n    Diag(Tok, diag::warn_cxx98_compat_generalized_initializer_lists);"},{Mb,6736,"/// ParseParameterDeclarationClause - Parse a (possibly empty) parameter-list\n/// after the opening parenthesis. This function will not parse a K&R-style\n/// identifier list.\n///\n/// DeclContext is the context of the declarator being parsed.  If FirstArgAttrs\n/// is non-null, then the caller parsed those attributes immediately after the\n/// open paren - they will be applied to the DeclSpec of the first parameter.\n///\n/// After returning, ParamInfo will hold the parsed parameters. EllipsisLoc will\n/// be the location of the ellipsis, if any was parsed.\n///\n///      parameter-type-list: [C99 6.7.5]\n///        parameter-list\n///        parameter-list \',\' \'...\'\n/// [C++]  parameter-list \'...\'\n///\n///      parameter-list: [C99 6.7.5]\n///        parameter-declaration\n///        parameter-list \',\' parameter-declaration\n///\n///      parameter-declaration: [C99 6.7.5]\n///        declaration-specifiers declarator\n/// [C++]  declaration-specifiers declarator \'=\' assignment-expression\n/// [C++11]                                      initializer-clause\n/// [GNU]  declaration-specifiers declarator attributes\n///        declaration-specifiers abstract-declarator[opt]\n/// [C++]  declaration-specifiers abstract-declarator[opt]\n///          \'=\' assignment-expression\n/// [GNU]  declaration-specifiers abstract-declarator[opt] attributes\n/// [C++11] attribute-specifier-seq parameter-declaration\n///\nvoid Parser::ParseParameterDeclarationClause(DeclaratorContext DeclaratorCtx, ParsedAttributes &FirstArgAttrs, SmallVectorImpl<DeclaratorChunk::ParamInfo> &ParamInfo, SourceLocation &EllipsisLoc, bool IsACXXFunctionDeclaration) {\n  do {\n    // If no parameter was specified, verify that *something* was specified,\n    // otherwise we have a missing type and identifier.\n    if (DS.isEmpty() && ParmDeclarator.getIdentifier() == nullptr && ParmDeclarator.getNumTypeObjects() == 0) {\n    } else {\n      // Parse the default argument, if any. We parse the default\n      // arguments in all dialects; the semantic analysis in\n      // ActOnParamDefaultArgument will reject the default argument in\n      // C.\n      if (Tok.is(tok::equal)) {\n        // Parse the default argument\n        if (DeclaratorCtx == DeclaratorContext::Member) {\n        } else {\n          if (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace)) {\n            Diag(Tok, diag::warn_cxx98_compat_generalized_initializer_lists);"},{db,3329,"/// ParseMemInitializer - Parse a C++ member initializer, which is\n/// part of a constructor initializer that explicitly initializes one\n/// member or base class (C++ [class.base.init]). See\n/// ParseConstructorInitializer for an example.\n///\n/// [C++] mem-initializer:\n///        mem-initializer-id \'(\' expression-list[opt] \')\'\n/// [C++0x] mem-initializer-id braced-init-list\n///\n/// [C++] mem-initializer-id:\n///        \'::\'[opt] nested-name-specifier[opt] class-name\n///        identifier\nMemInitResult Parser::ParseMemInitializer(Decl *ConstructorDecl) {\n  // Parse the \'(\'.\n  if (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace)) {\n    Diag(Tok, diag::warn_cxx98_compat_generalized_initializer_lists);"},{qc,541,"/// Parse a binary expression that starts with \\p LHS and has a\n/// precedence of at least \\p MinPrec.\nExprResult Parser::ParseRHSOfBinaryExpression(ExprResult LHS, prec::Level MinPrec) {\n  while (true) {\n    if (!RHS.isInvalid() && RHSIsInitList) {\n      if (ThisPrec == prec::Assignment) {\n        Diag(OpToken, diag::warn_cxx98_compat_generalized_initializer_lists) << Actions.getExprRange(RHS.get());"},{qc,1447,"#include \"clang/Basic/OpenCLImageTypes.def\"\n  {\n    if (Tok.is(tok::l_brace))\n      Diag(Tok, diag::warn_cxx98_compat_generalized_initializer_lists);"},{qc,1788,"/// Once the leading part of a postfix-expression is parsed, this\n/// method parses any suffixes that apply.\n///\n/// \\verbatim\n///      postfix-expression: [C99 6.5.2]\n///        primary-expression\n///        postfix-expression \'[\' expression \']\'\n///        postfix-expression \'[\' braced-init-list \']\'\n///        postfix-expression \'[\' expression-list [opt] \']\'  [C++23 12.4.5]\n///        postfix-expression \'(\' argument-expression-list[opt] \')\'\n///        postfix-expression \'.\' identifier\n///        postfix-expression \'->\' identifier\n///        postfix-expression \'++\'\n///        postfix-expression \'--\'\n///        \'(\' type-name \')\' \'{\' initializer-list \'}\'\n///        \'(\' type-name \')\' \'{\' initializer-list \',\' \'}\'\n///\n///      argument-expression-list: [C99 6.5.2]\n///        argument-expression ...[opt]\n///        argument-expression-list \',\' assignment-expression ...[opt]\n/// \\endverbatim\nExprResult Parser::ParsePostfixExpressionSuffix(ExprResult LHS) {\n  while (true) {\n    case tok::l_square: { // postfix-expression: p-e \'[\' expression \']\'\n      // We try to parse a list of indexes in all language mode first\n      // and, in we find 0 or one index, we try to parse an OpenMP array\n      // section. This allow us to support C++23 multi dimensional subscript and\n      // OpenMp sections in the same language mode.\n      if (!getLangOpts().OpenMP || Tok.isNot(tok::colon)) {\n        if (!getLangOpts().CPlusPlus23) {\n          if (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace)) {\n            Diag(Tok, diag::warn_cxx98_compat_generalized_initializer_lists);"},{qc,3168,"/// ParseExpressionList - Used for C/C++ (argument-)expression-list.\n///\n/// \\verbatim\n///      argument-expression-list:\n///        assignment-expression\n///        argument-expression-list , assignment-expression\n///\n/// [C++] expression-list:\n/// [C++]  assignment-expression\n/// [C++]  expression-list , assignment-expression\n///\n/// [C++0x] expression-list:\n/// [C++0x]  initializer-list\n///\n/// [C++0x] initializer-list\n/// [C++0x]  initializer-clause ...[opt]\n/// [C++0x]  initializer-list , initializer-clause ...[opt]\n///\n/// [C++0x] initializer-clause:\n/// [C++0x]  assignment-expression\n/// [C++0x]  braced-init-list\n/// \\endverbatim\nbool Parser::ParseExpressionList(SmallVectorImpl<Expr *> &Exprs, llvm::function_ref<void()> ExpressionStarts, bool FailImmediatelyOnInvalidExpr, bool EarlyTypoCorrection) {\n  while (true) {\n    if (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace)) {\n      Diag(Tok, diag::warn_cxx98_compat_generalized_initializer_lists);"},{Rb,1985,"/// ParseCXXCondition - if/switch/while condition expression.\n///\n///      condition:\n///        expression\n///        type-specifier-seq declarator \'=\' assignment-expression\n/// [C++11] type-specifier-seq declarator \'=\' initializer-clause\n/// [C++11] type-specifier-seq declarator braced-init-list\n/// [Clang] type-specifier-seq ref-qualifier[opt] \'[\' identifier-list \']\'\n///            brace-or-equal-initializer\n/// [GNU]  type-specifier-seq declarator simple-asm-expr[opt] attributes[opt]\n///            \'=\' assignment-expression\n///\n/// In C++1z, a condition may in some contexts be preceded by an\n/// optional init-statement. This function will parse that too.\n///\n/// \\param InitStmt If non-null, an init-statement is permitted, and if present\n/// will be parsed and stored here.\n///\n/// \\param Loc The location of the start of the statement that requires this\n/// condition, e.g., the \"for\" in a for loop.\n///\n/// \\param MissingOK Whether an empty condition is acceptable here. Otherwise\n/// it is considered an error to be recovered from.\n///\n/// \\param FRI If non-null, a for range declaration is permitted, and if\n/// present will be parsed and stored here, and a null result will be returned.\n///\n/// \\param EnterForConditionScope If true, enter a continue/break scope at the\n/// appropriate moment for a \'for\' loop.\n///\n/// \\returns The parsed condition.\nSema::ConditionResult Parser::ParseCXXCondition(StmtResult *InitStmt, SourceLocation Loc, Sema::ConditionKind CK, bool MissingOK, ForRangeInfo *FRI, bool EnterForConditionScope) {\n  if (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace)) {\n    Diag(Tok.getLocation(), diag::warn_cxx98_compat_generalized_initializer_lists);"},{Rb,2969,"/// ParseCXXNewExpression - Parse a C++ new-expression. New is used to allocate\n/// memory in a typesafe manner and call constructors.\n///\n/// This method is called to parse the new expression after the optional :: has\n/// been already parsed.  If the :: was present, \"UseGlobal\" is true and \"Start\"\n/// is its location.  Otherwise, \"Start\" is the location of the \'new\' token.\n///\n///        new-expression:\n///                  \'::\'[opt] \'new\' new-placement[opt] new-type-id\n///                                    new-initializer[opt]\n///                  \'::\'[opt] \'new\' new-placement[opt] \'(\' type-id \')\'\n///                                    new-initializer[opt]\n///\n///        new-placement:\n///                  \'(\' expression-list \')\'\n///\n///        new-type-id:\n///                  type-specifier-seq new-declarator[opt]\n/// [GNU]            attributes type-specifier-seq new-declarator[opt]\n///\n///        new-declarator:\n///                  ptr-operator new-declarator[opt]\n///                  direct-new-declarator\n///\n///        new-initializer:\n///                  \'(\' expression-list[opt] \')\'\n/// [C++0x]          braced-init-list\n///\nExprResult Parser::ParseCXXNewExpression(bool UseGlobal, SourceLocation Start) {\n  if (Tok.is(tok::l_paren)) {\n  } else if (Tok.is(tok::l_brace) && getLangOpts().CPlusPlus11) {\n    Diag(Tok.getLocation(), diag::warn_cxx98_compat_generalized_initializer_lists);"},{"clang/lib/Parse/ParseObjc.cpp",2951,"/// Parse the remainder of an Objective-C message following the\n/// \'[\' objc-receiver.\n///\n/// This routine handles sends to super, class messages (sent to a\n/// class name), and instance messages (sent to an object), and the\n/// target is represented by \\p SuperLoc, \\p ReceiverType, or \\p\n/// ReceiverExpr, respectively. Only one of these parameters may have\n/// a valid value.\n///\n/// \\param LBracLoc The location of the opening \'[\'.\n///\n/// \\param SuperLoc If this is a send to \'super\', the location of the\n/// \'super\' keyword that indicates a send to the superclass.\n///\n/// \\param ReceiverType If this is a class message, the type of the\n/// class we are sending a message to.\n///\n/// \\param ReceiverExpr If this is an instance message, the expression\n/// used to compute the receiver object.\n///\n///  objc-message-args:\n///    objc-selector\n///    objc-keywordarg-list\n///\n///  objc-keywordarg-list:\n///    objc-keywordarg\n///    objc-keywordarg-list objc-keywordarg\n///\n///  objc-keywordarg:\n///    selector-name[opt] \':\' objc-keywordexpr\n///\n///  objc-keywordexpr:\n///    nonempty-expr-list\n///\n///  nonempty-expr-list:\n///    assignment-expression\n///    nonempty-expr-list , assignment-expression\n///\nExprResult Parser::ParseObjCMessageExpressionBody(SourceLocation LBracLoc, SourceLocation SuperLoc, ParsedType ReceiverType, Expr *ReceiverExpr) {\n  if (Tok.is(tok::colon)) {\n    while (true) {\n      if (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace)) {\n        Diag(Tok, diag::warn_cxx98_compat_generalized_initializer_lists);"},{"clang/lib/Parse/ParseOpenMP.cpp",383,"void Parser::ParseOpenMPReductionInitializerForDecl(VarDecl *OmpPrivParm) {\n  // Parse declarator \'=\' initializer.\n  // If a \'==\' or \'+=\' is found, suggest a fixit to \'=\'.\n  if (isTokenEqualOrEqualTypo()) {\n  } else if (Tok.is(tok::l_paren)) {\n  } else if (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace)) {\n    Diag(Tok, diag::warn_cxx98_compat_generalized_initializer_lists);"},{Yb,2221,"/// ParseReturnStatement\n///      jump-statement:\n///        \'return\' expression[opt] \';\'\n///        \'return\' braced-init-list \';\'\n///        \'co_return\' expression[opt] \';\'\n///        \'co_return\' braced-init-list \';\'\nStmtResult Parser::ParseReturnStatement() {\n  if (Tok.isNot(tok::semi)) {\n    if (Tok.is(tok::l_brace) && getLangOpts().CPlusPlus) {\n      if (R.isUsable())\n        Diag(R.get()->getBeginLoc(), getLangOpts().CPlusPlus11 ? diag::warn_cxx98_compat_generalized_initializer_lists : diag::ext_generalized_initializer_lists) << R.get()->getSourceRange();"}}

[k]={{xd,599,"/// VerifyJumps - Verify each element of the Jumps array to see if they are\n/// valid, emitting diagnostics if not.\nvoid JumpScopeChecker::VerifyJumps() {\n  while (!Jumps.empty()) {\n    // With a goto,\n    if (GotoStmt *GS = dyn_cast<GotoStmt>(Jump)) {\n      // The label may not have a statement if it\'s coming from inline MS ASM.\n      if (GS->getLabel()->getStmt()) {\n        CheckJump(GS, GS->getLabel()->getStmt(), GS->getGotoLoc(), diag::err_goto_into_protected_scope, diag::ext_goto_into_protected_scope, diag::warn_cxx98_compat_goto_into_protected_scope);"},{xd,624,"/// VerifyJumps - Verify each element of the Jumps array to see if they are\n/// valid, emitting diagnostics if not.\nvoid JumpScopeChecker::VerifyJumps() {\n  while (!Jumps.empty()) {\n    // We only get indirect gotos here when they have a constant target.\n    if (IndirectGotoStmt *IGS = dyn_cast<IndirectGotoStmt>(Jump)) {\n      CheckJump(IGS, Target->getStmt(), IGS->getGotoLoc(), diag::err_goto_into_protected_scope, diag::ext_goto_into_protected_scope, diag::warn_cxx98_compat_goto_into_protected_scope);"}}

[k]={{xd,828,"/// Diagnose an indirect jump which is known to cross scopes.\nvoid JumpScopeChecker::DiagnoseIndirectOrAsmJump(Stmt *Jump, unsigned JumpScope, LabelDecl *Target, unsigned TargetScope) {\n  // Diagnose this jump if it would be ill-formed in C++98.\n  if (!Diagnosed && !ToScopesCXX98Compat.empty()) {\n    S.Diag(Jump->getBeginLoc(), diag::warn_cxx98_compat_indirect_goto_in_protected_scope) << IsAsmGoto;"}}

[k]={{fb,7865,"ExprResult InitializationSequence::Perform(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, MultiExprArg Args, QualType *ResultType) {\n  for (step_iterator Step = step_begin(), StepEnd = step_end(); Step != StepEnd; ++Step) {\n    case SK_StdInitializerList: {\n      S.Diag(CurInit.get()->getExprLoc(), diag::warn_cxx98_compat_initializer_list_init) << CurInit.get()->getSourceRange();"}}

[k]={{db,201,"/// ParseNamespace - We know that the current token is a namespace keyword. This\n/// may either be a top level namespace or a block-level namespace alias. If\n/// there was an inline keyword, it has already been parsed.\n///\n///      namespace-definition: [C++: namespace.def]\n///        named-namespace-definition\n///        unnamed-namespace-definition\n///        nested-namespace-definition\n///\n///      named-namespace-definition:\n///        \'inline\'[opt] \'namespace\' attributes[opt] identifier \'{\'\n///        namespace-body \'}\'\n///\n///      unnamed-namespace-definition:\n///        \'inline\'[opt] \'namespace\' attributes[opt] \'{\' namespace-body \'}\'\n///\n///      nested-namespace-definition:\n///        \'namespace\' enclosing-namespace-specifier \'::\' \'inline\'[opt]\n///        identifier \'{\' namespace-body \'}\'\n///\n///      enclosing-namespace-specifier:\n///        identifier\n///        enclosing-namespace-specifier \'::\' \'inline\'[opt] identifier\n///\n///      namespace-alias-definition:  [C++ 7.3.2: namespace.alias]\n///        \'namespace\' identifier \'=\' qualified-namespace-specifier \';\'\n///\nParser::DeclGroupPtrTy Parser::ParseNamespace(DeclaratorContext Context, SourceLocation &DeclEnd, SourceLocation InlineLoc) {\n  // If we\'re still good, complain about inline namespaces in non-C++0x now.\n  if (InlineLoc.isValid())\n    Diag(InlineLoc, getLangOpts().CPlusPlus11 ? diag::warn_cxx98_compat_inline_namespace : diag::ext_inline_namespace);"}}

[k]={{Rb,1155,"/// ParseLambdaExpressionAfterIntroducer - Parse the rest of a lambda\n/// expression.\nExprResult Parser::ParseLambdaExpressionAfterIntroducer(LambdaIntroducer &Intro) {\n  Diag(LambdaBeginLoc, diag::warn_cxx98_compat_lambda);"}}

[k]={{vb,3877,"LexStart:\n  case \'<\':\n    if (ParsingFilename) {\n    } else if (Char == \'<\') {\n    } else if (Char == \'=\') {\n    } else if (LangOpts.Digraphs && Char == \':\') { // \'<:\' -> \'[\'\n      if (LangOpts.CPlusPlus11 && getCharAndSize(CurPtr + SizeTmp, SizeTmp2) == \':\') {\n        if (After != \':\' && After != \'>\') {\n          if (!isLexingRawMode())\n            Diag(BufferPtr, diag::warn_cxx98_compat_less_colon_colon);"}}

[k]={{Rb,2471,"#include \"clang/Basic/OperatorKinds.def\"\n  if (getLangOpts().CPlusPlus11 && isTokenStringLiteral()) {\n    Diag(Tok.getLocation(), diag::warn_cxx98_compat_literal_operator);"}}

[k]={{Wc,575,"/// ProcessUCNEscape - Read the Universal Character Name, check constraints and\n/// return the UTF32.\nstatic bool ProcessUCNEscape(const char *ThisTokBegin, const char *&ThisTokBuf, const char *ThisTokEnd, uint32_t &UcnVal, unsigned short &UcnLen, FullSourceLoc Loc, DiagnosticsEngine *Diags, const LangOptions &Features, bool in_char_string_literal = false) {\n  // C2x and C++11 allow UCNs that refer to control characters\n  // and basic source characters inside character and string literals\n  if (UcnVal < 0xa0 &&\n    if (Diags) {\n      if (UcnVal >= 0x20 && UcnVal < 0x7f)\n      else\n        Diag(Diags, Features, Loc, ThisTokBegin, UcnBegin, ThisTokBuf, IsError ? diag::err_ucn_control_character : Features.CPlusPlus ? diag::warn_cxx98_compat_literal_ucn_control_character : diag::warn_c2x_compat_literal_ucn_control_character);"}}

[k]={{Wc,573,"/// ProcessUCNEscape - Read the Universal Character Name, check constraints and\n/// return the UTF32.\nstatic bool ProcessUCNEscape(const char *ThisTokBegin, const char *&ThisTokBuf, const char *ThisTokEnd, uint32_t &UcnVal, unsigned short &UcnLen, FullSourceLoc Loc, DiagnosticsEngine *Diags, const LangOptions &Features, bool in_char_string_literal = false) {\n  // C2x and C++11 allow UCNs that refer to control characters\n  // and basic source characters inside character and string literals\n  if (UcnVal < 0xa0 &&\n    if (Diags) {\n      if (UcnVal >= 0x20 && UcnVal < 0x7f)\n        Diag(Diags, Features, Loc, ThisTokBegin, UcnBegin, ThisTokBuf, IsError ? diag::err_ucn_escape_basic_scs : Features.CPlusPlus ? diag::warn_cxx98_compat_literal_ucn_escape_basic_scs : diag::warn_c2x_compat_literal_ucn_escape_basic_scs) << StringRef(&BasicSCSChar, 1);"}}

[k]={{"clang/lib/Lex/PPExpressions.cpp",303,"/// EvaluateValue - Evaluate the token PeekTok (and any others needed) and\n/// return the computed value in Result.  Return true if there was an error\n/// parsing.  This function also returns information about the form of the\n/// expression in DT.  See above for information on what DT means.\n///\n/// If ValueLive is false, then this value is being evaluated in a context where\n/// the result is not used.  As such, avoid diagnostics that relate to\n/// evaluation.\nstatic bool EvaluateValue(PPValue &Result, Token &PeekTok, DefinedTracker &DT, bool ValueLive, Preprocessor &PP) {\n  case tok::numeric_constant: {\n    // \'long long\' is a C99 or C++11 feature.\n    if (!PP.getLangOpts().C99 && Literal.isLongLong) {\n      if (PP.getLangOpts().CPlusPlus)\n        PP.Diag(PeekTok, PP.getLangOpts().CPlusPlus11 ? diag::warn_cxx98_compat_longlong : diag::ext_cxx11_longlong);"},{M,3687,"ExprResult Sema::ActOnNumericConstant(const Token &Tok, Scope *UDLScope) {\n  if (Literal.isFixedPointLiteral()) {\n  } else if (Literal.isFloatingLiteral()) {\n  } else if (!Literal.isIntegerLiteral()) {\n  } else {\n    if (Literal.GetIntegerValue(ResultVal)) {\n    } else {\n      // Check long long if needed.\n      if (Ty.isNull() && !Literal.isSizeT) {\n        // Does it fit in a unsigned long long?\n        if (ResultVal.isIntN(LongLongSize)) {\n          // \'long long\' is a C99 or C++11 feature, whether the literal\n          // explicitly specified \'long long\' or we needed the extra width.\n          if (getLangOpts().CPlusPlus)\n            Diag(Tok.getLocation(), getLangOpts().CPlusPlus11 ? diag::warn_cxx98_compat_longlong : diag::ext_cxx11_longlong);"},{Cb,1235,"/// Convert the specified declspec to the appropriate type\n/// object.\n/// \\param state Specifies the declarator containing the declaration specifier\n/// to be converted, along with other associated processing state.\n/// \\returns The type described by the declaration specifiers.  This function\n/// never returns null.\nstatic QualType ConvertDeclSpecToType(TypeProcessingState &state) {\n  case DeclSpec::TST_int: {\n    if (DS.getTypeSpecSign() != TypeSpecifierSign::Unsigned) {\n      case TypeSpecifierWidth::LongLong:\n        // \'long long\' is a C99 or C++11 feature.\n        if (!S.getLangOpts().C99) {\n          if (S.getLangOpts().CPlusPlus)\n            S.Diag(DS.getTypeSpecWidthLoc(), S.getLangOpts().CPlusPlus11 ? diag::warn_cxx98_compat_longlong : diag::ext_cxx11_longlong);"},{Cb,1258,"/// Convert the specified declspec to the appropriate type\n/// object.\n/// \\param state Specifies the declarator containing the declaration specifier\n/// to be converted, along with other associated processing state.\n/// \\returns The type described by the declaration specifiers.  This function\n/// never returns null.\nstatic QualType ConvertDeclSpecToType(TypeProcessingState &state) {\n  case DeclSpec::TST_int: {\n    if (DS.getTypeSpecSign() != TypeSpecifierSign::Unsigned) {\n    } else {\n      case TypeSpecifierWidth::LongLong:\n        // \'long long\' is a C99 or C++11 feature.\n        if (!S.getLangOpts().C99) {\n          if (S.getLangOpts().CPlusPlus)\n            S.Diag(DS.getTypeSpecWidthLoc(), S.getLangOpts().CPlusPlus11 ? diag::warn_cxx98_compat_longlong : diag::ext_cxx11_longlong);"}}

[k]={{vb,2814,"/// LexEndOfFile - CurPtr points to the end of this file.  Handle this\n/// condition, reporting diagnostics and handling other edge cases as required.\n/// This returns true if Result contains a token, false if PP.Lex should be\n/// called again.\nbool Lexer::LexEndOfFile(Token &Result, const char *CurPtr) {\n  // C99 5.1.1.2p2: If the file is non-empty and didn\'t end in a newline, issue\n  // a pedwarn.\n  if (CurPtr != BufferStart && (CurPtr[-1] != \'\\n\' && CurPtr[-1] != \'\\r\')) {\n    if (LangOpts.CPlusPlus11) {\n      if (!Diags.isIgnored(diag::warn_cxx98_compat_no_newline_eof, EndLoc)) {"},{vb,2815,"/// LexEndOfFile - CurPtr points to the end of this file.  Handle this\n/// condition, reporting diagnostics and handling other edge cases as required.\n/// This returns true if Result contains a token, false if PP.Lex should be\n/// called again.\nbool Lexer::LexEndOfFile(Token &Result, const char *CurPtr) {\n  // C99 5.1.1.2p2: If the file is non-empty and didn\'t end in a newline, issue\n  // a pedwarn.\n  if (CurPtr != BufferStart && (CurPtr[-1] != \'\\n\' && CurPtr[-1] != \'\\r\')) {\n    if (LangOpts.CPlusPlus11) {\n      // C++11 [lex.phases] 2.2 p2\n      // Prefer the C++98 pedantic compatibility warning over the generic,\n      // non-extension, user-requested \"missing newline at EOF\" warning.\n      if (!Diags.isIgnored(diag::warn_cxx98_compat_no_newline_eof, EndLoc)) {\n        DiagID = diag::warn_cxx98_compat_no_newline_eof;"}}

[k]={{db,3408,"/// Parse a C++ exception-specification if present (C++0x [except.spec]).\n///\n///      exception-specification:\n///        dynamic-exception-specification\n///        noexcept-specification\n///\n///      noexcept-specification:\n///        \'noexcept\'\n///        \'noexcept\' \'(\' constant-expression \')\'\nExceptionSpecificationType Parser::tryParseExceptionSpecification(bool Delayed, SourceRange &SpecificationRange, SmallVectorImpl<ParsedType> &DynamicExceptions, SmallVectorImpl<SourceRange> &DynamicExceptionRanges, ExprResult &NoexceptExpr, CachedTokens *&ExceptionSpecTokens) {\n  // Handle delayed parsing of exception-specifications.\n  if (Delayed) {\n    // Check for a \'(\'.\n    if (!Tok.is(tok::l_paren)) {\n      // If this is a bare \'noexcept\', we\'re done.\n      if (IsNoexcept) {\n        Diag(Tok, diag::warn_cxx98_compat_noexcept_decl);"},{db,3441,"/// Parse a C++ exception-specification if present (C++0x [except.spec]).\n///\n///      exception-specification:\n///        dynamic-exception-specification\n///        noexcept-specification\n///\n///      noexcept-specification:\n///        \'noexcept\'\n///        \'noexcept\' \'(\' constant-expression \')\'\nExceptionSpecificationType Parser::tryParseExceptionSpecification(bool Delayed, SourceRange &SpecificationRange, SmallVectorImpl<ParsedType> &DynamicExceptions, SmallVectorImpl<SourceRange> &DynamicExceptionRanges, ExprResult &NoexceptExpr, CachedTokens *&ExceptionSpecTokens) {\n  Diag(Tok, diag::warn_cxx98_compat_noexcept_decl);"}}

[k]={{qc,1554,"#include \"clang/Basic/OpenCLImageTypes.def\"\n  case tok::kw_noexcept: { // [C++0x] \'noexcept\' \'(\' expression \')\'\n    Diag(Tok, diag::warn_cxx98_compat_noexcept_expr);"}}

[k]={{"clang/lib/Sema/SemaExprMember.cpp",230,"/// Builds an expression which might be an implicit member expression.\nExprResult Sema::BuildPossibleImplicitMemberExpr(const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, LookupResult &R, const TemplateArgumentListInfo *TemplateArgs, const Scope *S, UnresolvedLookupExpr *AsULE) {\n  case IMA_Field_Uneval_Context:\n    Diag(R.getNameLoc(), diag::warn_cxx98_compat_non_static_member_use) << R.getLookupNameInfo().getName();"}}

[k]={{F,14670,"/// Perform semantic analysis of the given friend type declaration.\n///\n/// \\returns A friend declaration that.\nFriendDecl *Sema::CheckFriendTypeDecl(SourceLocation LocStart, SourceLocation FriendLoc, TypeSourceInfo *TSInfo) {\n  // C++03 [class.friend]p2:\n  //  An elaborated-type-specifier shall be used in a friend declaration\n  //  for a class.*\n  //\n  //  * The class-key of the elaborated-type-specifier is required.\n  if (!CodeSynthesisContexts.empty()) {\n  } else {\n    if (!T->isElaboratedTypeSpecifier()) {\n      // If we evaluated the type to a record type, suggest putting\n      // a tag in front.\n      if (const RecordType *RT = T->getAs<RecordType>()) {\n      } else {\n        Diag(FriendLoc, getLangOpts().CPlusPlus11 ? diag::warn_cxx98_compat_nonclass_type_friend : diag::ext_nonclass_type_friend) << T << TypeRange;"}}

[k]={{db,2664,"/// ParseCXXClassMemberDeclaration - Parse a C++ class member declaration.\n///\n///      member-declaration:\n///        decl-specifier-seq[opt] member-declarator-list[opt] \';\'\n///        function-definition \';\'[opt]\n///        ::[opt] nested-name-specifier template[opt] unqualified-id \';\'[TODO]\n///        using-declaration                                            [TODO]\n/// [C++0x] static_assert-declaration\n///        template-declaration\n/// [GNU]  \'__extension__\' member-declaration\n///\n///      member-declarator-list:\n///        member-declarator\n///        member-declarator-list \',\' member-declarator\n///\n///      member-declarator:\n///        declarator virt-specifier-seq[opt] pure-specifier[opt]\n/// [C++2a] declarator requires-clause\n///        declarator constant-initializer[opt]\n/// [C++11] declarator brace-or-equal-initializer[opt]\n///        identifier[opt] \':\' constant-expression\n///\n///      virt-specifier-seq:\n///        virt-specifier\n///        virt-specifier-seq virt-specifier\n///\n///      virt-specifier:\n///        override\n///        final\n/// [MS]    sealed\n///\n///      pure-specifier:\n///        \'= 0\'\n///\n///      constant-initializer:\n///        \'=\' constant-expression\n///\nParser::DeclGroupPtrTy Parser::ParseCXXClassMemberDeclaration(AccessSpecifier AS, ParsedAttributes &AccessAttrs, const ParsedTemplateInfo &TemplateInfo, ParsingDeclRAIIObject *TemplateDiags) {\n  while (true) {\n    // Handle the initializer.\n    if (HasInClassInit != ICIS_NoInit) {\n      Diag(Tok, getLangOpts().CPlusPlus11 ? diag::warn_cxx98_compat_nonstatic_member_init : diag::ext_nonstatic_member_init);"}}

[k]={{G,16039,"bool Sema::CheckNontrivialField(FieldDecl *FD) {\n  if (const RecordType *RT = EltTy->getAs<RecordType>()) {\n    if (RDecl->getDefinition()) {\n      if (member != CXXInvalid) {\n        Diag(FD->getLocation(), getLangOpts().CPlusPlus11 ? diag::warn_cxx98_compat_nontrivial_union_or_anon_struct_member : diag::err_illegal_union_or_anon_struct_member) << FD->getParent()->isUnion() << FD->getDeclName() << member;"}}

[k]={{qc,917,"/// Parse a cast-expression, or, if \\pisUnaryExpression is true, parse\n/// a unary-expression.\n///\n/// \\p isAddressOfOperand exists because an id-expression that is the operand\n/// of address-of gets special treatment due to member pointers. NotCastExpr\n/// is set to true if the token is not the start of a cast-expression, and no\n/// diagnostic is emitted in this case and no tokens are consumed.\n///\n/// \\verbatim\n///      cast-expression: [C99 6.5.4]\n///        unary-expression\n///        \'(\' type-name \')\' cast-expression\n///\n///      unary-expression:  [C99 6.5.3]\n///        postfix-expression\n///        \'++\' unary-expression\n///        \'--\' unary-expression\n/// [Coro]  \'co_await\' cast-expression\n///        unary-operator cast-expression\n///        \'sizeof\' unary-expression\n///        \'sizeof\' \'(\' type-name \')\'\n/// [C++11] \'sizeof\' \'...\' \'(\' identifier \')\'\n/// [GNU]  \'__alignof\' unary-expression\n/// [GNU]  \'__alignof\' \'(\' type-name \')\'\n/// [C11]  \'_Alignof\' \'(\' type-name \')\'\n/// [C++11] \'alignof\' \'(\' type-id \')\'\n/// [GNU]  \'&&\' identifier\n/// [C++11] \'noexcept\' \'(\' expression \')\' [C++11 5.3.7]\n/// [C++]  new-expression\n/// [C++]  delete-expression\n///\n///      unary-operator: one of\n///        \'&\'  \'*\'  \'+\'  \'-\'  \'~\'  \'!\'\n/// [GNU]  \'__extension__\'  \'__real\'  \'__imag\'\n///\n///      primary-expression: [C99 6.5.1]\n/// [C99]  identifier\n/// [C++]  id-expression\n///        constant\n///        string-literal\n/// [C++]  boolean-literal  [C++ 2.13.5]\n/// [C++11] \'nullptr\'        [C++11 2.14.7]\n/// [C++11] user-defined-literal\n///        \'(\' expression \')\'\n/// [C11]  generic-selection\n/// [C++2a] requires-expression\n///        \'__func__\'        [C99 6.4.2.2]\n/// [GNU]  \'__FUNCTION__\'\n/// [MS]    \'__FUNCDNAME__\'\n/// [MS]    \'L__FUNCTION__\'\n/// [MS]    \'__FUNCSIG__\'\n/// [MS]    \'L__FUNCSIG__\'\n/// [GNU]  \'__PRETTY_FUNCTION__\'\n/// [GNU]  \'(\' compound-statement \')\'\n/// [GNU]  \'__builtin_va_arg\' \'(\' assignment-expression \',\' type-name \')\'\n/// [GNU]  \'__builtin_offsetof\' \'(\' type-name \',\' offsetof-member-designator\')\'\n/// [GNU]  \'__builtin_choose_expr\' \'(\' assign-expr \',\' assign-expr \',\'\n///                                    assign-expr \')\'\n/// [GNU]  \'__builtin_FILE\' \'(\' \')\'\n/// [CLANG] \'__builtin_FILE_NAME\' \'(\' \')\'\n/// [GNU]  \'__builtin_FUNCTION\' \'(\' \')\'\n/// [MS]    \'__builtin_FUNCSIG\' \'(\' \')\'\n/// [GNU]  \'__builtin_LINE\' \'(\' \')\'\n/// [CLANG] \'__builtin_COLUMN\' \'(\' \')\'\n/// [GNU]  \'__builtin_source_location\' \'(\' \')\'\n/// [GNU]  \'__builtin_types_compatible_p\' \'(\' type-name \',\' type-name \')\'\n/// [GNU]  \'__null\'\n/// [OBJC]  \'[\' objc-message-expr \']\'\n/// [OBJC]  \'\\@selector\' \'(\' objc-selector-arg \')\'\n/// [OBJC]  \'\\@protocol\' \'(\' identifier \')\'\n/// [OBJC]  \'\\@encode\' \'(\' type-name \')\'\n/// [OBJC]  objc-string-literal\n/// [C++]  simple-type-specifier \'(\' expression-list[opt] \')\'      [C++ 5.2.3]\n/// [C++11] simple-type-specifier braced-init-list                  [C++11 5.2.3]\n/// [C++]  typename-specifier \'(\' expression-list[opt] \')\'        [C++ 5.2.3]\n/// [C++11] typename-specifier braced-init-list                    [C++11 5.2.3]\n/// [C++]  \'const_cast\' \'<\' type-name \'>\' \'(\' expression \')\'      [C++ 5.2p1]\n/// [C++]  \'dynamic_cast\' \'<\' type-name \'>\' \'(\' expression \')\'    [C++ 5.2p1]\n/// [C++]  \'reinterpret_cast\' \'<\' type-name \'>\' \'(\' expression \')\' [C++ 5.2p1]\n/// [C++]  \'static_cast\' \'<\' type-name \'>\' \'(\' expression \')\'      [C++ 5.2p1]\n/// [C++]  \'typeid\' \'(\' expression \')\'                            [C++ 5.2p1]\n/// [C++]  \'typeid\' \'(\' type-id \')\'                                [C++ 5.2p1]\n/// [C++]  \'this\'          [C++ 9.3.2]\n/// [G++]  unary-type-trait \'(\' type-id \')\'\n/// [G++]  binary-type-trait \'(\' type-id \',\' type-id \')\'          [TODO]\n/// [EMBT]  array-type-trait \'(\' type-id \',\' integer \')\'\n/// [clang] \'^\' block-literal\n///\n///      constant: [C99 6.4.4]\n///        integer-constant\n///        floating-constant\n///        enumeration-constant -> identifier\n///        character-constant\n///\n///      id-expression: [C++ 5.1]\n///                  unqualified-id\n///                  qualified-id\n///\n///      unqualified-id: [C++ 5.1]\n///                  identifier\n///                  operator-function-id\n///                  conversion-function-id\n///                  \'~\' class-name\n///                  template-id\n///\n///      new-expression: [C++ 5.3.4]\n///                  \'::\'[opt] \'new\' new-placement[opt] new-type-id\n///                                    new-initializer[opt]\n///                  \'::\'[opt] \'new\' new-placement[opt] \'(\' type-id \')\'\n///                                    new-initializer[opt]\n///\n///      delete-expression: [C++ 5.3.5]\n///                  \'::\'[opt] \'delete\' cast-expression\n///                  \'::\'[opt] \'delete\' \'[\' \']\' cast-expression\n///\n/// [GNU/Embarcadero] unary-type-trait:\n///                  \'__is_arithmetic\'\n///                  \'__is_floating_point\'\n///                  \'__is_integral\'\n///                  \'__is_lvalue_expr\'\n///                  \'__is_rvalue_expr\'\n///                  \'__is_complete_type\'\n///                  \'__is_void\'\n///                  \'__is_array\'\n///                  \'__is_function\'\n///                  \'__is_reference\'\n///                  \'__is_lvalue_reference\'\n///                  \'__is_rvalue_reference\'\n///                  \'__is_fundamental\'\n///                  \'__is_object\'\n///                  \'__is_scalar\'\n///                  \'__is_compound\'\n///                  \'__is_pointer\'\n///                  \'__is_member_object_pointer\'\n///                  \'__is_member_function_pointer\'\n///                  \'__is_member_pointer\'\n///                  \'__is_const\'\n///                  \'__is_volatile\'\n///                  \'__is_trivial\'\n///                  \'__is_standard_layout\'\n///                  \'__is_signed\'\n///                  \'__is_unsigned\'\n///\n/// [GNU] unary-type-trait:\n///                  \'__has_nothrow_assign\'\n///                  \'__has_nothrow_copy\'\n///                  \'__has_nothrow_constructor\'\n///                  \'__has_trivial_assign\'                  [TODO]\n///                  \'__has_trivial_copy\'                    [TODO]\n///                  \'__has_trivial_constructor\'\n///                  \'__has_trivial_destructor\'\n///                  \'__has_virtual_destructor\'\n///                  \'__is_abstract\'                        [TODO]\n///                  \'__is_class\'\n///                  \'__is_empty\'                            [TODO]\n///                  \'__is_enum\'\n///                  \'__is_final\'\n///                  \'__is_pod\'\n///                  \'__is_polymorphic\'\n///                  \'__is_sealed\'                          [MS]\n///                  \'__is_trivial\'\n///                  \'__is_union\'\n///                  \'__has_unique_object_representations\'\n///\n/// [Clang] unary-type-trait:\n///                  \'__is_aggregate\'\n///                  \'__trivially_copyable\'\n///\n///      binary-type-trait:\n/// [GNU]            \'__is_base_of\'\n/// [MS]              \'__is_convertible_to\'\n///                  \'__is_convertible\'\n///                  \'__is_same\'\n///\n/// [Embarcadero] array-type-trait:\n///                  \'__array_rank\'\n///                  \'__array_extent\'\n///\n/// [Embarcadero] expression-trait:\n///                  \'__is_lvalue_expr\'\n///                  \'__is_rvalue_expr\'\n/// \\endverbatim\n///\nExprResult Parser::ParseCastExpression(CastParseKind ParseKind, bool isAddressOfOperand, bool &NotCastExpr, TypeCastState isTypeCast, bool isVectorLiteral, bool *NotPrimaryExpression) {\n  case tok::kw_nullptr:\n    if (getLangOpts().CPlusPlus)\n      Diag(Tok, diag::warn_cxx98_compat_nullptr);"}}

[k]={{db,2114,"/// ParseOptionalCXX11VirtSpecifierSeq - Parse a virt-specifier-seq.\n///\n///      virt-specifier-seq:\n///        virt-specifier\n///        virt-specifier-seq virt-specifier\nvoid Parser::ParseOptionalCXX11VirtSpecifierSeq(VirtSpecifiers &VS, bool IsInterface, SourceLocation FriendLoc) {\n  while (true) {\n    if (IsInterface && (Specifier == VirtSpecifiers::VS_Final || Specifier == VirtSpecifiers::VS_Sealed)) {\n    } else if (Specifier == VirtSpecifiers::VS_Sealed) {\n    } else if (Specifier == VirtSpecifiers::VS_Abstract) {\n    } else if (Specifier == VirtSpecifiers::VS_GNU_Final) {\n    } else {\n      Diag(Tok.getLocation(), getLangOpts().CPlusPlus11 ? diag::warn_cxx98_compat_override_control_keyword : diag::ext_override_control_keyword) << VirtSpecifiers::getSpecifierName(Specifier);"},{db,3043,"/// ParseCXXMemberSpecification - Parse the class definition.\n///\n///      member-specification:\n///        member-declaration member-specification[opt]\n///        access-specifier \':\' member-specification[opt]\n///\nvoid Parser::ParseCXXMemberSpecification(SourceLocation RecordLoc, SourceLocation AttrFixitLoc, ParsedAttributes &Attrs, unsigned TagType, Decl *TagDecl) {\n  // Parse the optional \'final\' keyword.\n  if (getLangOpts().CPlusPlus && Tok.is(tok::identifier)) {\n    while (true) {\n      if (TagType == DeclSpec::TST_interface)\n      else if (Specifier == VirtSpecifiers::VS_Final)\n        Diag(FinalLoc, getLangOpts().CPlusPlus11 ? diag::warn_cxx98_compat_override_control_keyword : diag::ext_override_control_keyword) << VirtSpecifiers::getSpecifierName(Specifier);"}}

[k]={{M,880,"void Sema::checkVariadicArgument(const Expr *E, VariadicCallType CT) {\n  case VAK_ValidInCXX11:\n    DiagRuntimeBehavior(E->getBeginLoc(), nullptr, PDiag(diag::warn_cxx98_compat_pass_non_pod_arg_to_vararg) << Ty << CT);"}}

[k]={{pd,1299,"/// Handle a \\#line directive: C99 6.10.4.\n///\n/// The two acceptable forms are:\n/// \\verbatim\n///  # line digit-sequence\n///  # line digit-sequence \"s-char-sequence\"\n/// \\endverbatim\nvoid Preprocessor::HandleLineDirective() {\n  if (LineNo >= LineLimit)\n  else if (LangOpts.CPlusPlus11 && LineNo >= 32768U)\n    Diag(DigitTok, diag::warn_cxx98_compat_pp_line_too_big);"}}

[k]={{vb,1943,"/// LexRawStringLiteral - Lex the remainder of a raw string literal, after\n/// having lexed R\", LR\", u8R\", uR\", or UR\".\nbool Lexer::LexRawStringLiteral(Token &Result, const char *CurPtr, tok::TokenKind Kind) {\n  if (!isLexingRawMode())\n    Diag(BufferPtr, diag::warn_cxx98_compat_raw_string_literal);"}}

[k]={{Mb,6465,"/// ParseRefQualifier - Parses a member function ref-qualifier. Returns\n/// true if a ref-qualifier is found.\nbool Parser::ParseRefQualifier(bool &RefQualifierIsLValueRef, SourceLocation &RefQualifierLoc) {\n  if (Tok.isOneOf(tok::amp, tok::ampamp)) {\n    Diag(Tok, getLangOpts().CPlusPlus11 ? diag::warn_cxx98_compat_ref_qualifier : diag::ext_ref_qualifier);"}}

[k]={{fb,7328,"ExprResult InitializationSequence::Perform(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, MultiExprArg Args, QualType *ResultType) {\n  if (S.getLangOpts().CPlusPlus11 && Entity.getType()->isReferenceType() && Args.size() == 1 && isa<InitListExpr>(Args[0]) && !Entity.isParamOrTemplateParamKind()) {\n    S.Diag(Init->getBeginLoc(), diag::warn_cxx98_compat_reference_list_init) << Init->getSourceRange();"}}

[k]={{Mb,5705,"/// ParseDeclaratorInternal - Parse a C or C++ declarator. The direct-declarator\n/// is parsed by the function passed to it. Pass null, and the direct-declarator\n/// isn\'t parsed at all, making this function effectively parse the C++\n/// ptr-operator production.\n///\n/// If the grammar of this construct is extended, matching changes must also be\n/// made to TryParseDeclarator and MightBeDeclarator, and possibly to\n/// isConstructorDeclarator.\n///\n///      declarator: [C99 6.7.5] [C++ 8p4, dcl.decl]\n/// [C]    pointer[opt] direct-declarator\n/// [C++]  direct-declarator\n/// [C++]  ptr-operator declarator\n///\n///      pointer: [C99 6.7.5]\n///        \'*\' type-qualifier-list[opt]\n///        \'*\' type-qualifier-list[opt] pointer\n///\n///      ptr-operator:\n///        \'*\' cv-qualifier-seq[opt]\n///        \'&\'\n/// [C++0x] \'&&\'\n/// [GNU]  \'&\' restrict[opt] attributes[opt]\n/// [GNU?]  \'&&\' restrict[opt] attributes[opt]\n///        \'::\'[opt] nested-name-specifier \'*\' cv-qualifier-seq[opt]\nvoid Parser::ParseDeclaratorInternal(Declarator &D, DirectDeclParseFunction DirectDeclParser) {\n  if (Kind == tok::star || Kind == tok::caret) {\n  } else {\n    // Complain about rvalue references in C++03, but then go on and build\n    // the declarator.\n    if (Kind == tok::ampamp)\n      Diag(Loc, getLangOpts().CPlusPlus11 ? diag::warn_cxx98_compat_rvalue_reference : diag::ext_rvalue_reference);"}}

[k]={{Mb,4343,"/// ParseEnumSpecifier\n///      enum-specifier: [C99 6.7.2.2]\n///        \'enum\' identifier[opt] \'{\' enumerator-list \'}\'\n///[C99/C++]\'enum\' identifier[opt] \'{\' enumerator-list \',\' \'}\'\n/// [GNU]  \'enum\' attributes[opt] identifier[opt] \'{\' enumerator-list \',\' [opt]\n///                                                \'}\' attributes[opt]\n/// [MS]    \'enum\' __declspec[opt] identifier[opt] \'{\' enumerator-list \',\' [opt]\n///                                                \'}\'\n///        \'enum\' identifier\n/// [GNU]  \'enum\' attributes[opt] identifier\n///\n/// [C++11] enum-head \'{\' enumerator-list[opt] \'}\'\n/// [C++11] enum-head \'{\' enumerator-list \',\'  \'}\'\n///\n///      enum-head: [C++11]\n///        enum-key attribute-specifier-seq[opt] identifier[opt] enum-base[opt]\n///        enum-key attribute-specifier-seq[opt] nested-name-specifier\n///            identifier enum-base[opt]\n///\n///      enum-key: [C++11]\n///        \'enum\'\n///        \'enum\' \'class\'\n///        \'enum\' \'struct\'\n///\n///      enum-base: [C++11]\n///        \':\' type-specifier-seq\n///\n/// [C++] elaborated-type-specifier:\n/// [C++]  \'enum\' nested-name-specifier[opt] identifier\n///\nvoid Parser::ParseEnumSpecifier(SourceLocation StartLoc, DeclSpec &DS, const ParsedTemplateInfo &TemplateInfo, AccessSpecifier AS, DeclSpecContext DSC) {\n  // In C++11, recognize \'enum class\' and \'enum struct\'.\n  if (Tok.isOneOf(tok::kw_class, tok::kw_struct) && getLangOpts().CPlusPlus) {\n    Diag(Tok, getLangOpts().CPlusPlus11 ? diag::warn_cxx98_compat_scoped_enum : diag::ext_scoped_enum);"}}

[k]={{"clang/lib/Sema/Sema.cpp",1373,"void Sema::EmitCurrentDiagnostic(unsigned DiagID) {\n  // FIXME: It doesn\'t make sense to me that DiagID is an incoming argument here\n  // and yet we also use the current diag ID on the DiagnosticsEngine. This has\n  // been made more painfully obvious by the refactor that introduced this\n  // function, but it is possible that the incoming argument can be\n  // eliminated. If it truly cannot be (for example, there is some reentrancy\n  // issue I am not seeing yet), then there should at least be a clarifying\n  // comment somewhere.\n  if (std::optional<TemplateDeductionInfo *> Info = isSFINAEContext()) {\n    case DiagnosticIDs::SFINAE_AccessControl: {\n      Diag(Loc, diag::warn_cxx98_compat_sfinae_access_control);"}}

[k]={{db,846,"/// ParseStaticAssertDeclaration - Parse C++0x or C11 static_assert-declaration.\n///\n/// [C++0x] static_assert-declaration:\n///          static_assert ( constant-expression  ,  string-literal  ) ;\n///\n/// [C11]  static_assert-declaration:\n///          _Static_assert ( constant-expression  ,  string-literal  ) ;\n///\nDecl *Parser::ParseStaticAssertDeclaration(SourceLocation &DeclEnd) {\n  if (Tok.is(tok::kw_static_assert)) {\n    if (!getLangOpts().CPlusPlus) {\n    } else\n      Diag(Tok, diag::warn_cxx98_compat_static_assert);"}}

[k]={{G,6765,"NamedDecl *Sema::ActOnVariableDeclarator(Scope *S, Declarator &D, DeclContext *DC, TypeSourceInfo *TInfo, LookupResult &Previous, MultiTemplateParamsArg TemplateParamLists, bool &AddToScope, ArrayRef<BindingDecl *> Bindings) {\n  if (!getLangOpts().CPlusPlus) {\n  } else {\n    if (SC == SC_Static && CurContext->isRecord()) {\n      if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(DC)) {\n        if (FunctionOrMethod) {\n        } else if (AnonStruct) {\n        } else if (RD->isUnion()) {\n          Diag(D.getIdentifierLoc(), getLangOpts().CPlusPlus11 ? diag::warn_cxx98_compat_static_data_member_in_union : diag::ext_static_data_member_in_union) << Name;"}}

[k]={{xd,639,"/// VerifyJumps - Verify each element of the Jumps array to see if they are\n/// valid, emitting diagnostics if not.\nvoid JumpScopeChecker::VerifyJumps() {\n  while (!Jumps.empty()) {\n    for (SwitchCase *SC = SS->getSwitchCaseList(); SC; SC = SC->getNextSwitchCase()) {\n      CheckJump(SS, SC, Loc, diag::err_switch_into_protected_scope, 0, diag::warn_cxx98_compat_switch_into_protected_scope);"}}

[k]={{fb,5884,"/// Check whether elidable copy construction for binding a reference to\n/// a temporary would have succeeded if we were building in C++98 mode, for\n/// -Wc++98-compat.\nstatic void CheckCXX98CompatAccessibleCopy(Sema &S, const InitializedEntity &Entity, Expr *CurInitExpr) {\n  if (S.Diags.isIgnored(diag::warn_cxx98_compat_temp_copy, Loc))"},{fb,5898,"/// Check whether elidable copy construction for binding a reference to\n/// a temporary would have succeeded if we were building in C++98 mode, for\n/// -Wc++98-compat.\nstatic void CheckCXX98CompatAccessibleCopy(Sema &S, const InitializedEntity &Entity, Expr *CurInitExpr) {\n  PartialDiagnostic Diag = S.PDiag(diag::warn_cxx98_compat_temp_copy) << OR << (int)Entity.getKind() << CurInitExpr->getType() << CurInitExpr->getSourceRange();"}}

[k]={{wb,5538,"/// Checks whether the given template argument is the address\n/// of an object or function according to C++ [temp.arg.nontype]p1.\nstatic bool CheckTemplateArgumentAddressOfObjectOrFunction(Sema &S, NonTypeTemplateParmDecl *Param, QualType ParamType, Expr *ArgIn, TemplateArgument &SugaredConverted, TemplateArgument &CanonicalConverted) {\n  if (S.getLangOpts().MicrosoftExt) {\n  } else {\n    while (ParenExpr *Parens = dyn_cast<ParenExpr>(Arg)) {\n      if (!Invalid && !ExtraParens) {\n        S.Diag(Arg->getBeginLoc(), S.getLangOpts().CPlusPlus11 ? diag::warn_cxx98_compat_template_arg_extra_parens : diag::ext_template_arg_extra_parens) << Arg->getSourceRange();"},{wb,5726,"/// Checks whether the given template argument is a pointer to\n/// member constant according to C++ [temp.arg.nontype]p1.\nstatic bool CheckTemplateArgumentPointerToMember(Sema &S, NonTypeTemplateParmDecl *Param, QualType ParamType, Expr *&ResultArg, TemplateArgument &SugaredConverted, TemplateArgument &CanonicalConverted) {\n  while (ParenExpr *Parens = dyn_cast<ParenExpr>(Arg)) {\n    if (!Invalid && !ExtraParens) {\n      S.Diag(Arg->getBeginLoc(), S.getLangOpts().CPlusPlus11 ? diag::warn_cxx98_compat_template_arg_extra_parens : diag::ext_template_arg_extra_parens) << Arg->getSourceRange();"}}

[k]={{wb,5270,"bool UnnamedLocalNoLinkageFinder::VisitTagDecl(const TagDecl *Tag) {\n  if (Tag->getDeclContext()->isFunctionOrMethod()) {\n    S.Diag(SR.getBegin(), S.getLangOpts().CPlusPlus11 ? diag::warn_cxx98_compat_template_arg_local_type : diag::ext_template_arg_local_type) << S.Context.getTypeDeclType(Tag) << SR;"}}

[k]={{wb,5570,"/// Checks whether the given template argument is the address\n/// of an object or function according to C++ [temp.arg.nontype]p1.\nstatic bool CheckTemplateArgumentAddressOfObjectOrFunction(Sema &S, NonTypeTemplateParmDecl *Param, QualType ParamType, Expr *ArgIn, TemplateArgument &SugaredConverted, TemplateArgument &CanonicalConverted) {\n  // If our parameter has pointer type, check for a null template value.\n  if (ParamType->isPointerType() || ParamType->isNullPtrType()) {\n    case NPV_NullPointer:\n      S.Diag(Arg->getExprLoc(), diag::warn_cxx98_compat_template_arg_null);"},{wb,5770,"/// Checks whether the given template argument is a pointer to\n/// member constant according to C++ [temp.arg.nontype]p1.\nstatic bool CheckTemplateArgumentPointerToMember(Sema &S, NonTypeTemplateParmDecl *Param, QualType ParamType, Expr *&ResultArg, TemplateArgument &SugaredConverted, TemplateArgument &CanonicalConverted) {\n  case NPV_NullPointer:\n    S.Diag(ResultArg->getExprLoc(), diag::warn_cxx98_compat_template_arg_null);"},{wb,6323,"/// Check a template argument against its corresponding\n/// non-type template parameter.\n///\n/// This routine implements the semantics of C++ [temp.arg.nontype].\n/// If an error occurred, it returns ExprError(); otherwise, it\n/// returns the converted template argument. \\p ParamType is the\n/// type of the non-type template parameter after it has been instantiated.\nExprResult Sema::CheckTemplateArgument(NonTypeTemplateParmDecl *Param, QualType ParamType, Expr *Arg, TemplateArgument &SugaredConverted, TemplateArgument &CanonicalConverted, CheckTemplateArgumentKind CTAK) {\n  // Deal with parameters of type std::nullptr_t.\n  if (ParamType->isNullPtrType()) {\n    case NPV_NullPointer:\n      Diag(Arg->getExprLoc(), diag::warn_cxx98_compat_template_arg_null);"}}

[k]={{wb,5629,"/// Checks whether the given template argument is the address\n/// of an object or function according to C++ [temp.arg.nontype]p1.\nstatic bool CheckTemplateArgumentAddressOfObjectOrFunction(Sema &S, NonTypeTemplateParmDecl *Param, QualType ParamType, Expr *ArgIn, TemplateArgument &SugaredConverted, TemplateArgument &CanonicalConverted) {\n  // Address / reference template args must have external linkage in C++98.\n  if (Entity->getFormalLinkage() == InternalLinkage) {\n    S.Diag(Arg->getBeginLoc(), S.getLangOpts().CPlusPlus11 ? diag::warn_cxx98_compat_template_arg_object_internal : diag::ext_template_arg_object_internal) << !Func << Entity << Arg->getSourceRange();"}}

[k]={{wb,5275,"bool UnnamedLocalNoLinkageFinder::VisitTagDecl(const TagDecl *Tag) {\n  if (!Tag->hasNameForLinkage()) {\n    S.Diag(SR.getBegin(), S.getLangOpts().CPlusPlus11 ? diag::warn_cxx98_compat_template_arg_unnamed_type : diag::ext_template_arg_unnamed_type) << SR;"}}

[k]={{wb,4210,"/// Form a template name from a name that is syntactically required to name a\n/// template, either due to use of the \'template\' keyword or because a name in\n/// this syntactic context is assumed to name a template (C++ [temp.names]p2-4).\n///\n/// This action forms a template name given the name of the template and its\n/// optional scope specifier. This is used when the \'template\' keyword is used\n/// or when the parsing context unambiguously treats a following \'<\' as\n/// introducing a template argument list. Note that this may produce a\n/// non-dependent template name if we can perform the lookup now and identify\n/// the named template.\n///\n/// For example, given \"x.MetaFun::template apply\", the scope specifier\n/// \\p SS will be \"MetaFun::\", \\p TemplateKWLoc contains the location\n/// of the \"template\" keyword, and \"apply\" is the \\p Name.\nTemplateNameKind Sema::ActOnTemplateName(Scope *S, CXXScopeSpec &SS, SourceLocation TemplateKWLoc, const UnqualifiedId &Name, ParsedType ObjectType, bool EnteringContext, TemplateTy &Result, bool AllowInjectedClassName) {\n  if (TemplateKWLoc.isValid() && S && !S->getTemplateParamParent())\n    Diag(TemplateKWLoc, getLangOpts().CPlusPlus11 ? diag::warn_cxx98_compat_template_outside_of_template : diag::ext_template_outside_of_template) << FixItHint::CreateRemoval(TemplateKWLoc);"}}

[k]={{wb,2274,"/// Diagnose the presence of a default template argument on a\n/// template parameter, which is ill-formed in certain contexts.\n///\n/// \\returns true if the default template argument should be dropped.\nstatic bool DiagnoseDefaultTemplateArgument(Sema &S, Sema::TemplateParamListContext TPC, SourceLocation ParamLoc, SourceRange DefArgRange) {\n  case Sema::TPC_FriendFunctionTemplateDefinition:\n    S.Diag(ParamLoc, S.getLangOpts().CPlusPlus11 ? diag::warn_cxx98_compat_template_parameter_default_in_function_template : diag::ext_template_parameter_default_in_function_template) << DefArgRange;"}}

[k]={{tc,179,"void Parser::ConsumeExtraSemi(ExtraSemiKind Kind, DeclSpec::TST TST) {\n  // C++11 allows extra semicolons at namespace scope, but not in any of the\n  // other contexts.\n  if (Kind == OutsideFunction && getLangOpts().CPlusPlus) {\n    if (getLangOpts().CPlusPlus11)\n      Diag(StartLoc, diag::warn_cxx98_compat_top_level_semi) << FixItHint::CreateRemoval(SourceRange(StartLoc, EndLoc));"}}

[k]={{Mb,6421,"/// ParseFunctionDeclarator - We are after the identifier and have parsed the\n/// declarator D up to a paren, which indicates that we are parsing function\n/// arguments.\n///\n/// If FirstArgAttrs is non-null, then the caller parsed those attributes\n/// immediately after the open paren - they will be applied to the DeclSpec\n/// of the first parameter.\n///\n/// If RequiresArg is true, then the first argument of the function is required\n/// to be present and required to not be an identifier list.\n///\n/// For C++, after the parameter-list, it also parses the cv-qualifier-seq[opt],\n/// (C++11) ref-qualifier[opt], exception-specification[opt],\n/// (C++11) attribute-specifier-seq[opt], (C++11) trailing-return-type[opt] and\n/// (C++2a) the trailing requires-clause.\n///\n/// [C++11] exception-specification:\n///          dynamic-exception-specification\n///          noexcept-specification\n///\nvoid Parser::ParseFunctionDeclarator(Declarator &D, ParsedAttributes &FirstArgAttrs, BalancedDelimiterTracker &Tracker, bool IsAmbiguous, bool RequiresArg) {\n  if (isFunctionDeclaratorIdentifierList()) {\n  } else {\n    if (getLangOpts().CPlusPlus) {\n      if (getLangOpts().CPlusPlus11 && Tok.is(tok::arrow)) {\n        Diag(Tok, diag::warn_cxx98_compat_trailing_return_type);"}}

[k]={{"clang/lib/Parse/ParseTemplate.cpp",1048,"/// Parses a \'>\' at the end of a template list.\n///\n/// If this function encounters \'>>\', \'>>>\', \'>=\', or \'>>=\', it tries\n/// to determine if these tokens were supposed to be a \'>\' followed by\n/// \'>\', \'>>\', \'>=\', or \'>=\'. It emits an appropriate diagnostic if necessary.\n///\n/// \\param RAngleLoc the location of the consumed \'>\'.\n///\n/// \\param ConsumeLastToken if true, the \'>\' is consumed.\n///\n/// \\param ObjCGenericList if true, this is the \'>\' closing an Objective-C\n/// type parameter or type argument list, rather than a C++ template parameter\n/// or argument list.\n///\n/// \\returns true, if current token does not start with \'>\', false otherwise.\nbool Parser::ParseGreaterThanInTemplateList(SourceLocation LAngleLoc, SourceLocation &RAngleLoc, bool ConsumeLastToken, bool ObjCGenericList) {\n  // Diagnose this situation as appropriate.\n  if (!ObjCGenericList) {\n    if (getLangOpts().CPlusPlus11 && (Tok.is(tok::greatergreater) || Tok.is(tok::greatergreatergreater)))\n      DiagId = diag::warn_cxx98_compat_two_right_angle_brackets;"}}

[k]={{wb,8898,"TypeResult Sema::ActOnTypenameType(Scope *S, SourceLocation TypenameLoc, const CXXScopeSpec &SS, const IdentifierInfo &II, SourceLocation IdLoc, ImplicitTypenameContext IsImplicitTypename) {\n  if (TypenameLoc.isValid() && S && !S->getTemplateParamParent())\n    Diag(TypenameLoc, getLangOpts().CPlusPlus11 ? diag::warn_cxx98_compat_typename_outside_of_template : diag::ext_typename_outside_of_template) << FixItHint::CreateRemoval(TypenameLoc);"},{wb,8911,"TypeResult Sema::ActOnTypenameType(Scope *S, SourceLocation TypenameLoc, const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, TemplateTy TemplateIn, IdentifierInfo *TemplateII, SourceLocation TemplateIILoc, SourceLocation LAngleLoc, ASTTemplateArgsPtr TemplateArgsIn, SourceLocation RAngleLoc) {\n  if (TypenameLoc.isValid() && S && !S->getTemplateParamParent())\n    Diag(TypenameLoc, getLangOpts().CPlusPlus11 ? diag::warn_cxx98_compat_typename_outside_of_template : diag::ext_typename_outside_of_template) << FixItHint::CreateRemoval(TypenameLoc);"}}

[k]={{F,14668,"/// Perform semantic analysis of the given friend type declaration.\n///\n/// \\returns A friend declaration that.\nFriendDecl *Sema::CheckFriendTypeDecl(SourceLocation LocStart, SourceLocation FriendLoc, TypeSourceInfo *TSInfo) {\n  // C++03 [class.friend]p2:\n  //  An elaborated-type-specifier shall be used in a friend declaration\n  //  for a class.*\n  //\n  //  * The class-key of the elaborated-type-specifier is required.\n  if (!CodeSynthesisContexts.empty()) {\n  } else {\n    if (!T->isElaboratedTypeSpecifier()) {\n      // If we evaluated the type to a record type, suggest putting\n      // a tag in front.\n      if (const RecordType *RT = T->getAs<RecordType>()) {\n        Diag(TypeRange.getBegin(), getLangOpts().CPlusPlus11 ? diag::warn_cxx98_compat_unelaborated_friend_type : diag::ext_unelaborated_friend_type) << (unsigned)RD->getTagKind() << T << FixItHint::CreateInsertion(getLocForEndOfToken(FriendLoc), InsertionText);"}}

[k]={{vb,1886,"/// LexStringLiteral - Lex the remainder of a string literal, after having lexed\n/// either \" or L\" or u8\" or u\" or U\".\nbool Lexer::LexStringLiteral(Token &Result, const char *CurPtr, tok::TokenKind Kind) {\n  if (!isLexingRawMode() && (Kind == tok::utf8_string_literal || Kind == tok::utf16_string_literal || Kind == tok::utf32_string_literal))\n    Diag(BufferPtr, LangOpts.CPlusPlus ? diag::warn_cxx98_compat_unicode_literal : diag::warn_c99_compat_unicode_literal);"},{vb,2089,"/// LexCharConstant - Lex the remainder of a character constant, after having\n/// lexed either \' or L\' or u8\' or u\' or U\'.\nbool Lexer::LexCharConstant(Token &Result, const char *CurPtr, tok::TokenKind Kind) {\n  if (!isLexingRawMode()) {\n    if (Kind == tok::utf16_char_constant || Kind == tok::utf32_char_constant)\n      Diag(BufferPtr, LangOpts.CPlusPlus ? diag::warn_cxx98_compat_unicode_literal : diag::warn_c99_compat_unicode_literal);"}}

[k]={{dc,1232,"/// Finish - This does final analysis of the declspec, rejecting things like\n/// \"_Imaginary\" (lacking an FP type). After calling this method, DeclSpec is\n/// guaranteed to be self-consistent, even if an error occurred.\nvoid DeclSpec::Finish(Sema &S, const PrintingPolicy &Policy) {\n  if (TypeSpecType == TST_char8)\n  else if (TypeSpecType == TST_char16 || TypeSpecType == TST_char32)\n    S.Diag(TSTLoc, diag::warn_cxx98_compat_unicode_type) << (TypeSpecType == TST_char16 ? \"char16_t\" : \"char32_t\");"}}

[k]={{F,10353,"Decl *Sema::ActOnUsingDeclaration(Scope *S, AccessSpecifier AS, SourceLocation UsingLoc, SourceLocation TypenameLoc, CXXScopeSpec &SS, UnqualifiedId &Name, SourceLocation EllipsisLoc, const ParsedAttributesView &AttrList) {\n  case UnqualifiedIdKind::IK_ConstructorTemplateId:\n    Diag(Name.getBeginLoc(), getLangOpts().CPlusPlus11 ? diag::warn_cxx98_compat_using_decl_constructor : diag::err_using_decl_constructor) << SS.getRange();"}}

[k]={{pd,2435,"/// ReadMacroParameterList - The ( starting a parameter list of a macro\n/// definition has just been read.  Lex the rest of the parameters and the\n/// closing ), updating MI with what we learn.  Return true if an error occurs\n/// parsing the param list.\nbool Preprocessor::ReadMacroParameterList(MacroInfo *MI, Token &Tok) {\n  while (true) {\n    case tok::ellipsis: // #define X(... -> C99 varargs\n      if (!LangOpts.C99)\n        Diag(Tok, LangOpts.CPlusPlus11 ? diag::warn_cxx98_compat_variadic_macro : diag::ext_variadic_macro);"}}

[k]={{"clang/lib/Parse/ParseTemplate.cpp",735,"/// ParseTypeParameter - Parse a template type parameter (C++ [temp.param]).\n/// Other kinds of template parameters are parsed in\n/// ParseTemplateTemplateParameter and ParseNonTypeTemplateParameter.\n///\n///      type-parameter:    [C++ temp.param]\n///        \'class\' ...[opt][C++0x] identifier[opt]\n///        \'class\' identifier[opt] \'=\' type-id\n///        \'typename\' ...[opt][C++0x] identifier[opt]\n///        \'typename\' identifier[opt] \'=\' type-id\nNamedDecl *Parser::ParseTypeParameter(unsigned Depth, unsigned Position) {\n  if (TryConsumeToken(tok::ellipsis, EllipsisLoc)) {\n    Diag(EllipsisLoc, getLangOpts().CPlusPlus11 ? diag::warn_cxx98_compat_variadic_templates : diag::ext_variadic_templates);"},{"clang/lib/Parse/ParseTemplate.cpp",838,"/// ParseTemplateTemplateParameter - Handle the parsing of template\n/// template parameters.\n///\n///      type-parameter:    [C++ temp.param]\n///        template-head type-parameter-key ...[opt] identifier[opt]\n///        template-head type-parameter-key identifier[opt] = id-expression\n///      type-parameter-key:\n///        \'class\'\n///        \'typename\'      [C++1z]\n///      template-head:    [C++2a]\n///        \'template\' \'<\' template-parameter-list \'>\'\n///            requires-clause[opt]\nNamedDecl *Parser::ParseTemplateTemplateParameter(unsigned Depth, unsigned Position) {\n  if (TryConsumeToken(tok::ellipsis, EllipsisLoc))\n    Diag(EllipsisLoc, getLangOpts().CPlusPlus11 ? diag::warn_cxx98_compat_variadic_templates : diag::ext_variadic_templates);"},{Cb,5224,"static TypeSourceInfo *GetFullTypeForDeclarator(TypeProcessingState &state, QualType declSpecType, TypeSourceInfo *TInfo) {\n  // If there was an ellipsis in the declarator, the declaration declares a\n  // parameter pack whose type may be a pack expansion type.\n  if (D.hasEllipsis()) {\n    case DeclaratorContext::TemplateParam:\n      // C++0x [temp.param]p15:\n      //  If a template-parameter is a [...] is a parameter-declaration that\n      //  declares a parameter pack (8.3.5), then the template-parameter is a\n      //  template parameter pack (14.5.3).\n      //\n      // Note: core issue 778 clarifies that, if there are any unexpanded\n      // parameter packs in the type of the non-type template parameter, then\n      // it expands those parameter packs.\n      if (T->containsUnexpandedParameterPack())\n      else\n        S.Diag(D.getEllipsisLoc(), LangOpts.CPlusPlus11 ? diag::warn_cxx98_compat_variadic_templates : diag::ext_variadic_templates);"}}

[k]={{F,6139,"/// Perform semantic checks on a class definition that has been\n/// completing, introducing implicitly-declared members, checking for\n/// abstract types, etc.\n///\n/// \\param S The scope in which the class was parsed. Null if we didn\'t just\n///        parse a class definition.\n/// \\param Record The completed class.\nvoid Sema::CheckCompletedCXXClass(Scope *S, CXXRecordDecl *Record) {\n  // ms_struct is a request to use the same ABI rules as MSVC.  Check\n  // whether this class uses any C++ features that are implemented\n  // completely differently in MSVC, and if so, emit a diagnostic.\n  // That diagnostic defaults to an error, but we allow projects to\n  // map it down to a warning (or ignore it).  It\'s a fairly common\n  // practice among users of the ms_struct pragma to mass-annotate\n  // headers, sweeping up a bunch of types that the project doesn\'t\n  // really rely on MSVC-compatible layout for.  We must therefore\n  // support \"ms_struct except for C++ stuff\" as a secondary ABI.\n  // Don\'t emit this diagnostic if the feature was enabled as a\n  // language option (as opposed to via a pragma or attribute), as\n  // the option -mms-bitfields otherwise essentially makes it impossible\n  // to build C++ code, unless this diagnostic is turned off.\n  if (Record->isMsStruct(Context) && !Context.getLangOpts().MSBitfields && (Record->isPolymorphic() || Record->getNumBases())) {\n    Diag(Record->getLocation(), diag::warn_cxx_ms_struct);"}}

[k]={{Yb,1500,"/// ParseIfStatement\n///      if-statement: [C99 6.8.4.1]\n///        \'if\' \'(\' expression \')\' statement\n///        \'if\' \'(\' expression \')\' statement \'else\' statement\n/// [C++]  \'if\' \'(\' condition \')\' statement\n/// [C++]  \'if\' \'(\' condition \')\' statement \'else\' statement\n/// [C++23] \'if\' \'!\' [opt] consteval compound-statement\n/// [C++23] \'if\' \'!\' [opt] consteval compound-statement \'else\' statement\n///\nStmtResult Parser::ParseIfStatement(SourceLocation *TrailingElseLoc) {\n  if (Tok.is(tok::kw_else)) {\n  } else if (Tok.is(tok::code_completion)) {\n  } else if (InnerStatementTrailingElseLoc.isValid()) {\n    Diag(InnerStatementTrailingElseLoc, diag::warn_dangling_else);"}}

[k]={{fb,6923,"void Sema::checkInitializerLifetime(const InitializedEntity &Entity, Expr *Init) {\n  auto TemporaryVisitor = [&](IndirectLocalPath &Path, Local L, ReferenceKind RK) -> bool {\n    case LK_Extended: {\n      if (IsGslPtrInitWithGslTempOwner && DiagLoc.isValid()) {\n        Diag(DiagLoc, diag::warn_dangling_lifetime_pointer) << DiagRange;"},{fb,7018,"void Sema::checkInitializerLifetime(const InitializedEntity &Entity, Expr *Init) {\n  auto TemporaryVisitor = [&](IndirectLocalPath &Path, Local L, ReferenceKind RK) -> bool {\n    case LK_New:\n      if (isa<MaterializeTemporaryExpr>(L)) {\n        if (IsGslPtrInitWithGslTempOwner)\n          Diag(DiagLoc, diag::warn_dangling_lifetime_pointer) << DiagRange;"},{fb,7094,"void Sema::checkInitializerLifetime(const InitializedEntity &Entity, Expr *Init) {\n  bool EnableLifetimeWarnings = !getDiagnostics().isIgnored(diag::warn_dangling_lifetime_pointer, SourceLocation());"}}

[k]={{fb,6965,"void Sema::checkInitializerLifetime(const InitializedEntity &Entity, Expr *Init) {\n  auto TemporaryVisitor = [&](IndirectLocalPath &Path, Local L, ReferenceKind RK) -> bool {\n    case LK_MemInitializer: {\n      if (isa<MaterializeTemporaryExpr>(L)) {\n        // Under C++ DR1696, if a mem-initializer (or a default member\n        // initializer used by the absence of one) would lifetime-extend a\n        // temporary, the program is ill-formed.\n        if (auto *ExtendingDecl = ExtendingEntity ? ExtendingEntity->getDecl() : nullptr) {\n          if (IsGslPtrInitWithGslTempOwner) {\n            Diag(DiagLoc, diag::warn_dangling_lifetime_pointer_member) << ExtendingDecl << DiagRange;"}}

[k]={{fb,6970,"void Sema::checkInitializerLifetime(const InitializedEntity &Entity, Expr *Init) {\n  auto TemporaryVisitor = [&](IndirectLocalPath &Path, Local L, ReferenceKind RK) -> bool {\n    case LK_MemInitializer: {\n      if (isa<MaterializeTemporaryExpr>(L)) {\n        // Under C++ DR1696, if a mem-initializer (or a default member\n        // initializer used by the absence of one) would lifetime-extend a\n        // temporary, the program is ill-formed.\n        if (auto *ExtendingDecl = ExtendingEntity ? ExtendingEntity->getDecl() : nullptr) {\n          Diag(DiagLoc, shouldLifetimeExtendThroughPath(Path) != PathLifetimeKind::NoExtend ? diag::err_dangling_member : diag::warn_dangling_member) << ExtendingDecl << IsSubobjectMember << RK << DiagRange;"}}

[k]={{fb,6952,"void Sema::checkInitializerLifetime(const InitializedEntity &Entity, Expr *Init) {\n  auto TemporaryVisitor = [&](IndirectLocalPath &Path, Local L, ReferenceKind RK) -> bool {\n    case LK_Extended: {\n      case PathLifetimeKind::NoExtend:\n        Diag(DiagLoc, diag::warn_dangling_variable) << RK << !Entity.getParent() << ExtendingEntity->getDecl()->isImplicit() << ExtendingEntity->getDecl() << Init->isGLValue() << DiagRange;"}}

[k]={{mc,4108,"Decl *Sema::ActOnMethodDeclaration(Scope *S, SourceLocation MethodLoc, SourceLocation EndLoc, tok::TokenKind MethodType, ObjCDeclSpec &ReturnQT, ParsedType ReturnType, ArrayRef<SourceLocation> SelectorLocs, Selector Sel,\n  if (ObjCImplDecl *ImpDecl = dyn_cast<ObjCImplDecl>(ClassDecl)) {\n    // Merge information from the @interface declaration into the\n    // @implementation.\n    if (ObjCInterfaceDecl *IDecl = ImpDecl->getClassInterface()) {\n      if (auto *IMD = IDecl->lookupMethod(ObjCMethod->getSelector(), ObjCMethod->isInstanceMethod())) {\n        // Warn about defining -dealloc in a category.\n        if (isa<ObjCCategoryImplDecl>(ImpDecl) && IMD->isOverriding() && ObjCMethod->getSelector().getMethodFamily() == OMF_dealloc) {\n          Diag(ObjCMethod->getLocation(), diag::warn_dealloc_in_category) << ObjCMethod->getDeclName();"}}

[k]={{U,905,"static void RenderDebugInfoCompressionArgs(const ArgList &Args, ArgStringList &CmdArgs, const Driver &D, const ToolChain &TC) {\n  if (checkDebugInfoOption(A, Args, D, TC)) {\n    if (Value == \"none\") {\n    } else if (Value == \"zlib\") {\n      if (llvm::compression::zlib::isAvailable()) {\n      } else {\n        D.Diag(diag::warn_debug_compression_unavailable) << \"zlib\";"},{U,911,"static void RenderDebugInfoCompressionArgs(const ArgList &Args, ArgStringList &CmdArgs, const Driver &D, const ToolChain &TC) {\n  if (checkDebugInfoOption(A, Args, D, TC)) {\n    if (Value == \"none\") {\n    } else if (Value == \"zlib\") {\n    } else if (Value == \"zstd\") {\n      if (llvm::compression::zstd::isAvailable()) {\n      } else {\n        D.Diag(diag::warn_debug_compression_unavailable) << \"zstd\";"}}

[k]={{G,15421,"CreateNewDecl:\n  // If we\'re declaring or defining a tag in function prototype scope in C,\n  // note that this type can only be used within the function and add it to\n  // the list of decls to inject into the function definition scope.\n  if ((Name || Kind == TTK_Enum) && getNonFieldDeclScope(S)->isFunctionPrototypeScope()) {\n    if (getLangOpts().CPlusPlus) {\n    } else if (!PrevDecl) {\n      Diag(Loc, diag::warn_decl_in_param_list) << Context.getTagDeclType(New);"}}

[k]={{G,7182,"/// Enum describing the %select options in diag::warn_decl_shadow."},{G,7215,"static bool shouldWarnIfShadowedDecl(const DiagnosticsEngine &Diags, const LookupResult &R) {\n  return !Diags.isIgnored(diag::warn_decl_shadow, R.getNameLoc());"},{G,7298,"/// Diagnose variable or built-in function shadowing.  Implements\n/// -Wshadow.\n///\n/// This method is called whenever a VarDecl is added to a \"useful\"\n/// scope.\n///\n/// \\param ShadowedDecl the declaration that is shadowed by the given variable\n/// \\param R the lookup of the name\n///\nvoid Sema::CheckShadow(NamedDecl *D, NamedDecl *ShadowedDecl, const LookupResult &R) {\n  unsigned WarningDiag = diag::warn_decl_shadow;"},{G,7364,"/// Diagnose shadowing for variables shadowed in the lambda record \\p LambdaRD\n/// when these variables are captured by the lambda.\nvoid Sema::DiagnoseShadowingLambdaDecls(const LambdaScopeInfo *LSI) {\n  for (const auto &Shadow : LSI->ShadowingDecls) {\n    Diag(Shadow.VD->getLocation(), CaptureLoc.isInvalid() ? diag::warn_decl_shadow_uncaptured_local : diag::warn_decl_shadow) << Shadow.VD->getDeclName() << computeShadowedDeclKind(ShadowedDecl, OldDC) << OldDC;"},{G,7373,"/// Check -Wshadow without the advantage of a previous lookup.\nvoid Sema::CheckShadow(Scope *S, VarDecl *D) {\n  if (Diags.isIgnored(diag::warn_decl_shadow, D->getLocation()))"}}

[k]={{G,7309,"/// Diagnose variable or built-in function shadowing.  Implements\n/// -Wshadow.\n///\n/// This method is called whenever a VarDecl is added to a \"useful\"\n/// scope.\n///\n/// \\param ShadowedDecl the declaration that is shadowed by the given variable\n/// \\param R the lookup of the name\n///\nvoid Sema::CheckShadow(NamedDecl *D, NamedDecl *ShadowedDecl, const LookupResult &R) {\n  if (isa<VarDecl>(D) && isa<VarDecl>(ShadowedDecl) && NewDC && isa<CXXMethodDecl>(NewDC)) {\n    if (const auto *RD = dyn_cast<CXXRecordDecl>(NewDC->getParent())) {\n      if (RD->isLambda() && OldDC->Encloses(NewDC->getLexicalParent())) {\n        if (RD->getLambdaCaptureDefault() == LCD_None) {\n          if (CaptureLoc.isInvalid())\n            WarningDiag = diag::warn_decl_shadow_uncaptured_local;"},{G,7364,"/// Diagnose shadowing for variables shadowed in the lambda record \\p LambdaRD\n/// when these variables are captured by the lambda.\nvoid Sema::DiagnoseShadowingLambdaDecls(const LambdaScopeInfo *LSI) {\n  for (const auto &Shadow : LSI->ShadowingDecls) {\n    Diag(Shadow.VD->getLocation(), CaptureLoc.isInvalid() ? diag::warn_decl_shadow_uncaptured_local : diag::warn_decl_shadow) << Shadow.VD->getDeclName() << computeShadowedDeclKind(ShadowedDecl, OldDC) << OldDC;"}}

[k]={{H,7537,"static void handleMSAllocatorAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n  // Warn if the return type is not a pointer or reference type.\n  if (auto *FD = dyn_cast<FunctionDecl>(D)) {\n    if (!RetTy->isPointerType() && !RetTy->isReferenceType()) {\n      S.Diag(AL.getLoc(), diag::warn_declspec_allocator_nonpointer) << AL.getRange() << RetTy;"}}

[k]={{G,4739,"/// ParsedFreeStandingDeclSpec - This method is invoked when a declspec with\n/// no declarator (e.g. \"struct foo;\") is parsed. It also accepts template\n/// parameters to cope with template friend declarations.\nDecl *Sema::ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS, DeclSpec &DS, const ParsedAttributesView &DeclAttrs, MultiTemplateParamsArg TemplateParams, bool IsExplicitInstantiation, RecordDecl *&AnonRecord) {\n  // Warn about ignored type attributes, for example:\n  // __attribute__((aligned)) struct A;\n  // Attributes should be placed after tag to apply to type declaration.\n  if (!DS.getAttributes().empty() || !DeclAttrs.empty()) {\n    if (TypeSpecType == DeclSpec::TST_class || TypeSpecType == DeclSpec::TST_struct || TypeSpecType == DeclSpec::TST_interface || TypeSpecType == DeclSpec::TST_union || TypeSpecType == DeclSpec::TST_enum) {\n      for (const ParsedAttr &AL : DS.getAttributes())\n        Diag(AL.getLoc(), AL.isRegularKeywordAttribute() ? diag::err_declspec_keyword_has_no_effect : diag::warn_declspec_attribute_ignored) << AL << GetDiagnosticTypeSpecifierID(DS);"},{G,4741,"/// ParsedFreeStandingDeclSpec - This method is invoked when a declspec with\n/// no declarator (e.g. \"struct foo;\") is parsed. It also accepts template\n/// parameters to cope with template friend declarations.\nDecl *Sema::ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS, DeclSpec &DS, const ParsedAttributesView &DeclAttrs, MultiTemplateParamsArg TemplateParams, bool IsExplicitInstantiation, RecordDecl *&AnonRecord) {\n  // Warn about ignored type attributes, for example:\n  // __attribute__((aligned)) struct A;\n  // Attributes should be placed after tag to apply to type declaration.\n  if (!DS.getAttributes().empty() || !DeclAttrs.empty()) {\n    if (TypeSpecType == DeclSpec::TST_class || TypeSpecType == DeclSpec::TST_struct || TypeSpecType == DeclSpec::TST_interface || TypeSpecType == DeclSpec::TST_union || TypeSpecType == DeclSpec::TST_enum) {\n      for (const ParsedAttr &AL : DeclAttrs)\n        Diag(AL.getLoc(), AL.isRegularKeywordAttribute() ? diag::err_declspec_keyword_has_no_effect : diag::warn_declspec_attribute_ignored) << AL << GetDiagnosticTypeSpecifierID(DS);"}}

[k]={{"clang/lib/Sema/SemaExceptionSpec.cpp",838,"bool Sema::CheckExceptionSpecCompatibility(Expr *From, QualType ToType) {\n  // This is not an error in C++17 onwards, unless the noexceptness doesn\'t\n  // match, but in that case we have a full-on type mismatch, not just a\n  // type sugar mismatch.\n  if (getLangOpts().CPlusPlus17) {\n    NestedDiagID = diag::warn_deep_exception_specs_differ;"}}

[k]={{xb,1371,"StmtResult Sema::ActOnFinishSwitchStmt(SourceLocation SwitchLoc, Stmt *Switch, Stmt *BodyStmt) {\n  if (!HasDependentValue) {\n    // If switch has default case, then ignore it.\n    if (!CaseListIsErroneous && !CaseListIsIncomplete && !HasConstantCond && ET && ET->getDecl()->isCompleteDefinition() && !ET->getDecl()->enumerators().empty()) {\n      // Produce a nice diagnostic if multiple values aren\'t handled.\n      if (!UnhandledNames.empty()) {\n        auto DB = Diag(CondExpr->getExprLoc(), TheDefaultStmt ? diag::warn_def_missing_case : diag::warn_missing_case) << CondExpr->getSourceRange() << (int)UnhandledNames.size();"}}

[k]={{Gc,1749,"void Sema::AtomicPropertySetterGetterRules(ObjCImplDecl *IMPDecl, ObjCInterfaceDecl *IDecl) {\n  for (ObjCContainerDecl::PropertyMap::iterator I = PM.begin(), E = PM.end(); I != E; ++I) {\n    if (!(AttributesAsWritten & ObjCPropertyAttribute::kind_atomic) && !(AttributesAsWritten & ObjCPropertyAttribute::kind_nonatomic)) {\n      if (GetterMethod) {\n        Diag(GetterMethod->getLocation(), diag::warn_default_atomic_custom_getter_setter) << Property->getIdentifier() << 0;"},{Gc,1753,"void Sema::AtomicPropertySetterGetterRules(ObjCImplDecl *IMPDecl, ObjCInterfaceDecl *IDecl) {\n  for (ObjCContainerDecl::PropertyMap::iterator I = PM.begin(), E = PM.end(); I != E; ++I) {\n    if (!(AttributesAsWritten & ObjCPropertyAttribute::kind_atomic) && !(AttributesAsWritten & ObjCPropertyAttribute::kind_nonatomic)) {\n      if (SetterMethod) {\n        Diag(SetterMethod->getLocation(), diag::warn_default_atomic_custom_getter_setter) << Property->getIdentifier() << 1;"}}

[k]={{F,7591,"bool Sema::CheckExplicitlyDefaultedComparison(Scope *S, FunctionDecl *FD, DefaultedComparisonKind DCK) {\n  // If we want to delete the function, then do so; there\'s nothing else to\n  // check in that case.\n  if (Info.Deleted) {\n    if (!inTemplateInstantiation() && !FD->isImplicit()) {\n      Diag(FD->getLocation(), diag::warn_defaulted_comparison_deleted) << (int)DCK;"}}

[k]={{F,6637,"bool Sema::CheckExplicitlyDefaultedSpecialMember(CXXMethodDecl *MD, CXXSpecialMember CSM, SourceLocation DefaultLoc) {\n  if (ShouldDeleteForTypeMismatch || ShouldDeleteSpecialMember(MD, CSM)) {\n    if (First) {\n      if (!inTemplateInstantiation() && !HadError) {\n        Diag(MD->getLocation(), diag::warn_defaulted_method_deleted) << CSM;"}}

[k]={{"clang/lib/Lex/PPExpressions.cpp",201,"/// EvaluateDefined - Process a \'defined(sym)\' expression.\nstatic bool EvaluateDefined(PPValue &Result, Token &PeekTok, DefinedTracker &DT, bool ValueLive, Preprocessor &PP) {\n  // [cpp.cond]p4:\n  //  Prior to evaluation, macro invocations in the list of preprocessing\n  //  tokens that will become the controlling constant expression are replaced\n  //  (except for those macro names modified by the \'defined\' unary operator),\n  //  just as in normal text. If the token \'defined\' is generated as a result\n  //  of this replacement process or use of the \'defined\' unary operator does\n  //  not match one of the two specified forms prior to macro replacement, the\n  //  behavior is undefined.\n  // This isn\'t an idle threat, consider this program:\n  //  #define FOO\n  //  #define BAR defined(FOO)\n  //  #if BAR\n  //  ...\n  //  #else\n  //  ...\n  //  #endif\n  // clang and gcc will pick the #if branch while Visual Studio will take the\n  // #else branch.  Emit a warning about this undefined behavior.\n  if (beginLoc.isMacroID()) {\n    // For object-type macros, it\'s easy to replace\n    //  #define FOO defined(BAR)\n    // with\n    //  #if defined(BAR)\n    //  #define FOO 1\n    //  #else\n    //  #define FOO 0\n    //  #endif\n    // and doing so makes sense since compilers handle this differently in\n    // practice (see example further up).  But for function-type macros,\n    // there is no good way to write\n    //  # define FOO(x) (defined(M_ ## x) && M_ ## x)\n    // in a different way, and compilers seem to agree on how to behave here.\n    // So warn by default on object-type macros, but only warn in -pedantic\n    // mode on function-type macros.\n    if (IsFunctionTypeMacro)\n      PP.Diag(beginLoc, diag::warn_defined_in_function_type_macro);"}}

[k]={{"clang/lib/Lex/PPExpressions.cpp",203,"/// EvaluateDefined - Process a \'defined(sym)\' expression.\nstatic bool EvaluateDefined(PPValue &Result, Token &PeekTok, DefinedTracker &DT, bool ValueLive, Preprocessor &PP) {\n  // [cpp.cond]p4:\n  //  Prior to evaluation, macro invocations in the list of preprocessing\n  //  tokens that will become the controlling constant expression are replaced\n  //  (except for those macro names modified by the \'defined\' unary operator),\n  //  just as in normal text. If the token \'defined\' is generated as a result\n  //  of this replacement process or use of the \'defined\' unary operator does\n  //  not match one of the two specified forms prior to macro replacement, the\n  //  behavior is undefined.\n  // This isn\'t an idle threat, consider this program:\n  //  #define FOO\n  //  #define BAR defined(FOO)\n  //  #if BAR\n  //  ...\n  //  #else\n  //  ...\n  //  #endif\n  // clang and gcc will pick the #if branch while Visual Studio will take the\n  // #else branch.  Emit a warning about this undefined behavior.\n  if (beginLoc.isMacroID()) {\n    // For object-type macros, it\'s easy to replace\n    //  #define FOO defined(BAR)\n    // with\n    //  #if defined(BAR)\n    //  #define FOO 1\n    //  #else\n    //  #define FOO 0\n    //  #endif\n    // and doing so makes sense since compilers handle this differently in\n    // practice (see example further up).  But for function-type macros,\n    // there is no good way to write\n    //  # define FOO(x) (defined(M_ ## x) && M_ ## x)\n    // in a different way, and compilers seem to agree on how to behave here.\n    // So warn by default on object-type macros, but only warn in -pedantic\n    // mode on function-type macros.\n    if (IsFunctionTypeMacro)\n    else\n      PP.Diag(beginLoc, diag::warn_defined_in_object_type_macro);"}}

[k]={{"clang/lib/Sema/Sema.cpp",1056,"/// ActOnEndOfTranslationUnit - This is called at the very end of the\n/// translation unit when EOF is reached and all but the top-level scope is\n/// popped.\nvoid Sema::ActOnEndOfTranslationUnit() {\n  if (LangOpts.CPlusPlus11 && !Diags.isIgnored(diag::warn_delegating_ctor_cycle, SourceLocation()))"},{F,15847,"static void DelegatingCycleHelper(CXXConstructorDecl *Ctor, llvm::SmallPtrSet<CXXConstructorDecl *, 4> &Valid, llvm::SmallPtrSet<CXXConstructorDecl *, 4> &Invalid, llvm::SmallPtrSet<CXXConstructorDecl *, 4> &Current, Sema &S) {\n  // We know that beyond here, we aren\'t chaining into a cycle.\n  if (!Target || !Target->isDelegatingConstructor() || Target->isInvalidDecl() || Valid.count(TCanonical)) {\n  } else if (TCanonical == Canonical || Invalid.count(TCanonical) || Current.count(TCanonical)) {\n    // If we haven\'t diagnosed this cycle yet, do so now.\n    if (!Invalid.count(TCanonical)) {\n      S.Diag((*Ctor->init_begin())->getSourceLocation(), diag::warn_delegating_ctor_cycle) << Ctor;"}}

[k]={{Sb,3363,"void Sema::CheckVirtualDtorCall(CXXDestructorDecl *dtor, SourceLocation Loc, bool IsDelete, bool CallCanBeVirtual, bool WarnOnNonAbstractTypes, SourceLocation DtorLoc) {\n  if (PointeeRD->isAbstract()) {\n    Diag(Loc, diag::warn_delete_abstract_non_virtual_dtor) << (IsDelete ? 0 : 1) << ClassType;"}}

[k]={{Sb,3147,"/// ActOnCXXDelete - Parsed a C++ \'delete\' expression (C++ 5.3.5), as in:\n/// @code ::delete ptr; @endcode\n/// or\n/// @code delete [] ptr; @endcode\nExprResult Sema::ActOnCXXDelete(SourceLocation StartLoc, bool UseGlobal, bool ArrayForm, Expr *ExE) {\n  if (!Ex.get()->isTypeDependent()) {\n    if (Pointee->isArrayType() && !ArrayForm) {\n      Diag(StartLoc, diag::warn_delete_array_type) << Type << Ex.get()->getSourceRange() << FixItHint::CreateInsertion(getLocForEndOfToken(StartLoc), \"[]\");"}}