Module:ClangDiags/DiagsLongData9: Difference between revisions

[j]={{Jc,1413,"bool CompilerInstance::loadModuleFile(StringRef FileName) {\n  bool ConfigMismatchIsRecoverable = getDiagnostics().getDiagnosticLevel(diag::warn_module_config_mismatch, SourceLocation()) <= DiagnosticsEngine::Warning;"},{Jc,1429,"bool CompilerInstance::loadModuleFile(StringRef FileName) {\n  case ASTReader::ConfigurationMismatch:\n    getDiagnostics().Report(SourceLocation(), diag::warn_module_config_mismatch) << FileName;"},{Jc,1543,"ModuleLoadResult CompilerInstance::findOrCompileModuleAndReadAST(StringRef ModuleName, SourceLocation ImportLoc, SourceLocation ModuleNameLoc, bool IsInclusionDirective) {\n  case ASTReader::ConfigurationMismatch:\n    if (Source == MS_PrebuiltModulePath)\n      getDiagnostics().Report(SourceLocation(), diag::warn_module_config_mismatch) << ModuleFilename;"}}

[j]={{jc,1250,"void Preprocessor::makeModuleVisible(Module *M, SourceLocation Loc) {\n  CurSubmoduleState->VisibleModules.setVisible(\n      [&](ArrayRef<Module *> Path, Module *Conflict, StringRef Message) {\n        Diag(ModuleImportLoc, diag::warn_module_conflict) << Path[0]->getFullModuleName() << Conflict->getFullModuleName() << Message;"}}

[j]={{"clang/lib/Serialization/ASTReader.cpp",4247,"ASTReader::ASTReadResult ASTReader::readUnhashedControlBlock(ModuleFile &F, bool WasImportedBy, unsigned ClientLoadCapabilities) {\n  if (Result == OutOfDate && F.Kind == MK_ImplicitModule) {\n    // If this module has already been finalized in the ModuleCache, we\'re stuck\n    // with it; we can only load a single version of each module.\n    //\n    // This can happen when a module is imported in two contexts: in one, as a\n    // user module; in another, as a system module (due to an import from\n    // another module marked with the [system] flag).  It usually indicates a\n    // bug in the module map: this module should also be marked with [system].\n    //\n    // If -Wno-system-headers (the default), and the first import is as a\n    // system module, then validation will fail during the as-user import,\n    // since -Werror flags won\'t have been validated.  However, it\'s reasonable\n    // to treat this consistently as a system module.\n    //\n    // If -Wsystem-headers, the PCM on disk was built with\n    // -Wno-system-headers, and the first import is as a user module, then\n    // validation will fail during the as-system import since the PCM on disk\n    // doesn\'t guarantee that -Werror was respected.  However, the -Werror\n    // flags were checked during the initial as-user import.\n    if (getModuleManager().getModuleCache().isPCMFinal(F.FileName)) {\n      Diag(diag::warn_module_system_bit_conflict) << F.FileName;"}}

[j]={{"clang/lib/Serialization/ASTWriter.cpp",2136,"/// Writes the block containing the serialized form of the\n/// preprocessor.\nvoid ASTWriter::WritePreprocessor(const Preprocessor &PP, bool IsModule) {\n  // If the AST file contains __DATE__ or __TIME__ emit a warning about this.\n  // FIXME: Include a location for the use, and say which one was used.\n  if (PP.SawDateOrTime())\n    PP.Diag(SourceLocation(), diag::warn_module_uses_date_time) << IsModule;"}}

[j]={{"clang/lib/ARCMigrate/TransformActions.cpp",576,"void TransformActions::reportWarning(StringRef message, SourceLocation loc, SourceRange range) { report(loc, diag::warn_mt_message, range) << message; }"},{"clang/unittests/Basic/DiagnosticTest.cpp",47,"// Check that DiagnosticErrorTrap works with SuppressAllDiagnostics.\nTEST(DiagnosticTest, suppressAndTrap) {\n  {\n    Diags.Report(diag::warn_mt_message) << \"warning\";"},{"clang/unittests/Basic/DiagnosticTest.cpp",71,"// Check that FatalsAsError works as intended\nTEST(DiagnosticTest, fatalsAsError) {\n  for (unsigned FatalsAsError = 0; FatalsAsError != 2; ++FatalsAsError) {\n    Diags.Report(diag::warn_mt_message) << \"warning\";"}}

[j]={{"clang/lib/Lex/LiteralSupport.cpp",1622,"/// \\verbatim\n///      user-defined-character-literal: [C++11 lex.ext]\n///        character-literal ud-suffix\n///      ud-suffix:\n///        identifier\n///      character-literal: [C++11 lex.ccon]\n///        \' c-char-sequence \'\n///        u\' c-char-sequence \'\n///        U\' c-char-sequence \'\n///        L\' c-char-sequence \'\n///        u8\' c-char-sequence \' [C++1z lex.ccon]\n///      c-char-sequence:\n///        c-char\n///        c-char-sequence c-char\n///      c-char:\n///        any member of the source character set except the single-quote \',\n///          backslash \\, or new-line character\n///        escape-sequence\n///        universal-character-name\n///      escape-sequence:\n///        simple-escape-sequence\n///        octal-escape-sequence\n///        hexadecimal-escape-sequence\n///      simple-escape-sequence:\n///        one of \\\' \\\" \\? \\\\ \\a \\b \\f \\n \\r \\t \\v\n///      octal-escape-sequence:\n///        \\ octal-digit\n///        \\ octal-digit octal-digit\n///        \\ octal-digit octal-digit octal-digit\n///      hexadecimal-escape-sequence:\n///        \\x hexadecimal-digit\n///        hexadecimal-escape-sequence hexadecimal-digit\n///      universal-character-name: [C++11 lex.charset]\n///        \\u hex-quad\n///        \\U hex-quad hex-quad\n///      hex-quad:\n///        hex-digit hex-digit hex-digit hex-digit\n/// \\endverbatim\n///\nCharLiteralParser::CharLiteralParser(const char *begin, const char *end, SourceLocation Loc, Preprocessor &PP, tok::TokenKind kind) {\n  if (NumCharsSoFar > 1) {\n    if (isOrdinary() && NumCharsSoFar == 4)\n    else if (isOrdinary())\n      PP.Diag(Loc, diag::warn_multichar_character_literal);"}}

[j]={{N,2977,"void Sema::DiagnoseMultipleMethodInGlobalPool(SmallVectorImpl<ObjCMethodDecl *> &Methods, Selector Sel, SourceRange R, bool receiverIdOrClass) {\n  if (issueDiagnostic) {\n    if (issueError)\n    else if (strictSelectorMatch)\n    else\n      Diag(R.getBegin(), diag::warn_multiple_method_decl) << Sel << R;"}}

[j]={{Z,965,"static bool HelperToDiagnoseMismatchedMethodsInGlobalPool(Sema &S, SourceLocation AtLoc, SourceLocation LParenLoc, SourceLocation RParenLoc, ObjCMethodDecl *Method, ObjCMethodList &MethList) {\n  for (M = M->getNext(); M; M = M->getNext()) {\n    if (!S.MatchTwoMethodDeclarations(Method, MatchingMethodDecl, Sema::MMS_loose)) {\n      if (!Warned) {\n        S.Diag(AtLoc, diag::warn_multiple_selectors) << Method->getSelector() << FixItHint::CreateInsertion(LParenLoc, \"(\") << FixItHint::CreateInsertion(RParenLoc, \")\");"},{Z,975,"static void DiagnoseMismatchedSelectors(Sema &S, SourceLocation AtLoc, ObjCMethodDecl *Method, SourceLocation LParenLoc, SourceLocation RParenLoc, bool WarnMultipleSelectors) {\n  if (!WarnMultipleSelectors || S.Diags.isIgnored(diag::warn_multiple_selectors, SourceLocation()))"}}

[j]={{B,1900,"static void handleCPUSpecificAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n  for (unsigned ArgNo = 0; ArgNo < getNumAttributeArgs(AL); ++ArgNo) {\n    if (llvm::any_of(CPUs, [CPUName, &Target](const IdentifierInfo *Cur) { return Target.CPUSpecificManglingCharacter(CPUName) == Target.CPUSpecificManglingCharacter(Cur->getName()); })) {\n      S.Diag(AL.getLoc(), diag::warn_multiversion_duplicate_entries);"}}

[j]={{G,5503,"/// Diagnose a declaration whose declarator-id has the given\n/// nested-name-specifier.\n///\n/// \\param SS The nested-name-specifier of the declarator-id.\n///\n/// \\param DC The declaration context to which the nested-name-specifier\n/// resolves.\n///\n/// \\param Name The name of the entity being declared.\n///\n/// \\param Loc The location of the name of the entity being declared.\n///\n/// \\param IsTemplateId Whether the name is a (simple-)template-id, and thus\n/// we\'re declaring an explicit / partial specialization / instantiation.\n///\n/// \\returns true if we cannot safely recover from this error, false otherwise.\nbool Sema::diagnoseQualifiedDeclaration(CXXScopeSpec &SS, DeclContext *DC, DeclarationName Name, SourceLocation Loc, bool IsTemplateId) {\n  // If the user provided a superfluous scope specifier that refers back to the\n  // class in which the entity is already declared, diagnose and ignore it.\n  //\n  // class X {\n  //  void X::f();\n  // };\n  //\n  // Note, it was once ill-formed to give redundant qualification in all\n  // contexts, but that rule was removed by DR482.\n  if (Cur->Equals(DC)) {\n    if (Cur->isRecord()) {\n    } else {\n      Diag(Loc, diag::warn_namespace_member_extra_qualification) << Name;"}}

[j]={{vb,1488,"void InitListChecker::CheckVectorType(const InitializedEntity &Entity, InitListExpr *IList, QualType DeclType, unsigned &Index, InitListExpr *StructuredList, unsigned &StructuredIndex) {\n  if (!SemaRef.getLangOpts().OpenCL && !SemaRef.getLangOpts().HLSL) {\n    if (isBigEndian && (T->getVectorKind() == VectorType::NeonVector || T->getVectorKind() == VectorType::NeonPolyVector)) {\n      SemaRef.Diag(IList->getBeginLoc(), diag::warn_neon_vector_initializer_non_portable);"}}

[j]={{Jb,2643,"#endif\n    FoundSlash:\n      if (CurPtr[0] == \'*\' && CurPtr[1] != \'/\') {\n        // If this is a /* inside of the comment, emit a warning.  Don\'t do this\n        // if this is a /*/, which will end the comment.  This misses cases with\n        // embedded escaped newlines, but oh well.\n        if (!isLexingRawMode())\n          Diag(CurPtr - 1, diag::warn_nested_block_comment);"}}

[j]={{vb,7020,"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        else\n          Diag(DiagLoc, RK == RK_ReferenceBinding ? diag::warn_new_dangling_reference : diag::warn_new_dangling_initializer_list) << !Entity.getParent() << DiagRange;"}}

[j]={{vb,7020,"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        else\n          Diag(DiagLoc, RK == RK_ReferenceBinding ? diag::warn_new_dangling_reference : diag::warn_new_dangling_initializer_list) << !Entity.getParent() << DiagRange;"}}

[j]={{S,1555,"/// Default synthesizes all properties which must be synthesized\n/// in class\'s \\@implementation.\nvoid Sema::DefaultSynthesizeProperties(Scope *S, ObjCImplDecl *IMPDecl, ObjCInterfaceDecl *IDecl, SourceLocation AtEnd) {\n  for (const auto &PropEntry : PropMap) {\n    // If property to be implemented in the super class, ignore.\n    if (PropInSuperClass) {\n      if ((Prop->getPropertyAttributes() & ObjCPropertyAttribute::kind_readwrite) && (PropInSuperClass->getPropertyAttributes() & ObjCPropertyAttribute::kind_readonly) && !IMPDecl->getInstanceMethod(Prop->getSetterName()) && !IDecl->HasUserDeclaredSetterMethod(Prop)) {\n        Diag(Prop->getLocation(), diag::warn_no_autosynthesis_property) << Prop->getIdentifier();"}}

[j]={{S,1533,"/// Default synthesizes all properties which must be synthesized\n/// in class\'s \\@implementation.\nvoid Sema::DefaultSynthesizeProperties(Scope *S, ObjCImplDecl *IMPDecl, ObjCInterfaceDecl *IDecl, SourceLocation AtEnd) {\n  for (const auto &PropEntry : PropMap) {\n    if (ObjCPropertyImplDecl *PID = IMPDecl->FindPropertyImplIvarDecl(Prop->getIdentifier())) {\n      Diag(Prop->getLocation(), diag::warn_no_autosynthesis_shared_ivar_property) << Prop->getIdentifier();"}}

[j]={{Y,5920,"/// 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  // If this is not an aggregate type and has no user-declared constructor,\n  // complain about any non-static data members of reference or const scalar\n  // type, since they will never get initializers.\n  if (!Record->isInvalidDecl() && !Record->isDependentType() && !Record->isAggregate() && !Record->hasUserDeclaredConstructor() && !Record->isLambda()) {\n    for (const auto *F : Record->fields()) {\n      if (F->getType()->isReferenceType() || (F->getType().isConstQualified() && F->getType()->isScalarType())) {\n        if (!Complained) {\n          Diag(Record->getLocation(), diag::warn_no_constructor_for_refconst) << Record->getTagKind() << Record;"}}

[j]={{Db,786,"/// CheckDynamicCast - Check that a dynamic_cast\\<DestType\\>(SrcExpr) is valid.\n/// Refer to C++ 5.2.7 for details. Dynamic casts are used mostly for runtime-\n/// checked downcasts in class hierarchies.\nvoid CastOperation::CheckDynamicCast() {\n  // Warns when dynamic_cast is used with RTTI data disabled.\n  if (!Self.getLangOpts().RTTIData) {\n    if (MicrosoftABI || !DestPointee->isVoidType())\n      Self.Diag(OpRange.getBegin(), diag::warn_no_dynamic_cast_with_rtti_disabled) << isClangCL;"}}

[j]={{Jb,2817,"/// 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      } else {\n        DiagID = diag::warn_no_newline_eof;"}}

[j]={{Jc,1676,"ModuleLoadResult CompilerInstance::loadModule(SourceLocation ImportLoc, ModuleIdPath Path, Module::NameVisibilityKind Visibility, bool IsInclusionDirective) {\n  for (unsigned I = 1, N = Path.size(); I != N; ++I) {\n    // If the user is requesting Foo.Private and it doesn\'t exist, try to\n    // match Foo_Private and emit a warning asking for the user to write\n    // @import Foo_Private instead. FIXME: remove this when existing clients\n    // migrate off of Foo.Private syntax.\n    if (!Sub && Name == \"Private\" && Module == Module->getTopLevelModule()) {\n      if (Sub) {\n        if (!getDiagnostics().isIgnored(diag::warn_no_priv_submodule_use_toplevel, ImportLoc)) {"},{Jc,1677,"ModuleLoadResult CompilerInstance::loadModule(SourceLocation ImportLoc, ModuleIdPath Path, Module::NameVisibilityKind Visibility, bool IsInclusionDirective) {\n  for (unsigned I = 1, N = Path.size(); I != N; ++I) {\n    // If the user is requesting Foo.Private and it doesn\'t exist, try to\n    // match Foo_Private and emit a warning asking for the user to write\n    // @import Foo_Private instead. FIXME: remove this when existing clients\n    // migrate off of Foo.Private syntax.\n    if (!Sub && Name == \"Private\" && Module == Module->getTopLevelModule()) {\n      if (Sub) {\n        if (!getDiagnostics().isIgnored(diag::warn_no_priv_submodule_use_toplevel, ImportLoc)) {\n          getDiagnostics().Report(Path[I].second, diag::warn_no_priv_submodule_use_toplevel) << Path[I].first << Module->getFullModuleName() << PrivateModule << SourceRange(Path[0].second, Path[I].second) << FixItHint::CreateReplacement(SourceRange(Path[0].second), PrivateModule);"}}

[j]={{"clang/lib/Parse/ParseStmt.cpp",1176,"/// ParseCompoundStatementBody - Parse a sequence of statements optionally\n/// followed by a label and invoke the ActOnCompoundStmt action.  This expects\n/// the \'{\' to be the current token, and consume the \'}\' at the end of the\n/// block.  It does not manipulate the scope stack.\nStmtResult Parser::ParseCompoundStatementBody(bool isStmtExpr) {\n  // Warn the user that using option `-ffp-eval-method=source` on a\n  // 32-bit target and feature `sse` disabled, or using\n  // `pragma clang fp eval_method=source` and feature `sse` disabled, is not\n  // supported.\n  if (!PP.getTargetInfo().supportSourceEvalMethod() && (PP.getLastFPEvalPragmaLocation().isValid() || PP.getCurrentFPEvalMethod() == LangOptions::FPEvalMethodKind::FEM_Source))\n    Diag(Tok.getLocation(), diag::warn_no_support_for_eval_method_source_on_m32);"}}

[j]={{Lb,637,"/// ActOnCXXTypeidOfType - Parse typeid( type-id ) or typeid (expression);\nExprResult Sema::ActOnCXXTypeid(SourceLocation OpLoc, SourceLocation LParenLoc, bool isType, void *TyOrExpr, SourceLocation RParenLoc) {\n  if (!getLangOpts().RTTIData && !Result.isInvalid())\n    if (auto *CTE = dyn_cast<CXXTypeidExpr>(Result.get()))\n      if (CTE->isPotentiallyEvaluated() && !CTE->isMostDerived(Context))\n        Diag(OpLoc, diag::warn_no_typeid_with_rtti_disabled) << (getDiagnostics().getDiagnosticOptions().getFormat() == DiagnosticOptions::MSVC);"}}

[j]={{x,12564,"/// Analyzes an attempt to assign the given value to a bitfield.\n///\n/// Returns true if there was something fishy about the attempt.\nstatic bool AnalyzeBitFieldAssignment(Sema &S, FieldDecl *Bitfield, Expr *Init, SourceLocation InitLoc) {\n  if (BitfieldType->isEnumeralType()) {\n    // If the underlying enum type was not explicitly specified as an unsigned\n    // type and the enum contain only positive values, MSVC++ will cause an\n    // inconsistency by storing this as a signed type.\n    if (S.getLangOpts().CPlusPlus11 && !BitfieldEnumDecl->getIntegerTypeSourceInfo() && BitfieldEnumDecl->getNumPositiveBits() > 0 && BitfieldEnumDecl->getNumNegativeBits() == 0) {\n      S.Diag(InitLoc, diag::warn_no_underlying_type_specified_for_enum_bitfield) << BitfieldEnumDecl;"}}

[j]={{D,1653,"class ThreadSafetyReporter : public clang::threadSafety::ThreadSafetyHandler {\n  void handleMutexHeldEndOfScope(StringRef Kind, Name LockName, SourceLocation LocLocked, SourceLocation LocEndOfScope, LockErrorKind LEK) override {\n    case LEK_LockedAtEndOfFunction:\n      DiagID = diag::warn_no_unlock;"}}

[j]={{B,1983,"static void handleNoCfCheckAttr(Sema &S, Decl *D, const ParsedAttr &Attrs) {\n  if (!S.getLangOpts().CFProtectionBranch)\n    S.Diag(Attrs.getLoc(), diag::warn_nocf_check_attribute_ignored);"},{Q,6961,"/// Process an individual function attribute.  Returns true to\n/// indicate that the attribute was handled, false if it wasn\'t.\nstatic bool handleFunctionTypeAttr(TypeProcessingState &state, ParsedAttr &attr, QualType &type) {\n  if (attr.getKind() == ParsedAttr::AT_AnyX86NoCfCheck) {\n    if (!S.getLangOpts().CFProtectionBranch) {\n      S.Diag(attr.getLoc(), diag::warn_nocf_check_attribute_ignored);"}}

[j]={{Q,5036,"static TypeSourceInfo *GetFullTypeForDeclarator(TypeProcessingState &state, QualType declSpecType, TypeSourceInfo *TInfo) {\n  for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i) {\n    if (DeclType.Kind != DeclaratorChunk::Paren) {\n      if (ExpectNoDerefChunk && !IsNoDerefableChunk(DeclType))\n        S.Diag(DeclType.Loc, diag::warn_noderef_on_non_pointer_or_array);"},{Q,5043,"static TypeSourceInfo *GetFullTypeForDeclarator(TypeProcessingState &state, QualType declSpecType, TypeSourceInfo *TInfo) {\n  if (ExpectNoDerefChunk)\n    S.Diag(state.getDeclarator().getBeginLoc(), diag::warn_noderef_on_non_pointer_or_array);"}}

[j]={{Db,166,"void CheckNoDeref(Sema &S, const QualType FromType, const QualType ToType, SourceLocation OpLoc) {\n  if (const auto *PtrType = dyn_cast<PointerType>(FromType)) {\n    if (PtrType->getPointeeType()->hasAttr(attr::NoDeref)) {\n      if (const auto *DestType = dyn_cast<PointerType>(ToType)) {\n        if (!DestType->getPointeeType()->hasAttr(attr::NoDeref)) {\n          S.Diag(OpLoc, diag::warn_noderef_to_dereferenceable_pointer);"},{z,9041,"Sema::AssignConvertType Sema::CheckSingleAssignmentConstraints(QualType LHSType, ExprResult &CallerRHS, bool Diagnose, bool DiagnoseCFAudited, bool ConvertRHS) {\n  if (const auto *LHSPtrType = LHSType->getAs<PointerType>()) {\n    if (const auto *RHSPtrType = RHS.get()->getType()->getAs<PointerType>()) {\n      if (RHSPtrType->getPointeeType()->hasAttr(attr::NoDeref) && !LHSPtrType->getPointeeType()->hasAttr(attr::NoDeref)) {\n        Diag(RHS.get()->getExprLoc(), diag::warn_noderef_to_dereferenceable_pointer) << RHS.get()->getSourceRange();"},{vb,7641,"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_ConversionSequenceNoNarrowing: {\n      if (const auto *FromPtrType = CurInit.get()->getType()->getAs<PointerType>()) {\n        if (const auto *ToPtrType = Step->Type->getAs<PointerType>()) {\n          if (FromPtrType->getPointeeType()->hasAttr(attr::NoDeref) && !ToPtrType->getPointeeType()->hasAttr(attr::NoDeref)) {\n            // Do not check static casts here because they are checked earlier\n            // in Sema::ActOnCXXNamedCast()\n            if (!Kind.isStaticCast()) {\n              S.Diag(CurInit.get()->getExprLoc(), diag::warn_noderef_to_dereferenceable_pointer) << CurInit.get()->getSourceRange();"}}

[j]={{"clang/lib/Sema/SemaCoroutine.cpp",1325,"bool CoroutineStmtBuilder::makeNewAndDeleteExpr() {\n  // If we found a non-aligned allocation function in the promise_type,\n  // it indicates the user forgot to update the allocation function. Let\'s emit\n  // a warning here.\n  if (FoundNonAlignedInPromise) {\n    S.Diag(OperatorNew->getLocation(), diag::warn_non_aligned_allocation_function) << &FD;"}}

[j]={{N,1988,"static bool CheckMethodOverrideParam(Sema &S, ObjCMethodDecl *MethodImpl, ObjCMethodDecl *MethodDecl, ParmVarDecl *ImplVar, ParmVarDecl *IfaceVar, bool IsProtocolMethodDecl, bool IsOverridingMode, bool Warn) {\n  // Mismatches between ObjC pointers go into a different warning\n  // category, and sometimes they\'re even completely explicitly allowed..\n  if (const ObjCObjectPointerType *ImplPtrTy = ImplTy->getAs<ObjCObjectPointerType>()) {\n    if (const ObjCObjectPointerType *IfacePtrTy = IfaceTy->getAs<ObjCObjectPointerType>()) {\n      DiagID = IsOverridingMode ? diag::warn_non_contravariant_overriding_param_types : diag::warn_non_contravariant_param_types;"}}

[j]={{N,1988,"static bool CheckMethodOverrideParam(Sema &S, ObjCMethodDecl *MethodImpl, ObjCMethodDecl *MethodDecl, ParmVarDecl *ImplVar, ParmVarDecl *IfaceVar, bool IsProtocolMethodDecl, bool IsOverridingMode, bool Warn) {\n  // Mismatches between ObjC pointers go into a different warning\n  // category, and sometimes they\'re even completely explicitly allowed..\n  if (const ObjCObjectPointerType *ImplPtrTy = ImplTy->getAs<ObjCObjectPointerType>()) {\n    if (const ObjCObjectPointerType *IfacePtrTy = IfaceTy->getAs<ObjCObjectPointerType>()) {\n      DiagID = IsOverridingMode ? diag::warn_non_contravariant_overriding_param_types : diag::warn_non_contravariant_param_types;"}}

[j]={{N,1943,"static bool CheckMethodOverrideReturn(Sema &S, ObjCMethodDecl *MethodImpl, ObjCMethodDecl *MethodDecl, bool IsProtocolMethodDecl, bool IsOverridingMode, bool Warn) {\n  // Mismatches between ObjC pointers go into a different warning\n  // category, and sometimes they\'re even completely explicitly allowed.\n  if (const ObjCObjectPointerType *ImplPtrTy = MethodImpl->getReturnType()->getAs<ObjCObjectPointerType>()) {\n    if (const ObjCObjectPointerType *IfacePtrTy = MethodDecl->getReturnType()->getAs<ObjCObjectPointerType>()) {\n      DiagID = IsOverridingMode ? diag::warn_non_covariant_overriding_ret_types : diag::warn_non_covariant_ret_types;"}}

[j]={{N,1943,"static bool CheckMethodOverrideReturn(Sema &S, ObjCMethodDecl *MethodImpl, ObjCMethodDecl *MethodDecl, bool IsProtocolMethodDecl, bool IsOverridingMode, bool Warn) {\n  // Mismatches between ObjC pointers go into a different warning\n  // category, and sometimes they\'re even completely explicitly allowed.\n  if (const ObjCObjectPointerType *ImplPtrTy = MethodImpl->getReturnType()->getAs<ObjCObjectPointerType>()) {\n    if (const ObjCObjectPointerType *IfacePtrTy = MethodDecl->getReturnType()->getAs<ObjCObjectPointerType>()) {\n      DiagID = IsOverridingMode ? diag::warn_non_covariant_overriding_ret_types : diag::warn_non_covariant_ret_types;"}}

[j]={{"clang/lib/Sema/SemaOverload.cpp",2681,"/// CheckPointerConversion - Check the pointer conversion from the\n/// expression From to the type ToType. This routine checks for\n/// ambiguous or inaccessible derived-to-base pointer\n/// conversions for which IsPointerConversion has already returned\n/// true. It returns true and produces a diagnostic if there was an\n/// error, or returns false otherwise.\nbool Sema::CheckPointerConversion(Expr *From, QualType ToType, CastKind &Kind, CXXCastPath &BasePath, bool IgnoreBaseAccess, bool Diagnose) {\n  if (Diagnose && !IsCStyleOrFunctionalCast && !FromType->isAnyPointerType() && From->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNotNull) == Expr::NPCK_ZeroExpression) {\n    if (Context.hasSameUnqualifiedType(From->getType(), Context.BoolTy))\n    else if (!isUnevaluatedContext())\n      Diag(From->getExprLoc(), diag::warn_non_literal_null_pointer) << ToType << From->getSourceRange();"}}

[j]={{"clang/lib/Lex/ModuleMap.cpp",471,"void ModuleMap::diagnoseHeaderInclusion(Module *RequestingModule, bool RequestingModuleIsModuleInterface, SourceLocation FilenameLoc, StringRef Filename, FileEntryRef File) {\n  if (RequestingModule && LangOpts.ModulesStrictDeclUse) {\n  } else if (RequestingModule && RequestingModuleIsModuleInterface && LangOpts.isCompilingModule()) {\n    diag::kind DiagID = RequestingModule->getTopLevelModule()->IsFramework ? diag::warn_non_modular_include_in_framework_module : diag::warn_non_modular_include_in_module;"}}

[j]={{"clang/lib/Lex/ModuleMap.cpp",471,"void ModuleMap::diagnoseHeaderInclusion(Module *RequestingModule, bool RequestingModuleIsModuleInterface, SourceLocation FilenameLoc, StringRef Filename, FileEntryRef File) {\n  if (RequestingModule && LangOpts.ModulesStrictDeclUse) {\n  } else if (RequestingModule && RequestingModuleIsModuleInterface && LangOpts.isCompilingModule()) {\n    diag::kind DiagID = RequestingModule->getTopLevelModule()->IsFramework ? diag::warn_non_modular_include_in_framework_module : diag::warn_non_modular_include_in_module;"}}

[j]={{x,10262,"bool CheckPrintfHandler::checkFormatExpr(const analyze_printf::PrintfSpecifier &FS, const char *StartSpecifier, unsigned SpecifierLen, const Expr *E) {\n  if (Success) {\n  } else {\n    case Sema::VAK_MSVCUndefined:\n      if (CallType == Sema::VariadicDoesNotApply) {\n      } else {\n        EmitFormatDiagnostic(S.PDiag(diag::warn_non_pod_vararg_with_format_string) << S.getLangOpts().CPlusPlus11 << ExprTy << CallType << AT.getRepresentativeTypeName(S.Context) << CSR << E->getSourceRange(), E->getBeginLoc(), /*IsStringLocation*/ false, CSR);"}}

[j]={{G,3741,"/// MergeFunctionDecl - We just parsed a function \'New\' from\n/// declarator D which has the same name and scope as a previous\n/// declaration \'Old\'.  Figure out how to resolve this situation,\n/// merging decls or emitting diagnostics as appropriate.\n///\n/// In C++, New and Old must be declarations that are not\n/// overloaded. Use IsOverload to determine whether New and Old are\n/// overloaded, and to select the Old declaration that New should be\n/// merged with.\n///\n/// Returns true if there was an error, false otherwise.\nbool Sema::MergeFunctionDecl(FunctionDecl *New, NamedDecl *&OldD, Scope *S, bool MergeTypeWithOld, bool NewDeclIsDefn) {\n  // C: Function types need to be compatible, not identical. This handles\n  // duplicate function decls like \"void f(int); void f(enum X);\" properly.\n  if (!getLangOpts().CPlusPlus) {\n    // If we are merging two functions where only one of them has a prototype,\n    // we may have enough information to decide to issue a diagnostic that the\n    // function without a protoype will change behavior in C2x. This handles\n    // cases like:\n    //  void i(); void i(int j);\n    //  void i(int j); void i();\n    //  void i(); void i(int j) {}\n    // See ActOnFinishFunctionBody() for other cases of the behavior change\n    // diagnostic. See GetFullTypeForDeclarator() for handling of a function\n    // type without a prototype.\n    if (New->hasWrittenPrototype() != Old->hasWrittenPrototype() && !New->isImplicit() && !Old->isImplicit()) {\n      if (WithProto->getNumParams() != 0) {\n        if (WithoutProto->getBuiltinID() == 0 && !WithoutProto->isImplicit()) {\n          Diag(WithoutProto->getLocation(), diag::warn_non_prototype_changes_behavior) << IsWithoutProtoADef << (WithoutProto->getNumParams() ? 0 : 1) << (WithoutProto == Old) << IsWithProtoADef;"},{G,13768,"Decl *Sema::ActOnFinishFunctionBody(Decl *dcl, Stmt *Body, bool IsInstantiation) {\n  {\n    if (FD) {\n      // If the function being defined does not have a prototype, then we may\n      // need to diagnose it as changing behavior in C2x because we now know\n      // whether the function accepts arguments or not. This only handles the\n      // case where the definition has no prototype but does have parameters\n      // and either there is no previous potential prototype, or the previous\n      // potential prototype also has no actual prototype. This handles cases\n      // like:\n      //  void f(); void f(a) int a; {}\n      //  void g(a) int a; {}\n      // See MergeFunctionDecl() for other cases of the behavior change\n      // diagnostic. See GetFullTypeForDeclarator() for handling of a function\n      // type without a prototype.\n      if (!FD->hasWrittenPrototype() && FD->getNumParams() != 0 && (!PossiblePrototype || (!PossiblePrototype->hasWrittenPrototype() && !PossiblePrototype->isImplicit()))) {\n        Diag(FD->getLocation(), diag::warn_non_prototype_changes_behavior) << /*definition*/ 1 << /* not supported in C2x */ 0;"},{G,13776,"Decl *Sema::ActOnFinishFunctionBody(Decl *dcl, Stmt *Body, bool IsInstantiation) {\n  {\n    if (FD) {\n      // If the function being defined does not have a prototype, then we may\n      // need to diagnose it as changing behavior in C2x because we now know\n      // whether the function accepts arguments or not. This only handles the\n      // case where the definition has no prototype but does have parameters\n      // and either there is no previous potential prototype, or the previous\n      // potential prototype also has no actual prototype. This handles cases\n      // like:\n      //  void f(); void f(a) int a; {}\n      //  void g(a) int a; {}\n      // See MergeFunctionDecl() for other cases of the behavior change\n      // diagnostic. See GetFullTypeForDeclarator() for handling of a function\n      // type without a prototype.\n      if (!FD->hasWrittenPrototype() && FD->getNumParams() != 0 && (!PossiblePrototype || (!PossiblePrototype->hasWrittenPrototype() && !PossiblePrototype->isImplicit()))) {\n        // If we have a possible prototype for the function which is a user-\n        // visible declaration, we already tested that it has no prototype.\n        // This will change behavior in C2x. This gets a warning rather than a\n        // note because it\'s the same behavior-changing problem as with the\n        // definition.\n        if (PossiblePrototype)\n          Diag(PossiblePrototype->getLocation(), diag::warn_non_prototype_changes_behavior) << /*declaration*/ 0 << /* conflicting */ 1 << /*subsequent*/ 1 << /*definition*/ 1;"}}

[j]={{Y,5952,"/// 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  // Warn if the class has virtual methods but non-virtual public destructor.\n  if (Record->isPolymorphic() && !Record->isDependentType()) {\n    if ((!dtor || (!dtor->isVirtual() && dtor->getAccess() == AS_public)) && !Record->hasAttr<FinalAttr>())\n      Diag(dtor ? dtor->getLocation() : Record->getLocation(), diag::warn_non_virtual_dtor) << Context.getRecordType(Record);"}}

[j]={{x,13781,"/// Diagnose pointers that are always non-null.\n/// \\param E the expression containing the pointer\n/// \\param NullKind NPCK_NotNull if E is a cast to bool, otherwise, E is\n/// compared to a null pointer\n/// \\param IsEqual True when the comparison is equal to a null pointer\n/// \\param Range Extra SourceRange to highlight in the diagnostic\nvoid Sema::DiagnoseAlwaysNonNullPointer(Expr *E, Expr::NullPointerConstantKind NullKind, bool IsEqual, SourceRange Range) {\n  auto ComplainAboutNonnullParamOrCall = [&](const Attr *NonnullAttr) {\n    unsigned DiagID = IsCompare ? diag::warn_nonnull_expr_compare : diag::warn_cast_nonnull_to_bool;"}}

[j]={{D,567,"struct CheckFallThroughDiagnostics {\n  bool checkDiagnostics(DiagnosticsEngine &D, bool ReturnsVoid, bool HasNoReturn) const {\n    if (funMode == Function) {\n      return (ReturnsVoid || D.isIgnored(diag::warn_maybe_falloff_nonvoid_function, FuncLoc)) && (!HasNoReturn || D.isIgnored(diag::warn_noreturn_function_has_return_expr, FuncLoc)) && (!ReturnsVoid || D.isIgnored(diag::warn_suggest_noreturn_block, FuncLoc));"},{R,3408,"StmtResult Sema::BuildReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp, bool AllowRecovery) {\n  if (const FunctionDecl *FD = getCurFunctionDecl()) {\n    if (FD->isNoReturn())\n      Diag(ReturnLoc, diag::warn_noreturn_function_has_return_expr) << FD;"}}

[j]={{V,2150,"void Sema::ActOnComment(SourceRange Comment) {\n  if (RC.isAlmostTrailingComment() || RC.hasUnsupportedSplice(SourceMgr)) {\n    Diag(Comment.getBegin(), diag::warn_not_a_doxygen_trailing_member_comment) << FixItHint::CreateReplacement(MagicMarkerRange, MagicMarkerText);"}}

[j]={{z,12488,"// C99 6.5.16.1\nQualType Sema::CheckAssignmentOperands(Expr *LHSExpr, ExprResult &RHS, SourceLocation Loc, QualType CompoundType, BinaryOperatorKind Opc) {\n  if (CompoundType.isNull()) {\n    if (UnaryOperator *UO = dyn_cast<UnaryOperator>(RHSCheck)) {\n      if ((UO->getOpcode() == UO_Plus || UO->getOpcode() == UO_Minus) && Loc.isFileID() && UO->getOperatorLoc().isFileID() &&\n        Diag(Loc, diag::warn_not_compound_assign) << (UO->getOpcode() == UO_Plus ? \"+\" : \"-\") << SourceRange(UO->getOperatorLoc(), UO->getOperatorLoc());"}}

[j]={{z,430,"/// DiagnoseSentinelCalls - This routine checks whether a call or\n/// message-send is to a declaration with the sentinel attribute, and\n/// if so, it checks that the requirements of the sentinel are\n/// satisfied.\nvoid Sema::DiagnoseSentinelCalls(NamedDecl *D, SourceLocation Loc, ArrayRef<Expr *> Args) {\n  // If there aren\'t enough arguments for all the formal parameters,\n  // the sentinel, and the args after the sentinel, complain.\n  if (Args.size() < numFormalParams + numArgsAfterSentinel + 1) {\n    Diag(Loc, diag::warn_not_enough_argument) << D->getDeclName();"}}

[j]={{R,1302,"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      // See which case values aren\'t in enum.\n      for (CaseValsTy::const_iterator CI = CaseVals.begin(); CI != CaseVals.end(); CI++) {\n        if (ShouldDiagnoseSwitchCaseNotInEnum(*this, ED, CaseExpr, EI, EIEnd, CI->first))\n          Diag(CaseExpr->getExprLoc(), diag::warn_not_in_enum) << CondTypeBeforePromotion;"},{R,1310,"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      for (CaseRangesTy::const_iterator RI = CaseRanges.begin(); RI != CaseRanges.end(); RI++) {\n        if (ShouldDiagnoseSwitchCaseNotInEnum(*this, ED, CaseExpr, EI, EIEnd, RI->first))\n          Diag(CaseExpr->getExprLoc(), diag::warn_not_in_enum) << CondTypeBeforePromotion;"},{R,1317,"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      for (CaseRangesTy::const_iterator RI = CaseRanges.begin(); RI != CaseRanges.end(); RI++) {\n        if (ShouldDiagnoseSwitchCaseNotInEnum(*this, ED, CaseExpr, EI, EIEnd, Hi))\n          Diag(CaseExpr->getExprLoc(), diag::warn_not_in_enum) << CondTypeBeforePromotion;"}}

[j]={{R,1394,"void Sema::DiagnoseAssignmentEnum(QualType DstType, QualType SrcType, Expr *SrcExpr) {\n  if (Diags.isIgnored(diag::warn_not_in_enum_assignment, SrcExpr->getExprLoc()))"},{R,1413,"void Sema::DiagnoseAssignmentEnum(QualType DstType, QualType SrcType, Expr *SrcExpr) {\n  if (const EnumType *ET = DstType->getAs<EnumType>())\n    if (!Context.hasSameUnqualifiedType(SrcType, DstType) && SrcType->isIntegerType()) {\n      if (!SrcExpr->isTypeDependent() && !SrcExpr->isValueDependent() && SrcExpr->isIntegerConstantExpr(Context)) {\n        if (ED->hasAttr<FlagEnumAttr>()) {\n          if (!IsValueInFlagEnum(ED, RhsVal, true))\n            Diag(SrcExpr->getExprLoc(), diag::warn_not_in_enum_assignment) << DstType.getUnqualifiedType();"},{R,1435,"void Sema::DiagnoseAssignmentEnum(QualType DstType, QualType SrcType, Expr *SrcExpr) {\n  if (const EnumType *ET = DstType->getAs<EnumType>())\n    if (!Context.hasSameUnqualifiedType(SrcType, DstType) && SrcType->isIntegerType()) {\n      if (!SrcExpr->isTypeDependent() && !SrcExpr->isValueDependent() && SrcExpr->isIntegerConstantExpr(Context)) {\n        if (ED->hasAttr<FlagEnumAttr>()) {\n        } else {\n          if (EI == EIend || EI->first != RhsVal) {\n            Diag(SrcExpr->getExprLoc(), diag::warn_not_in_enum_assignment) << DstType.getUnqualifiedType();"}}

[j]={{x,6280,"// 16 byte ByVal alignment not due to a vector member is not honoured by XL\n// on AIX. Emit a warning here that users are generating binary incompatible\n// code to be safe.\n// Here we try to get information about the alignment of the struct member\n// from the struct passed to the caller function. We only warn when the struct\n// is passed byval, hence the series of checks and early returns if we are a not\n// passing a struct byval.\nvoid Sema::checkAIXMemberAlignment(SourceLocation Loc, const Expr *Arg) {\n  for (const FieldDecl *FD : ArgType->castAs<RecordType>()->getDecl()->fields()) {\n    if (const auto *AA = FD->getAttr<AlignedAttr>()) {\n      if (Alignment.getQuantity() == 16) {\n        Diag(FD->getLocation(), diag::warn_not_xl_compatible) << FD;"}}

[j]={{Q,7038,"/// Process an individual function attribute.  Returns true to\n/// indicate that the attribute was handled, false if it wasn\'t.\nstatic bool handleFunctionTypeAttr(TypeProcessingState &state, ParsedAttr &attr, QualType &type) {\n  if (attr.getKind() == ParsedAttr::AT_NoThrow) {\n    // MSVC ignores nothrow if it is in conflict with an explicit exception\n    // specification.\n    if (Proto->hasExceptionSpec()) {\n      case EST_NoexceptFalse:\n        S.Diag(attr.getLoc(), diag::warn_nothrow_attribute_ignored);"}}

[j]={{ac,1782,"void ItaniumRecordLayoutBuilder::LayoutField(const FieldDecl *D, bool InsertExtraPadding) {\n  if (D->getType()->isIncompleteArrayType()) {\n  } else {\n    if (IsMsStruct) {\n      if (const BuiltinType *BTy = T->getAs<BuiltinType>()) {\n        if (!llvm::isPowerOf2_64(TypeSize.getQuantity())) {\n          // Since the combination of -mms-bitfields together with structs\n          // like max_align_t (which contains a long double) for mingw is\n          // quite common (and GCC handles it silently), just handle it\n          // silently there. For other targets that have ms_struct enabled\n          // (most probably via a pragma or attribute), trigger a diagnostic\n          // that defaults to an error.\n          if (!Context.getTargetInfo().getTriple().isWindowsGNUEnvironment())\n            Diag(D->getLocation(), diag::warn_npot_ms_struct);"}}

[j]={{B,5181,"void Sema::AddXConsumedAttr(Decl *D, const AttributeCommonInfo &CI, RetainOwnershipKind K, bool IsTemplateInstantiation) {\n  case RetainOwnershipKind::OS:\n    handleSimpleAttributeOrDiagnose<OSConsumedAttr>(*this, VD, CI, isValidSubjectOfOSAttribute(VD->getType()), diag::warn_ns_attribute_wrong_parameter_type,"},{B,5191,"void Sema::AddXConsumedAttr(Decl *D, const AttributeCommonInfo &CI, RetainOwnershipKind K, bool IsTemplateInstantiation) {\n  case RetainOwnershipKind::NS:\n    handleSimpleAttributeOrDiagnose<NSConsumedAttr>(*this, VD, CI, isValidSubjectOfNSAttribute(VD->getType()),\n                                                    ((IsTemplateInstantiation && getLangOpts().ObjCAutoRefCount) ? diag::err_ns_attribute_wrong_parameter_type : diag::warn_ns_attribute_wrong_parameter_type),"},{B,5195,"void Sema::AddXConsumedAttr(Decl *D, const AttributeCommonInfo &CI, RetainOwnershipKind K, bool IsTemplateInstantiation) {\n  case RetainOwnershipKind::CF:\n    handleSimpleAttributeOrDiagnose<CFConsumedAttr>(*this, VD, CI, isValidSubjectOfCFAttribute(VD->getType()), diag::warn_ns_attribute_wrong_parameter_type,"},{B,5261,"static void handleXReturnsXRetainedAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n  if (const auto *MD = dyn_cast<ObjCMethodDecl>(D)) {\n  } else if (S.getLangOpts().ObjCAutoRefCount && hasDeclarator(D) && (AL.getKind() == ParsedAttr::AT_NSReturnsRetained)) {\n  } else if (const auto *PD = dyn_cast<ObjCPropertyDecl>(D)) {\n  } else if (const auto *FD = dyn_cast<FunctionDecl>(D)) {\n  } else if (const auto *Param = dyn_cast<ParmVarDecl>(D)) {\n    if (ReturnType.isNull()) {\n      S.Diag(D->getBeginLoc(), diag::warn_ns_attribute_wrong_parameter_type) << AL << DiagID << AL.getRange();"},{B,5324,"static void handleXReturnsXRetainedAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n  if (!TypeOK) {\n    if (isa<ParmVarDecl>(D)) {\n      S.Diag(D->getBeginLoc(), diag::warn_ns_attribute_wrong_parameter_type) << AL << ParmDiagID << AL.getRange();"},{B,8038,"/// ProcessDeclAttribute - Apply the specific attribute to the specified decl if\n/// the attribute applies to decls.  If the attribute is a type attribute, just\n/// silently ignore it if a GNU attribute.\nstatic void ProcessDeclAttribute(Sema &S, Scope *scope, Decl *D, const ParsedAttr &AL, const Sema::ProcessDeclAttributeOptions &Options) {\n  case ParsedAttr::AT_OSReturnsRetainedOnZero:\n    handleSimpleAttributeOrDiagnose<OSReturnsRetainedOnZeroAttr>(S, D, AL, isValidOSObjectOutParameter(D), diag::warn_ns_attribute_wrong_parameter_type,"},{B,8042,"/// ProcessDeclAttribute - Apply the specific attribute to the specified decl if\n/// the attribute applies to decls.  If the attribute is a type attribute, just\n/// silently ignore it if a GNU attribute.\nstatic void ProcessDeclAttribute(Sema &S, Scope *scope, Decl *D, const ParsedAttr &AL, const Sema::ProcessDeclAttributeOptions &Options) {\n  case ParsedAttr::AT_OSReturnsRetainedOnNonZero:\n    handleSimpleAttributeOrDiagnose<OSReturnsRetainedOnNonZeroAttr>(S, D, AL, isValidOSObjectOutParameter(D), diag::warn_ns_attribute_wrong_parameter_type,"}}

[j]={{B,5229,"bool Sema::checkNSReturnsRetainedReturnType(SourceLocation Loc, QualType QT) {\n  Diag(Loc, diag::warn_ns_attribute_wrong_return_type) << \"\'ns_returns_retained\'\" << 0 << 0;"},{B,5332,"static void handleXReturnsXRetainedAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n  if (!TypeOK) {\n    if (isa<ParmVarDecl>(D)) {\n    } else {\n      S.Diag(D->getBeginLoc(), diag::warn_ns_attribute_wrong_return_type) << AL << SubjectKind << Cf << AL.getRange();"},{B,5376,"static void handleObjCReturnsInnerPointerAttr(Sema &S, Decl *D, const ParsedAttr &Attrs) {\n  if (!resultType->isReferenceType() && (!resultType->isPointerType() || resultType->isObjCRetainableType())) {\n    S.Diag(D->getBeginLoc(), diag::warn_ns_attribute_wrong_return_type) << SourceRange(loc) << Attrs << (isa<ObjCMethodDecl>(D) ? EP_ObjCMethod : EP_ObjCProperty) << /*non-retainable pointer*/ 2;"}}

[j]={{N,174,"void Sema::CheckObjCMethodOverride(ObjCMethodDecl *NewMethod, const ObjCMethodDecl *Overridden) {\n  for (ObjCMethodDecl::param_iterator ni = NewMethod->param_begin(), ne = NewMethod->param_end(); ni != ne && oi != oe; ++ni, ++oi) {\n    if (newDecl->hasAttr<NSConsumedAttr>() != oldDecl->hasAttr<NSConsumedAttr>()) {\n      Diag(newDecl->getLocation(), getLangOpts().ObjCAutoRefCount ? diag::err_nsconsumed_attribute_mismatch : diag::warn_nsconsumed_attribute_mismatch);"}}

[j]={{Z,765,"/// Check for duplicate keys in an ObjC dictionary literal. For instance:\n///  NSDictionary *nd = @{ @\"foo\" : @\"bar\", @\"foo\" : @\"baz\" };\nstatic void CheckObjCDictionaryLiteralDuplicateKeys(Sema &S, ObjCDictionaryLiteral *Literal) {\n  auto checkOneKey = [&](auto &Map, const auto &Key, SourceLocation Loc) {\n    if (!Pair.second) {\n      S.Diag(Loc, diag::warn_nsdictionary_duplicate_key);"}}

[j]={{B,2640,"static void handleObjCNSObject(Sema &S, Decl *D, const ParsedAttr &AL) {\n  if (const auto *TD = dyn_cast<TypedefNameDecl>(D)) {\n  } else if (const auto *PD = dyn_cast<ObjCPropertyDecl>(D)) {\n  } else {\n    S.Diag(D->getLocation(), diag::warn_nsobject_attribute);"}}

[j]={{N,161,"void Sema::CheckObjCMethodOverride(ObjCMethodDecl *NewMethod, const ObjCMethodDecl *Overridden) {\n  if ((NewMethod->hasAttr<NSReturnsRetainedAttr>() != Overridden->hasAttr<NSReturnsRetainedAttr>())) {\n    Diag(NewMethod->getLocation(), getLangOpts().ObjCAutoRefCount ? diag::err_nsreturns_retained_attribute_mismatch : diag::warn_nsreturns_retained_attribute_mismatch) << 1;"},{N,165,"void Sema::CheckObjCMethodOverride(ObjCMethodDecl *NewMethod, const ObjCMethodDecl *Overridden) {\n  if ((NewMethod->hasAttr<NSReturnsNotRetainedAttr>() != Overridden->hasAttr<NSReturnsNotRetainedAttr>())) {\n    Diag(NewMethod->getLocation(), getLangOpts().ObjCAutoRefCount ? diag::err_nsreturns_retained_attribute_mismatch : diag::warn_nsreturns_retained_attribute_mismatch) << 0;"}}

[j]={{x,6111,"static void CheckNonNullArgument(Sema &S, const Expr *ArgExpr, SourceLocation CallSiteLoc) {\n  if (CheckNonNullExpr(S, ArgExpr))\n    S.DiagRuntimeBehavior(CallSiteLoc, ArgExpr, S.PDiag(diag::warn_null_arg) << ArgExpr->getSourceRange());"},{z,5768,"/// CheckStaticArrayArgument - If the given argument corresponds to a static\n/// array parameter, check that it is non-null, and that if it is formed by\n/// array-to-pointer decay, the underlying array is sufficiently large.\n///\n/// C99 6.7.5.3p7: If the keyword static also appears within the [ and ] of the\n/// array type derivation, then for each call to the function, the value of the\n/// corresponding actual argument shall provide access to the first element of\n/// an array with at least as many elements as specified by the size expression.\nvoid Sema::CheckStaticArrayArgument(SourceLocation CallLoc, ParmVarDecl *Param, const Expr *ArgExpr) {\n  if (ArgExpr->isNullPointerConstant(Context, Expr::NPC_NeverValueDependent)) {\n    Diag(CallLoc, diag::warn_null_arg) << ArgExpr->getSourceRange();"}}

[j]={{z,9747,"// checkArithmeticNull - Detect when a NULL constant is used improperly in an\n// expression.  These are mainly cases where the null pointer is used as an\n// integer instead of a pointer.\nstatic void checkArithmeticNull(Sema &S, ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompare) {\n  // Comparison operations would not make sense with a null pointer no matter\n  // what the other expression is.\n  if (!IsCompare) {\n    S.Diag(Loc, diag::warn_null_in_arithmetic_operation) << (LHSNull ? LHS.get()->getSourceRange() : SourceRange()) << (RHSNull ? RHS.get()->getSourceRange() : SourceRange());"}}

[j]={{z,9756,"// checkArithmeticNull - Detect when a NULL constant is used improperly in an\n// expression.  These are mainly cases where the null pointer is used as an\n// integer instead of a pointer.\nstatic void checkArithmeticNull(Sema &S, ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompare) {\n  S.Diag(Loc, diag::warn_null_in_comparison_operation) << LHSNull /* LHS is NULL */ << NonNullType << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();"}}

[j]={{x,13859,"/// Diagnose pointers that are always non-null.\n/// \\param E the expression containing the pointer\n/// \\param NullKind NPCK_NotNull if E is a cast to bool, otherwise, E is\n/// compared to a null pointer\n/// \\param IsEqual True when the comparison is equal to a null pointer\n/// \\param Range Extra SourceRange to highlight in the diagnostic\nvoid Sema::DiagnoseAlwaysNonNullPointer(Expr *E, Expr::NullPointerConstantKind NullKind, bool IsEqual, SourceRange Range) {\n  unsigned DiagID = IsCompare ? diag::warn_null_pointer_compare : diag::warn_impcast_pointer_to_bool;"}}

[j]={{S,1716,"void Sema::diagnoseNullResettableSynthesizedSetters(const ObjCImplDecl *impDecl) {\n  for (const auto *propertyImpl : impDecl->property_impls()) {\n    // Warn about null_resettable properties with synthesized setters,\n    // because the setter won\'t properly handle nil.\n    if (propertyImpl->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize && (property->getPropertyAttributes() & ObjCPropertyAttribute::kind_null_resettable) && property->getGetterMethodDecl() && property->getSetterMethodDecl()) {\n      if ((!getterImpl || getterImpl->isSynthesizedAccessorStub()) && (!setterImpl || setterImpl->isSynthesizedAccessorStub())) {\n        Diag(loc, diag::warn_null_resettable_setter) << setterImpl->getSelector() << property->getDeclName();"}}

[j]={{x,11573,"void Sema::CheckReturnValExpr(Expr *RetValExp, QualType lhsType, SourceLocation ReturnLoc, bool isObjCMethod, const AttrVec *Attrs, const FunctionDecl *FD) {\n  // Check if the return value is null but should not be.\n  if (((Attrs && hasSpecificAttr<ReturnsNonNullAttr>(*Attrs)) || (!isObjCMethod && isNonNullType(lhsType))) && CheckNonNullExpr(*this, RetValExp))\n    Diag(ReturnLoc, diag::warn_null_ret) << (isObjCMethod ? 1 : 0) << RetValExp->getSourceRange();"}}

[j]={{"clang/lib/Parse/ParseStmt.cpp",1038,"/// Consume any extra semi-colons resulting in null statements,\n/// returning true if any tok::semi were consumed.\nbool Parser::ConsumeNullStmt(StmtVector &Stmts) {\n  Diag(StartLoc, diag::warn_null_statement) << FixItHint::CreateRemoval(SourceRange(StartLoc, EndLoc));"}}

[j]={{Q,6779,"/// Distribute a nullability type attribute that cannot be applied to\n/// the type specifier to a pointer, block pointer, or member pointer\n/// declarator, complaining if necessary.\n///\n/// \\returns true if the nullability annotation was distributed, false\n/// otherwise.\nstatic bool distributeNullabilityTypeAttr(TypeProcessingState &state, QualType type, ParsedAttr &attr) {\n  /// Attempt to move the attribute to the specified chunk.\n  auto moveToChunk = [&](DeclaratorChunk &chunk, bool inFunction) -> bool {\n    auto diag = state.getSema().Diag(attr.getLoc(), diag::warn_nullability_declspec) << DiagNullabilityKind(mapNullabilityAttrKind(attr.getKind()), attr.isContextSensitiveKeywordAttribute()) << type << static_cast<unsigned>(pointerKind);"}}

[j]={{"clang/lib/Parse/ParseObjc.cpp",761,"/// Diagnose redundant or conflicting nullability information.\nstatic void diagnoseRedundantPropertyNullability(Parser &P, ObjCDeclSpec &DS, NullabilityKind nullability, SourceLocation nullabilityLoc) {\n  if (DS.getNullability() == nullability) {\n    P.Diag(nullabilityLoc, diag::warn_nullability_duplicate) << DiagNullabilityKind(nullability, true) << SourceRange(DS.getNullabilityLoc());"},{Q,6643,"/// Applies a nullability type specifier to the given type, if possible.\n///\n/// \\param state The type processing state.\n///\n/// \\param type The type to which the nullability specifier will be\n/// added. On success, this type will be updated appropriately.\n///\n/// \\param attr The attribute as written on the type.\n///\n/// \\param allowOnArrayType Whether to accept nullability specifiers on an\n/// array type (e.g., because it will decay to a pointer).\n///\n/// \\returns true if a problem has been diagnosed, false on success.\nstatic bool checkNullabilityTypeSpecifier(TypeProcessingState &state, QualType &type, ParsedAttr &attr, bool allowOnArrayType) {\n  while (auto attributed = dyn_cast<AttributedType>(desugared.getTypePtr())) {\n    // Check whether there is already a null\n    if (auto existingNullability = attributed->getImmediateNullability()) {\n      // Duplicated nullability.\n      if (nullability == *existingNullability) {\n        S.Diag(nullabilityLoc, diag::warn_nullability_duplicate) << DiagNullabilityKind(nullability, isContextSensitive) << FixItHint::CreateRemoval(nullabilityLoc);"}}

[j]={{Q,4370,"static TypeSourceInfo *GetFullTypeForDeclarator(TypeProcessingState &state, QualType declSpecType, TypeSourceInfo *TInfo) {\n  // Local function that checks the nullability for a given pointer declarator.\n  // Returns true if _Nonnull was inferred.\n  auto inferPointerNullability = [&](SimplePointerKind pointerKind, SourceLocation pointerLoc, SourceLocation pointerEndLoc, ParsedAttributesView &attrs, AttributePool &Pool) -> ParsedAttr * {\n    // If we\'re supposed to infer nullability, do so now.\n    if (inferNullability && !inferNullabilityInnerOnlyComplete) {\n      if (pointerLoc.isValid() && complainAboutInferringWithinChunk != PointerWrappingDeclaratorKind::None) {\n        auto Diag = S.Diag(pointerLoc, diag::warn_nullability_inferred_on_nested_type);"}}

[j]={{V,503,"void Sema::diagnoseNullableToNonnullConversion(QualType DstType, QualType SrcType, SourceLocation Loc) {\n  Diag(Loc, diag::warn_nullability_lost) << SrcType << DstType;"}}

[j]={{Q,3937,"static void emitNullabilityConsistencyWarning(Sema &S, SimplePointerKind PointerKind, SourceLocation PointerLoc, SourceLocation PointerEndLoc) {\n  if (PointerKind == SimplePointerKind::Array) {\n  } else {\n    S.Diag(PointerLoc, diag::warn_nullability_missing) << static_cast<unsigned>(PointerKind);"},{Q,3976,"/// Complains about missing nullability if the file containing \\p pointerLoc\n/// has other uses of nullability (either the keywords or the \\c assume_nonnull\n/// pragma).\n///\n/// If the file has \\e not seen other uses of nullability, this particular\n/// pointer is saved for possible later diagnosis. See recordNullabilitySeen().\nstatic void checkNullabilityConsistency(Sema &S, SimplePointerKind pointerKind, SourceLocation pointerLoc, SourceLocation pointerEndLoc = SourceLocation()) {\n  if (!fileNullability.SawTypeNullability) {\n    if (pointerKind == SimplePointerKind::Array)\n    else\n      diagKind = diag::warn_nullability_missing;"}}

[j]={{Q,3935,"static void emitNullabilityConsistencyWarning(Sema &S, SimplePointerKind PointerKind, SourceLocation PointerLoc, SourceLocation PointerEndLoc) {\n  if (PointerKind == SimplePointerKind::Array) {\n    S.Diag(PointerLoc, diag::warn_nullability_missing_array);"},{Q,3974,"/// Complains about missing nullability if the file containing \\p pointerLoc\n/// has other uses of nullability (either the keywords or the \\c assume_nonnull\n/// pragma).\n///\n/// If the file has \\e not seen other uses of nullability, this particular\n/// pointer is saved for possible later diagnosis. See recordNullabilitySeen().\nstatic void checkNullabilityConsistency(Sema &S, SimplePointerKind pointerKind, SourceLocation pointerLoc, SourceLocation pointerEndLoc = SourceLocation()) {\n  if (!fileNullability.SawTypeNullability) {\n    if (pointerKind == SimplePointerKind::Array)\n      diagKind = diag::warn_nullability_missing_array;"}}

[j]={{Z,476,"ExprResult Sema::BuildObjCBoxedExpr(SourceRange SR, Expr *ValueExpr) {\n  if (const PointerType *PT = ValueType->getAs<PointerType>()) {\n    if (Context.hasSameUnqualifiedType(PointeeType, Context.CharTy)) {\n      // The boxed expression can be emitted as a compile time constant if it is\n      // a string literal whose character encoding is compatible with UTF-8.\n      if (auto *CE = dyn_cast<ImplicitCastExpr>(ValueExpr))\n        if (CE->getCastKind() == CK_ArrayToPointerDecay)\n          if (auto *SL = dyn_cast<StringLiteral>(CE->getSubExpr()->IgnoreParens())) {\n            Diag(SL->getBeginLoc(), diag::warn_objc_boxing_invalid_utf8_string) << NSStringPointer << SL->getSourceRange();"}}

[j]={{x,6152,"/// Diagnose use of %s directive in an NSString which is being passed\n/// as formatting string to formatting method.\nstatic void DiagnoseCStringFormatDirectiveInCFAPI(Sema &S, const NamedDecl *FDecl, Expr **Args, unsigned NumArgs) {\n  if (S.FormatStringHasSArg(FormatString)) {\n    S.Diag(FormatExpr->getExprLoc(), diag::warn_objc_cdirective_format_string) << \"%s\" << 1 << 1;"},{Z,2067,"/// Diagnose use of %s directive in an NSString which is being passed\n/// as formatting string to formatting method.\nstatic void DiagnoseCStringFormatDirectiveInObjCAPI(Sema &S, ObjCMethodDecl *Method, Selector Sel, Expr **Args, unsigned NumArgs) {\n  if (ObjCStringLiteral *OSL = dyn_cast<ObjCStringLiteral>(FormatExpr->IgnoreParenImpCasts())) {\n    if (S.FormatStringHasSArg(FormatString)) {\n      S.Diag(FormatExpr->getExprLoc(), diag::warn_objc_cdirective_format_string) << \"%s\" << 0 << 0;"}}

[j]={{x,15768,"void Sema::CheckObjCCircularContainer(ObjCMessageExpr *Message) {\n  if (Message->getReceiverKind() == ObjCMessageExpr::SuperInstance) {\n    if (DeclRefExpr *ArgRE = dyn_cast<DeclRefExpr>(Arg)) {\n      if (ArgRE->isObjCSelfExpr()) {\n        Diag(Message->getSourceRange().getBegin(), diag::warn_objc_circular_container) << ArgRE->getDecl() << StringRef(\"\'super\'\");"},{x,15782,"void Sema::CheckObjCCircularContainer(ObjCMessageExpr *Message) {\n  if (Message->getReceiverKind() == ObjCMessageExpr::SuperInstance) {\n  } else {\n    if (DeclRefExpr *ReceiverRE = dyn_cast<DeclRefExpr>(Receiver)) {\n      if (DeclRefExpr *ArgRE = dyn_cast<DeclRefExpr>(Arg)) {\n        if (ReceiverRE->getDecl() == ArgRE->getDecl()) {\n          Diag(Message->getSourceRange().getBegin(), diag::warn_objc_circular_container) << Decl << Decl;"},{x,15792,"void Sema::CheckObjCCircularContainer(ObjCMessageExpr *Message) {\n  if (Message->getReceiverKind() == ObjCMessageExpr::SuperInstance) {\n  } else {\n    if (DeclRefExpr *ReceiverRE = dyn_cast<DeclRefExpr>(Receiver)) {\n    } else if (ObjCIvarRefExpr *IvarRE = dyn_cast<ObjCIvarRefExpr>(Receiver)) {\n      if (ObjCIvarRefExpr *IvarArgRE = dyn_cast<ObjCIvarRefExpr>(Arg)) {\n        if (IvarRE->getDecl() == IvarArgRE->getDecl()) {\n          Diag(Message->getSourceRange().getBegin(), diag::warn_objc_circular_container) << Decl << Decl;"}}

[j]={{x,12933,"/// Check a single element within a collection literal against the\n/// target element type.\nstatic void checkObjCCollectionLiteralElement(Sema &S, QualType TargetElementType, Expr *Element, unsigned ElementKind) {\n  if (ElementType->getAs<ObjCObjectPointerType>() && S.CheckSingleAssignmentConstraints(TargetElementType, ElementResult, false, false) != Sema::Compatible) {\n    S.Diag(Element->getBeginLoc(), diag::warn_objc_collection_literal_element) << ElementType << ElementKind << TargetElementType << Element->getSourceRange();"}}

[j]={{G,13837,"Decl *Sema::ActOnFinishFunctionBody(Decl *dcl, Stmt *Body, bool IsInstantiation) {\n  {\n    if (FD) {\n    } else if (ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(dcl)) {\n      if (FSI->ObjCWarnForNoDesignatedInitChain) {\n        // Don\'t issue this warning for unavailable inits or direct subclasses\n        // of NSObject.\n        if (!MD->isUnavailable() && !superIsNSObject(MD)) {\n          Diag(MD->getLocation(), diag::warn_objc_designated_init_missing_super_call);"}}

[j]={{Z,2572,"/// Build an Objective-C instance message expression.\n///\n/// This routine takes care of both normal instance messages and\n/// instance messages to the superclass instance.\n///\n/// \\param Receiver The expression that computes the object that will\n/// receive this message. This may be empty, in which case we are\n/// sending to the superclass instance and \\p SuperLoc must be a valid\n/// source location.\n///\n/// \\param ReceiverType The (static) type of the object receiving the\n/// message. When a \\p Receiver expression is provided, this is the\n/// same type as that expression. For a superclass instance send, this\n/// is a pointer to the type of the superclass.\n///\n/// \\param SuperLoc The location of the \"super\" keyword in a\n/// superclass instance message.\n///\n/// \\param Sel The selector to which the message is being sent.\n///\n/// \\param Method The method that this instance message is invoking, if\n/// already known.\n///\n/// \\param LBracLoc The location of the opening square bracket \']\'.\n///\n/// \\param RBracLoc The location of the closing square bracket \']\'.\n///\n/// \\param ArgsIn The message arguments.\nExprResult Sema::BuildInstanceMessage(Expr *Receiver, QualType ReceiverType, SourceLocation SuperLoc, Selector Sel, ObjCMethodDecl *Method, SourceLocation LBracLoc, ArrayRef<SourceLocation> SelectorLocs, SourceLocation RBracLoc, MultiExprArg ArgsIn, bool isImplicit) {\n  if (DIFunctionScopeInfo && DIFunctionScopeInfo->ObjCIsDesignatedInit && (SuperLoc.isValid() || isSelfExpr(Receiver))) {\n    if (!isDesignatedInitChain) {\n      Diag(SelLoc, SuperLoc.isValid() ? diag::warn_objc_designated_init_non_designated_init_call : diag::warn_objc_designated_init_non_super_designated_init_call);"}}

[j]={{Z,2572,"/// Build an Objective-C instance message expression.\n///\n/// This routine takes care of both normal instance messages and\n/// instance messages to the superclass instance.\n///\n/// \\param Receiver The expression that computes the object that will\n/// receive this message. This may be empty, in which case we are\n/// sending to the superclass instance and \\p SuperLoc must be a valid\n/// source location.\n///\n/// \\param ReceiverType The (static) type of the object receiving the\n/// message. When a \\p Receiver expression is provided, this is the\n/// same type as that expression. For a superclass instance send, this\n/// is a pointer to the type of the superclass.\n///\n/// \\param SuperLoc The location of the \"super\" keyword in a\n/// superclass instance message.\n///\n/// \\param Sel The selector to which the message is being sent.\n///\n/// \\param Method The method that this instance message is invoking, if\n/// already known.\n///\n/// \\param LBracLoc The location of the opening square bracket \']\'.\n///\n/// \\param RBracLoc The location of the closing square bracket \']\'.\n///\n/// \\param ArgsIn The message arguments.\nExprResult Sema::BuildInstanceMessage(Expr *Receiver, QualType ReceiverType, SourceLocation SuperLoc, Selector Sel, ObjCMethodDecl *Method, SourceLocation LBracLoc, ArrayRef<SourceLocation> SelectorLocs, SourceLocation RBracLoc, MultiExprArg ArgsIn, bool isImplicit) {\n  if (DIFunctionScopeInfo && DIFunctionScopeInfo->ObjCIsDesignatedInit && (SuperLoc.isValid() || isSelfExpr(Receiver))) {\n    if (!isDesignatedInitChain) {\n      Diag(SelLoc, SuperLoc.isValid() ? diag::warn_objc_designated_init_non_designated_init_call : diag::warn_objc_designated_init_non_super_designated_init_call);"}}

[j]={{B,2585,"static void handleObjCDirectAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n  if (S.getLangOpts().ObjCRuntime.allowsDirectDispatch()) {\n  } else {\n    S.Diag(AL.getLoc(), diag::warn_objc_direct_ignored) << AL;"},{B,2593,"static void handleObjCDirectMembersAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n  if (S.getLangOpts().ObjCRuntime.allowsDirectDispatch()) {\n  } else {\n    S.Diag(AL.getLoc(), diag::warn_objc_direct_ignored) << AL;"}}

[j]={{S,590,"ObjCPropertyDecl *Sema::CreatePropertyDecl(Scope *S, ObjCContainerDecl *CDecl, SourceLocation AtLoc, SourceLocation LParenLoc, FieldDeclarator &FD, Selector GetterSel, SourceLocation GetterNameLoc, Selector SetterSel, SourceLocation SetterNameLoc, const bool isReadWrite, const unsigned Attributes, const unsigned AttributesAsWritten, QualType T, TypeSourceInfo *TInfo, tok::ObjCKeywordKind MethodImplKind, DeclContext *lexicalDC) {\n  if ((Attributes & ObjCPropertyAttribute::kind_direct) || CDecl->hasAttr<ObjCDirectMembersAttr>()) {\n    if (isa<ObjCProtocolDecl>(CDecl)) {\n    } else if (getLangOpts().ObjCRuntime.allowsDirectDispatch()) {\n    } else {\n      Diag(PDecl->getLocation(), diag::warn_objc_direct_property_ignored) << PDecl->getDeclName();"}}

[j]={{S,1872,"void Sema::DiagnoseMissingDesignatedInitOverrides(const ObjCImplementationDecl *ImplD, const ObjCInterfaceDecl *IFD) {\n  for (SmallVector<const ObjCMethodDecl *, 8>::iterator I = DesignatedInits.begin(), E = DesignatedInits.end(); I != E; ++I) {\n    if (!InitSelSet.count(MD->getSelector())) {\n      if (!Ignore) {\n        Diag(ImplD->getLocation(), diag::warn_objc_implementation_missing_designated_init_override) << MD->getSelector();"}}

[j]={{Z,3261,"template <typename TB> static bool CheckObjCBridgeNSCast(Sema &S, QualType castType, Expr *castExpr, bool &HadTheAttribute, bool warn) {\n  while (const auto *TD = T->getAs<TypedefType>()) {\n    if (TB *ObjCBAttr = getObjCBridgeAttr<TB>(TD)) {\n      if (IdentifierInfo *Parm = ObjCBAttr->getBridgedType()) {\n        if (S.LookupName(R, S.TUScope)) {\n          if (Target && isa<ObjCInterfaceDecl>(Target)) {\n            if (const ObjCObjectPointerType *InterfacePointerType = castType->getAsObjCInterfacePointerType()) {\n              if (warn)\n                S.Diag(castExpr->getBeginLoc(), diag::warn_objc_invalid_bridge) << T << Target->getName() << castType->getPointeeType();"},{Z,3270,"template <typename TB> static bool CheckObjCBridgeNSCast(Sema &S, QualType castType, Expr *castExpr, bool &HadTheAttribute, bool warn) {\n  while (const auto *TD = T->getAs<TypedefType>()) {\n    if (TB *ObjCBAttr = getObjCBridgeAttr<TB>(TD)) {\n      if (IdentifierInfo *Parm = ObjCBAttr->getBridgedType()) {\n        if (S.LookupName(R, S.TUScope)) {\n          if (Target && isa<ObjCInterfaceDecl>(Target)) {\n            if (const ObjCObjectPointerType *InterfacePointerType = castType->getAsObjCInterfacePointerType()) {\n            } else if (castType->isObjCIdType() || (S.Context.ObjCObjectAdoptsQTypeProtocols(castType, ExprClass)))\n            else {\n              if (warn) {\n                S.Diag(castExpr->getBeginLoc(), diag::warn_objc_invalid_bridge) << T << Target->getName() << castType;"}}

[j]={{Z,3313,"template <typename TB> static bool CheckObjCBridgeCFCast(Sema &S, QualType castType, Expr *castExpr, bool &HadTheAttribute, bool warn) {\n  while (const auto *TD = T->getAs<TypedefType>()) {\n    if (TB *ObjCBAttr = getObjCBridgeAttr<TB>(TD)) {\n      if (IdentifierInfo *Parm = ObjCBAttr->getBridgedType()) {\n        if (S.LookupName(R, S.TUScope)) {\n          if (Target && isa<ObjCInterfaceDecl>(Target)) {\n            if (const ObjCObjectPointerType *InterfacePointerType = castExpr->getType()->getAsObjCInterfacePointerType()) {\n              if (warn) {\n                S.Diag(castExpr->getBeginLoc(), diag::warn_objc_invalid_bridge_to_cf) << castExpr->getType()->getPointeeType() << T;"},{Z,3324,"template <typename TB> static bool CheckObjCBridgeCFCast(Sema &S, QualType castType, Expr *castExpr, bool &HadTheAttribute, bool warn) {\n  while (const auto *TD = T->getAs<TypedefType>()) {\n    if (TB *ObjCBAttr = getObjCBridgeAttr<TB>(TD)) {\n      if (IdentifierInfo *Parm = ObjCBAttr->getBridgedType()) {\n        if (S.LookupName(R, S.TUScope)) {\n          if (Target && isa<ObjCInterfaceDecl>(Target)) {\n            if (const ObjCObjectPointerType *InterfacePointerType = castExpr->getType()->getAsObjCInterfacePointerType()) {\n            } else if (castExpr->getType()->isObjCIdType() || (S.Context.QIdProtocolsAdoptObjCObjectProtocols(castExpr->getType(), CastClass)))\n            else {\n              if (warn) {\n                S.Diag(castExpr->getBeginLoc(), diag::warn_objc_invalid_bridge_to_cf) << castExpr->getType() << castType;"}}

[j]={{z,553,"static void DiagnoseDirectIsaAccess(Sema &S, const ObjCIvarRefExpr *OIRE, SourceLocation AssignLoc, const Expr *RHS) {\n  if (const ObjCObjectType *OTy = BaseType->getAs<ObjCObjectType>())\n    if (ObjCInterfaceDecl *IDecl = OTy->getInterface()) {\n      if (!ClassDeclared->getSuperClass() && (*ClassDeclared->ivar_begin()) == IV) {\n        if (RHS) {\n          if (ObjectSetClass) {\n            S.Diag(OIRE->getExprLoc(), diag::warn_objc_isa_assign) << FixItHint::CreateInsertion(OIRE->getBeginLoc(), \"object_setClass(\") << FixItHint::CreateReplacement(SourceRange(OIRE->getOpLoc(), AssignLoc), \",\") << FixItHint::CreateInsertion(RHSLocEnd, \")\");"},{z,555,"static void DiagnoseDirectIsaAccess(Sema &S, const ObjCIvarRefExpr *OIRE, SourceLocation AssignLoc, const Expr *RHS) {\n  if (const ObjCObjectType *OTy = BaseType->getAs<ObjCObjectType>())\n    if (ObjCInterfaceDecl *IDecl = OTy->getInterface()) {\n      if (!ClassDeclared->getSuperClass() && (*ClassDeclared->ivar_begin()) == IV) {\n        if (RHS) {\n          if (ObjectSetClass) {\n          } else\n            S.Diag(OIRE->getLocation(), diag::warn_objc_isa_assign);"},{z,13630,"/// CreateBuiltinBinOp - Creates a new built-in binary operation with\n/// operator @p Opc at location @c TokLoc. This routine only supports\n/// built-in operations; ActOnBinOp handles overloaded operators.\nExprResult Sema::CreateBuiltinBinOp(SourceLocation OpLoc, BinaryOperatorKind Opc, Expr *LHSExpr, Expr *RHSExpr) {\n  if (const ObjCIsaExpr *OISA = dyn_cast<ObjCIsaExpr>(LHS.get()->IgnoreParenCasts())) {\n    if (ObjectSetClass && isa<ObjCIsaExpr>(LHS.get())) {\n      Diag(LHS.get()->getExprLoc(), diag::warn_objc_isa_assign) << FixItHint::CreateInsertion(LHS.get()->getBeginLoc(), \"object_setClass(\") << FixItHint::CreateReplacement(SourceRange(OISA->getOpLoc(), OpLoc), \",\") << FixItHint::CreateInsertion(RHSLocEnd, \")\");"},{z,13632,"/// CreateBuiltinBinOp - Creates a new built-in binary operation with\n/// operator @p Opc at location @c TokLoc. This routine only supports\n/// built-in operations; ActOnBinOp handles overloaded operators.\nExprResult Sema::CreateBuiltinBinOp(SourceLocation OpLoc, BinaryOperatorKind Opc, Expr *LHSExpr, Expr *RHSExpr) {\n  if (const ObjCIsaExpr *OISA = dyn_cast<ObjCIsaExpr>(LHS.get()->IgnoreParenCasts())) {\n    if (ObjectSetClass && isa<ObjCIsaExpr>(LHS.get())) {\n    } else\n      Diag(LHS.get()->getExprLoc(), diag::warn_objc_isa_assign);"}}

[j]={{z,559,"static void DiagnoseDirectIsaAccess(Sema &S, const ObjCIvarRefExpr *OIRE, SourceLocation AssignLoc, const Expr *RHS) {\n  if (const ObjCObjectType *OTy = BaseType->getAs<ObjCObjectType>())\n    if (ObjCInterfaceDecl *IDecl = OTy->getInterface()) {\n      if (!ClassDeclared->getSuperClass() && (*ClassDeclared->ivar_begin()) == IV) {\n        if (RHS) {\n        } else {\n          if (ObjectGetClass)\n            S.Diag(OIRE->getExprLoc(), diag::warn_objc_isa_use) << FixItHint::CreateInsertion(OIRE->getBeginLoc(), \"object_getClass(\") << FixItHint::CreateReplacement(SourceRange(OIRE->getOpLoc(), OIRE->getEndLoc()), \")\");"},{z,561,"static void DiagnoseDirectIsaAccess(Sema &S, const ObjCIvarRefExpr *OIRE, SourceLocation AssignLoc, const Expr *RHS) {\n  if (const ObjCObjectType *OTy = BaseType->getAs<ObjCObjectType>())\n    if (ObjCInterfaceDecl *IDecl = OTy->getInterface()) {\n      if (!ClassDeclared->getSuperClass() && (*ClassDeclared->ivar_begin()) == IV) {\n        if (RHS) {\n        } else {\n          if (ObjectGetClass)\n          else\n            S.Diag(OIRE->getLocation(), diag::warn_objc_isa_use);"},{z,613,"ExprResult Sema::DefaultLvalueConversion(Expr *E) {\n  if (const ObjCIsaExpr *OISA = dyn_cast<ObjCIsaExpr>(E->IgnoreParenCasts())) {\n    if (ObjectGetClass)\n      Diag(E->getExprLoc(), diag::warn_objc_isa_use) << FixItHint::CreateInsertion(OISA->getBeginLoc(), \"object_getClass(\") << FixItHint::CreateReplacement(SourceRange(OISA->getOpLoc(), OISA->getIsaMemberLoc()), \")\");"},{z,615,"ExprResult Sema::DefaultLvalueConversion(Expr *E) {\n  if (const ObjCIsaExpr *OISA = dyn_cast<ObjCIsaExpr>(E->IgnoreParenCasts())) {\n    if (ObjectGetClass)\n    else\n      Diag(E->getExprLoc(), diag::warn_objc_isa_use);"}}

[j]={{z,10787,"static void diagnoseObjCLiteralComparison(Sema &S, SourceLocation Loc, ExprResult &LHS, ExprResult &RHS, BinaryOperator::Opcode Opc) {\n  if (LiteralKind == Sema::LK_String)\n  else\n    S.Diag(Loc, diag::warn_objc_literal_comparison) << LiteralKind << Literal->getSourceRange();"}}

[j]={{G,13816,"Decl *Sema::ActOnFinishFunctionBody(Decl *dcl, Stmt *Body, bool IsInstantiation) {\n  {\n    if (FD) {\n    } else if (ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(dcl)) {\n      if (FSI->ObjCShouldCallSuper) {\n        Diag(MD->getEndLoc(), diag::warn_objc_missing_super_call) << MD->getSelector().getAsString();"}}

[j]={{Y,14218,"/// Perform semantic analysis for the variable declaration that\n/// occurs within a C++ catch clause, returning the newly-created\n/// variable.\nVarDecl *Sema::BuildExceptionDeclaration(Scope *S, TypeSourceInfo *TInfo, SourceLocation StartLoc, SourceLocation Loc, IdentifierInfo *Name) {\n  // Only the non-fragile NeXT runtime currently supports C++ catches\n  // of ObjC types, and no runtime supports catching ObjC types by value.\n  if (!Invalid && getLangOpts().ObjC) {\n    if (T->isObjCObjectType()) {\n    } else if (T->isObjCObjectPointerType()) {\n      // FIXME: should this be a test for macosx-fragile specifically?\n      if (getLangOpts().ObjCRuntime.isFragile())\n        Diag(Loc, diag::warn_objc_pointer_cxx_catch_fragile);"}}

[j]={{z,13320,"/// Check if a bitwise-& is performed on an Objective-C pointer.  This\n/// is usually indicative of introspection within the Objective-C pointer.\nstatic void checkObjCPointerIntrospection(Sema &S, ExprResult &L, ExprResult &R, SourceLocation OpLoc) {\n  // This warning is deliberately made very specific to reduce false\n  // positives with logic that uses \'&\' for hashing.  This logic mainly\n  // looks for code trying to introspect into tagged pointers, which\n  // code should generally never do.\n  if (ObjCPointerExpr && isa<IntegerLiteral>(OtherExpr->IgnoreParenCasts())) {\n    unsigned Diag = diag::warn_objc_pointer_masking;"}}

[j]={{z,13330,"/// Check if a bitwise-& is performed on an Objective-C pointer.  This\n/// is usually indicative of introspection within the Objective-C pointer.\nstatic void checkObjCPointerIntrospection(Sema &S, ExprResult &L, ExprResult &R, SourceLocation OpLoc) {\n  // This warning is deliberately made very specific to reduce false\n  // positives with logic that uses \'&\' for hashing.  This logic mainly\n  // looks for code trying to introspect into tagged pointers, which\n  // code should generally never do.\n  if (ObjCPointerExpr && isa<IntegerLiteral>(OtherExpr->IgnoreParenCasts())) {\n    // Special case messages to -performSelector and friends, which\n    // can return non-pointer values boxed in a pointer value.\n    // Some clients may wish to silence warnings in this subcase.\n    if (const ObjCMessageExpr *ME = dyn_cast<ObjCMessageExpr>(Ex)) {\n      if (SelArg0.startswith(\"performSelector\"))\n        Diag = diag::warn_objc_pointer_masking_performSelector;"}}

[j]={{B,5563,"static void handleObjCPreciseLifetimeAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n  case Qualifiers::OCL_Autoreleasing:\n    S.Diag(AL.getLoc(), diag::warn_objc_precise_lifetime_meaningless) << (Lifetime == Qualifiers::OCL_Autoreleasing);"}}

[j]={{S,2121,"void Sema::CheckObjCPropertyAttributes(Decl *PDecl, SourceLocation Loc, unsigned &Attributes, bool propertyInPrimaryClass) {\n  // Check for assign on object types.\n  if ((Attributes & ObjCPropertyAttribute::kind_assign) && !(Attributes & ObjCPropertyAttribute::kind_unsafe_unretained) && PropertyTy->isObjCRetainableType() && !PropertyTy->isObjCARCImplicitlyUnretainedType()) {\n    Diag(Loc, diag::warn_objc_property_assign_on_object);"}}

[j]={{S,2245,"void Sema::CheckObjCPropertyAttributes(Decl *PDecl, SourceLocation Loc, unsigned &Attributes, bool propertyInPrimaryClass) {\n  if (!(Attributes & ObjCPropertyAttribute::kind_copy) && !(Attributes & ObjCPropertyAttribute::kind_readonly) && getLangOpts().getGC() == LangOptions::GCOnly && PropertyTy->isBlockPointerType())\n    Diag(Loc, diag::warn_objc_property_copy_missing_on_block);"}}

[j]={{S,2234,"void Sema::CheckObjCPropertyAttributes(Decl *PDecl, SourceLocation Loc, unsigned &Attributes, bool propertyInPrimaryClass) {\n  // Warn if user supplied no assignment attribute, property is\n  // readwrite, and this is an object type.\n  if (!getOwnershipRule(Attributes) && PropertyTy->isObjCRetainableType()) {\n    if (Attributes & ObjCPropertyAttribute::kind_readonly) {\n    } else if (getLangOpts().ObjCAutoRefCount) {\n    } else if (PropertyTy->isObjCObjectPointerType()) {\n      // In non-gc, non-arc mode, \'Class\' is treated as a \'void *\' no need to\n      // issue any warning.\n      if (isAnyClassTy && getLangOpts().getGC() == LangOptions::NonGC)\n      else if (propertyInPrimaryClass) {\n        // If non-gc code warn that this is likely inappropriate.\n        if (getLangOpts().getGC() == LangOptions::NonGC)\n          Diag(Loc, diag::warn_objc_property_default_assign_on_object);"}}

[j]={{S,2230,"void Sema::CheckObjCPropertyAttributes(Decl *PDecl, SourceLocation Loc, unsigned &Attributes, bool propertyInPrimaryClass) {\n  // Warn if user supplied no assignment attribute, property is\n  // readwrite, and this is an object type.\n  if (!getOwnershipRule(Attributes) && PropertyTy->isObjCRetainableType()) {\n    if (Attributes & ObjCPropertyAttribute::kind_readonly) {\n    } else if (getLangOpts().ObjCAutoRefCount) {\n    } else if (PropertyTy->isObjCObjectPointerType()) {\n      // In non-gc, non-arc mode, \'Class\' is treated as a \'void *\' no need to\n      // issue any warning.\n      if (isAnyClassTy && getLangOpts().getGC() == LangOptions::NonGC)\n      else if (propertyInPrimaryClass) {\n        // Don\'t issue warning on property with no life time in class\n        // extension as it is inherited from property in primary class.\n        // Skip this warning in gc-only mode.\n        if (getLangOpts().getGC() != LangOptions::GCOnly)\n          Diag(Loc, diag::warn_objc_property_no_assignment_attribute);"}}

[j]={{S,2247,"void Sema::CheckObjCPropertyAttributes(Decl *PDecl, SourceLocation Loc, unsigned &Attributes, bool propertyInPrimaryClass) {\n  if (!(Attributes & ObjCPropertyAttribute::kind_copy) && !(Attributes & ObjCPropertyAttribute::kind_readonly) && getLangOpts().getGC() == LangOptions::GCOnly && PropertyTy->isBlockPointerType())\n  else if ((Attributes & ObjCPropertyAttribute::kind_retain) && !(Attributes & ObjCPropertyAttribute::kind_readonly) && !(Attributes & ObjCPropertyAttribute::kind_strong) && PropertyTy->isBlockPointerType())\n    Diag(Loc, diag::warn_objc_property_retain_of_block);"}}

[j]={{"clang/lib/Parse/ParseObjc.cpp",1481,"TypeResult Parser::parseObjCProtocolQualifierType(SourceLocation &rAngleLoc) {\n  if (result.isUsable()) {\n    Diag(lAngleLoc, diag::warn_objc_protocol_qualifier_missing_id) << FixItHint::CreateInsertion(lAngleLoc, \"id\") << SourceRange(lAngleLoc, rAngleLoc);"}}

[j]={{S,2250,"void Sema::CheckObjCPropertyAttributes(Decl *PDecl, SourceLocation Loc, unsigned &Attributes, bool propertyInPrimaryClass) {\n  if ((Attributes & ObjCPropertyAttribute::kind_readonly) && (Attributes & ObjCPropertyAttribute::kind_setter))\n    Diag(Loc, diag::warn_objc_readonly_property_has_setter);"}}

[j]={{Z,2008,"static void checkCocoaAPI(Sema &S, const ObjCMessageExpr *Msg) { applyCocoaAPICheck(S, Msg, diag::warn_objc_redundant_literal_use, edit::rewriteObjCRedundantCallWithLiteral); }"}}

[j]={{N,1219,"void Sema::actOnObjCTypeArgsOrProtocolQualifiers(Scope *S, ParsedType baseType, SourceLocation lAngleLoc, ArrayRef<IdentifierInfo *> identifiers, ArrayRef<SourceLocation> identifierLocs, SourceLocation rAngleLoc, SourceLocation &typeArgsLAngleLoc, SmallVectorImpl<ParsedType> &typeArgs, SourceLocation &typeArgsRAngleLoc, SourceLocation &protocolLAngleLoc, SmallVectorImpl<Decl *> &protocols, SourceLocation &protocolRAngleLoc, bool warnOnIncompleteProtocols) {\n  auto resolvedAsProtocols = [&] {\n    // All of the protocols listed also have type names, and at least\n    // one is an Objective-C class name. Check whether all of the\n    // protocol conformances are declared by the base class itself, in\n    // which case we warn.\n    if (allAreTypeNames && firstClassNameLoc.isValid()) {\n      if (allProtocolsDeclared) {\n        Diag(firstClassNameLoc, diag::warn_objc_redundant_qualified_class_type) << baseClass->getDeclName() << SourceRange(lAngleLoc, rAngleLoc) << FixItHint::CreateInsertion(getLocForEndOfToken(firstClassNameLoc), \" *\");"}}

[j]={{B,5390,"static void handleObjCRequiresSuperAttr(Sema &S, Decl *D, const ParsedAttr &Attrs) {\n  if (const auto *PDecl = dyn_cast_or_null<ObjCProtocolDecl>(DC)) {\n    S.Diag(D->getBeginLoc(), diag::warn_objc_requires_super_protocol) << Attrs << 0;"},{B,5395,"static void handleObjCRequiresSuperAttr(Sema &S, Decl *D, const ParsedAttr &Attrs) {\n  if (Method->getMethodFamily() == OMF_dealloc) {\n    S.Diag(D->getBeginLoc(), diag::warn_objc_requires_super_protocol) << Attrs << 1;"}}

[j]={{N,3400,"// Note: For class/category implementations, allMethods is always null.\nDecl *Sema::ActOnAtEnd(Scope *S, SourceRange AtEnd, ArrayRef<Decl *> allMethods, ArrayRef<DeclGroupPtrTy> allTUVars) {\n  if (ObjCImplementationDecl *IC = dyn_cast<ObjCImplementationDecl>(ClassDecl)) {\n    if (ObjCInterfaceDecl *IDecl = IC->getClassInterface()) {\n      if (IDecl->getSuperClass() == nullptr) {\n        // This class has no superclass, so check that it has been marked with\n        // __attribute((objc_root_class)).\n        if (!HasRootClassAttr) {\n          Diag(DeclLoc, diag::warn_objc_root_class_missing) << IDecl->getIdentifier();"}}

[j]={{G,13845,"Decl *Sema::ActOnFinishFunctionBody(Decl *dcl, Stmt *Body, bool IsInstantiation) {\n  {\n    if (FD) {\n    } else if (ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(dcl)) {\n      if (FSI->ObjCWarnForNoInitDelegation) {\n        // Don\'t issue this warning for unavaialable inits.\n        if (!MD->isUnavailable())\n          Diag(MD->getLocation(), diag::warn_objc_secondary_init_missing_init_call);"}}

[j]={{Z,2579,"/// Build an Objective-C instance message expression.\n///\n/// This routine takes care of both normal instance messages and\n/// instance messages to the superclass instance.\n///\n/// \\param Receiver The expression that computes the object that will\n/// receive this message. This may be empty, in which case we are\n/// sending to the superclass instance and \\p SuperLoc must be a valid\n/// source location.\n///\n/// \\param ReceiverType The (static) type of the object receiving the\n/// message. When a \\p Receiver expression is provided, this is the\n/// same type as that expression. For a superclass instance send, this\n/// is a pointer to the type of the superclass.\n///\n/// \\param SuperLoc The location of the \"super\" keyword in a\n/// superclass instance message.\n///\n/// \\param Sel The selector to which the message is being sent.\n///\n/// \\param Method The method that this instance message is invoking, if\n/// already known.\n///\n/// \\param LBracLoc The location of the opening square bracket \']\'.\n///\n/// \\param RBracLoc The location of the closing square bracket \']\'.\n///\n/// \\param ArgsIn The message arguments.\nExprResult Sema::BuildInstanceMessage(Expr *Receiver, QualType ReceiverType, SourceLocation SuperLoc, Selector Sel, ObjCMethodDecl *Method, SourceLocation LBracLoc, ArrayRef<SourceLocation> SelectorLocs, SourceLocation RBracLoc, MultiExprArg ArgsIn, bool isImplicit) {\n  if (DIFunctionScopeInfo && DIFunctionScopeInfo->ObjCIsSecondaryInit && (SuperLoc.isValid() || isSelfExpr(Receiver))) {\n    if (SuperLoc.isValid()) {\n      Diag(SelLoc, diag::warn_objc_secondary_init_super_init_call);"}}

[j]={{z,10785,"static void diagnoseObjCLiteralComparison(Sema &S, SourceLocation Loc, ExprResult &LHS, ExprResult &RHS, BinaryOperator::Opcode Opc) {\n  if (LiteralKind == Sema::LK_String)\n    S.Diag(Loc, diag::warn_objc_string_literal_comparison) << Literal->getSourceRange();"}}

[j]={{Z,2038,"static void checkFoundationAPI(Sema &S, SourceLocation Loc, const ObjCMethodDecl *Method, ArrayRef<Expr *> Args, QualType ReceiverType, bool IsClassObjectCall) {\n  if (Ret->isRecordType() || Ret->isVectorType() || Ret->isExtVectorType()) {\n    S.Diag(Loc, diag::warn_objc_unsafe_perform_selector) << Method->getSelector() << (!Ret->isRecordType() ? /*Vector*/ 2 : Ret->isUnionType() ? /*Union*/ 1 : /*Struct*/ 0);"}}

[j]={{fb,1809,"unsigned StructuralEquivalenceContext::getApplicableDiagnostic(unsigned ErrorDiagnostic) {\n  case diag::err_odr_different_num_template_parameters:\n    return diag::warn_odr_different_num_template_parameters;"}}

[j]={{fb,1811,"unsigned StructuralEquivalenceContext::getApplicableDiagnostic(unsigned ErrorDiagnostic) {\n  case diag::err_odr_different_template_parameter_kind:\n    return diag::warn_odr_different_template_parameter_kind;"}}

[j]={{sb,3481,"ExpectedDecl ASTNodeImporter::VisitFieldDecl(FieldDecl *D) {\n  for (auto *FoundDecl : FoundDecls) {\n    if (FieldDecl *FoundField = dyn_cast<FieldDecl>(FoundDecl)) {\n      Importer.ToDiag(Loc, diag::warn_odr_field_type_inconsistent) << Name << D->getType() << FoundField->getType();"},{sb,3550,"ExpectedDecl ASTNodeImporter::VisitIndirectFieldDecl(IndirectFieldDecl *D) {\n  for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {\n    if (auto *FoundField = dyn_cast<IndirectFieldDecl>(FoundDecls[I])) {\n      Importer.ToDiag(Loc, diag::warn_odr_field_type_inconsistent) << Name << D->getType() << FoundField->getType();"},{fb,1789,"unsigned StructuralEquivalenceContext::getApplicableDiagnostic(unsigned ErrorDiagnostic) {\n  case diag::err_odr_field_type_inconsistent:\n    return diag::warn_odr_field_type_inconsistent;"}}

[j]={{sb,3171,"ExpectedDecl ASTNodeImporter::VisitFunctionDecl(FunctionDecl *D) {\n  }\n  // Try to find a function in our own (\"to\") context with the same name, same\n  // type, and in the same context as the function we\'re importing.\n  else if (!LexicalDC->isFunctionOrMethod()) {\n    for (auto *FoundDecl : FoundDecls) {\n      if (auto *FoundFunction = dyn_cast<FunctionDecl>(FoundDecl)) {\n        Importer.ToDiag(Loc, diag::warn_odr_function_type_inconsistent) << Name << D->getType() << FoundFunction->getType();"},{fb,1785,"unsigned StructuralEquivalenceContext::getApplicableDiagnostic(unsigned ErrorDiagnostic) {\n  case diag::err_odr_function_type_inconsistent:\n    return diag::warn_odr_function_type_inconsistent;"}}

[j]={{sb,3724,"ExpectedDecl ASTNodeImporter::VisitObjCIvarDecl(ObjCIvarDecl *D) {\n  for (auto *FoundDecl : FoundDecls) {\n    if (ObjCIvarDecl *FoundIvar = dyn_cast<ObjCIvarDecl>(FoundDecl)) {\n      Importer.ToDiag(Loc, diag::warn_odr_ivar_type_inconsistent) << Name << D->getType() << FoundIvar->getType();"},{fb,1791,"unsigned StructuralEquivalenceContext::getApplicableDiagnostic(unsigned ErrorDiagnostic) {\n  case diag::err_odr_ivar_type_inconsistent:\n    return diag::warn_odr_ivar_type_inconsistent;"}}

[j]={{fb,1815,"unsigned StructuralEquivalenceContext::getApplicableDiagnostic(unsigned ErrorDiagnostic) {\n  case diag::err_odr_non_type_parameter_type_inconsistent:\n    return diag::warn_odr_non_type_parameter_type_inconsistent;"}}

[j]={{sb,4008,"ExpectedDecl ASTNodeImporter::VisitObjCMethodDecl(ObjCMethodDecl *D) {\n  for (auto *FoundDecl : FoundDecls) {\n    if (auto *FoundMethod = dyn_cast<ObjCMethodDecl>(FoundDecl)) {\n      // Check the number of parameters.\n      if (D->param_size() != FoundMethod->param_size()) {\n        Importer.ToDiag(Loc, diag::warn_odr_objc_method_num_params_inconsistent) << D->isInstanceMethod() << Name << D->param_size() << FoundMethod->param_size();"},{fb,1797,"unsigned StructuralEquivalenceContext::getApplicableDiagnostic(unsigned ErrorDiagnostic) {\n  case diag::err_odr_objc_method_num_params_inconsistent:\n    return diag::warn_odr_objc_method_num_params_inconsistent;"}}

[j]={{sb,4017,"ExpectedDecl ASTNodeImporter::VisitObjCMethodDecl(ObjCMethodDecl *D) {\n  for (auto *FoundDecl : FoundDecls) {\n    if (auto *FoundMethod = dyn_cast<ObjCMethodDecl>(FoundDecl)) {\n      // Check parameter types.\n      for (ObjCMethodDecl::param_iterator P = D->param_begin(), PEnd = D->param_end(), FoundP = FoundMethod->param_begin(); P != PEnd; ++P, ++FoundP) {\n        if (!Importer.IsStructurallyEquivalent((*P)->getType(), (*FoundP)->getType())) {\n          Importer.FromDiag((*P)->getLocation(), diag::warn_odr_objc_method_param_type_inconsistent) << D->isInstanceMethod() << Name << (*P)->getType() << (*FoundP)->getType();"},{fb,1799,"unsigned StructuralEquivalenceContext::getApplicableDiagnostic(unsigned ErrorDiagnostic) {\n  case diag::err_odr_objc_method_param_type_inconsistent:\n    return diag::warn_odr_objc_method_param_type_inconsistent;"}}

[j]={{sb,4000,"ExpectedDecl ASTNodeImporter::VisitObjCMethodDecl(ObjCMethodDecl *D) {\n  for (auto *FoundDecl : FoundDecls) {\n    if (auto *FoundMethod = dyn_cast<ObjCMethodDecl>(FoundDecl)) {\n      // Check return types.\n      if (!Importer.IsStructurallyEquivalent(D->getReturnType(), FoundMethod->getReturnType())) {\n        Importer.ToDiag(Loc, diag::warn_odr_objc_method_result_type_inconsistent) << D->isInstanceMethod() << Name << D->getReturnType() << FoundMethod->getReturnType();"},{fb,1795,"unsigned StructuralEquivalenceContext::getApplicableDiagnostic(unsigned ErrorDiagnostic) {\n  case diag::err_odr_objc_method_result_type_inconsistent:\n    return diag::warn_odr_objc_method_result_type_inconsistent;"}}

[j]={{sb,4027,"ExpectedDecl ASTNodeImporter::VisitObjCMethodDecl(ObjCMethodDecl *D) {\n  for (auto *FoundDecl : FoundDecls) {\n    if (auto *FoundMethod = dyn_cast<ObjCMethodDecl>(FoundDecl)) {\n      // Check variadic/non-variadic.\n      // Check the number of parameters.\n      if (D->isVariadic() != FoundMethod->isVariadic()) {\n        Importer.ToDiag(Loc, diag::warn_odr_objc_method_variadic_inconsistent) << D->isInstanceMethod() << Name;"},{fb,1801,"unsigned StructuralEquivalenceContext::getApplicableDiagnostic(unsigned ErrorDiagnostic) {\n  case diag::err_odr_objc_method_variadic_inconsistent:\n    return diag::warn_odr_objc_method_variadic_inconsistent;"}}

[j]={{sb,4964,"ExpectedDecl ASTNodeImporter::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) {\n  if (!ToImpl) {\n  } else {\n    // Check that we have the same kind of property implementation (@synthesize\n    // vs. @dynamic).\n    if (D->getPropertyImplementation() != ToImpl->getPropertyImplementation()) {\n      Importer.ToDiag(ToImpl->getLocation(), diag::warn_odr_objc_property_impl_kind_inconsistent) << Property->getDeclName() << (ToImpl->getPropertyImplementation() == ObjCPropertyImplDecl::Dynamic);"},{fb,1805,"unsigned StructuralEquivalenceContext::getApplicableDiagnostic(unsigned ErrorDiagnostic) {\n  case diag::err_odr_objc_property_impl_kind_inconsistent:\n    return diag::warn_odr_objc_property_impl_kind_inconsistent;"}}

[j]={{sb,4879,"ExpectedDecl ASTNodeImporter::VisitObjCPropertyDecl(ObjCPropertyDecl *D) {\n  for (auto *FoundDecl : FoundDecls) {\n    if (auto *FoundProp = dyn_cast<ObjCPropertyDecl>(FoundDecl)) {\n      // Check property types.\n      if (!Importer.IsStructurallyEquivalent(D->getType(), FoundProp->getType())) {\n        Importer.ToDiag(Loc, diag::warn_odr_objc_property_type_inconsistent) << Name << D->getType() << FoundProp->getType();"},{fb,1803,"unsigned StructuralEquivalenceContext::getApplicableDiagnostic(unsigned ErrorDiagnostic) {\n  case diag::err_odr_objc_property_type_inconsistent:\n    return diag::warn_odr_objc_property_type_inconsistent;"}}

[j]={{sb,4604,"Error ASTNodeImporter::ImportDefinition(ObjCInterfaceDecl *From, ObjCInterfaceDecl *To, ImportDefinitionKind Kind) {\n  if (To->getDefinition()) {\n    if ((bool)FromSuper != (bool)ToSuper || (FromSuper && !declaresSameEntity(FromSuper, ToSuper))) {\n      Importer.ToDiag(To->getLocation(), diag::warn_odr_objc_superclass_inconsistent) << To->getDeclName();"},{sb,4834,"ExpectedDecl ASTNodeImporter::VisitObjCImplementationDecl(ObjCImplementationDecl *D) {\n  if (!Impl) {\n  } else {\n    // Verify that the existing @implementation has the same superclass.\n    if ((Super && !Impl->getSuperClass()) || (!Super && Impl->getSuperClass()) || (Super && Impl->getSuperClass() && !declaresSameEntity(Super->getCanonicalDecl(), Impl->getSuperClass()))) {\n      Importer.ToDiag(Impl->getLocation(), diag::warn_odr_objc_superclass_inconsistent) << Iface->getDeclName();"},{fb,1793,"unsigned StructuralEquivalenceContext::getApplicableDiagnostic(unsigned ErrorDiagnostic) {\n  case diag::err_odr_objc_superclass_inconsistent:\n    return diag::warn_odr_objc_superclass_inconsistent;"}}

[j]={{sb,4972,"ExpectedDecl ASTNodeImporter::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) {\n  if (!ToImpl) {\n  } else {\n    // For @synthesize, check that we have the same\n    if (D->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize && Ivar != ToImpl->getPropertyIvarDecl()) {\n      Importer.ToDiag(ToImpl->getPropertyIvarDeclLoc(), diag::warn_odr_objc_synthesize_ivar_inconsistent) << Property->getDeclName() << ToImpl->getPropertyIvarDecl()->getDeclName() << Ivar->getDeclName();"},{fb,1807,"unsigned StructuralEquivalenceContext::getApplicableDiagnostic(unsigned ErrorDiagnostic) {\n  case diag::err_odr_objc_synthesize_ivar_inconsistent:\n    return diag::warn_odr_objc_synthesize_ivar_inconsistent;"}}

[j]={{fb,1813,"unsigned StructuralEquivalenceContext::getApplicableDiagnostic(unsigned ErrorDiagnostic) {\n  case diag::err_odr_parameter_pack_non_pack:\n    return diag::warn_odr_parameter_pack_non_pack;"}}

[j]={{fb,1787,"unsigned StructuralEquivalenceContext::getApplicableDiagnostic(unsigned ErrorDiagnostic) {\n  case diag::err_odr_tag_type_inconsistent:\n    return diag::warn_odr_tag_type_inconsistent;"}}

[j]={{fb,1783,"unsigned StructuralEquivalenceContext::getApplicableDiagnostic(unsigned ErrorDiagnostic) {\n  case diag::err_odr_variable_multiple_def:\n    return diag::warn_odr_variable_multiple_def;"}}

[j]={{sb,3824,"ExpectedDecl ASTNodeImporter::VisitVarDecl(VarDecl *D) {\n  if (D->isFileVarDecl()) {\n    for (auto *FoundDecl : FoundDecls) {\n      if (auto *FoundVar = dyn_cast<VarDecl>(FoundDecl)) {\n        Importer.ToDiag(Loc, diag::warn_odr_variable_type_inconsistent) << Name << D->getType() << FoundVar->getType();"},{fb,1781,"unsigned StructuralEquivalenceContext::getApplicableDiagnostic(unsigned ErrorDiagnostic) {\n  case diag::err_odr_variable_type_inconsistent:\n    return diag::warn_odr_variable_type_inconsistent;"}}

[j]={{z,3662,"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      // Are long/unsigned long possibilities?\n      if (Ty.isNull() && !Literal.isLongLong && !Literal.isSizeT) {\n        // Does it fit in a unsigned long?\n        if (ResultVal.isIntN(LongSize)) {\n          // Does it fit in a signed long?\n          if (!Literal.isUnsigned && ResultVal[LongSize - 1] == 0)\n          else if (AllowUnsigned)\n          // Check according to the rules of C90 6.1.3.2p5. C++03 [lex.icon]p2\n          // is compatible.\n          else if (!getLangOpts().C99 && !getLangOpts().CPlusPlus11) {\n            Diag(Tok.getLocation(), getLangOpts().CPlusPlus ? Literal.isLong ? diag::warn_old_implicitly_unsigned_long_cxx : /*C++98 UB*/ diag::ext_old_implicitly_unsigned_long_cxx : diag::warn_old_implicitly_unsigned_long) << (LongLongSize > LongSize ? /*will have type \'long long\'*/ 0 : /*will be ill-formed*/ 1);"}}

[j]={{z,3662,"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      // Are long/unsigned long possibilities?\n      if (Ty.isNull() && !Literal.isLongLong && !Literal.isSizeT) {\n        // Does it fit in a unsigned long?\n        if (ResultVal.isIntN(LongSize)) {\n          // Does it fit in a signed long?\n          if (!Literal.isUnsigned && ResultVal[LongSize - 1] == 0)\n          else if (AllowUnsigned)\n          // Check according to the rules of C90 6.1.3.2p5. C++03 [lex.icon]p2\n          // is compatible.\n          else if (!getLangOpts().C99 && !getLangOpts().CPlusPlus11) {\n            Diag(Tok.getLocation(), getLangOpts().CPlusPlus ? Literal.isLong ? diag::warn_old_implicitly_unsigned_long_cxx : /*C++98 UB*/ diag::ext_old_implicitly_unsigned_long_cxx : diag::warn_old_implicitly_unsigned_long) << (LongLongSize > LongSize ? /*will have type \'long long\'*/ 0 : /*will be ill-formed*/ 1);"}}

[j]={{z,7290,"ExprResult Sema::ActOnCastExpr(Scope *S, SourceLocation LParenLoc, Declarator &D, ParsedType &Ty, SourceLocation RParenLoc, Expr *CastExpr) {\n  if (getLangOpts().CPlusPlus && !castType->isVoidType())\n    Diag(LParenLoc, diag::warn_old_style_cast) << CastExpr->getSourceRange();"}}

[j]={{"clang/lib/Parse/ParseDeclCXX.cpp",3859,"/// ParseCXX11AttributeArgs -- Parse a C++11 attribute-argument-clause.\n///\n/// [C++11] attribute-argument-clause:\n///        \'(\' balanced-token-seq \')\'\n///\n/// [C++11] balanced-token-seq:\n///        balanced-token\n///        balanced-token-seq balanced-token\n///\n/// [C++11] balanced-token:\n///        \'(\' balanced-token-seq \')\'\n///        \'[\' balanced-token-seq \']\'\n///        \'{\' balanced-token-seq \'}\'\n///        any token but \'(\', \')\', \'[\', \']\', \'{\', or \'}\'\nbool Parser::ParseCXX11AttributeArgs(IdentifierInfo *AttrName, SourceLocation AttrNameLoc, ParsedAttributes &Attrs, SourceLocation *EndLoc, IdentifierInfo *ScopeName, SourceLocation ScopeLoc, CachedTokens &OpenMPTokens) {\n  if (ScopeName && ScopeName->isStr(\"omp\")) {\n    Diag(AttrNameLoc, getLangOpts().OpenMP >= 51 ? diag::warn_omp51_compat_attributes : diag::ext_omp_attributes);"}}

[j]={{nb,13581,"ExprResult Sema::VerifyPositiveIntegerConstantInClause(Expr *E, OpenMPClauseKind CKind, bool StrictlyPositive, bool SuppressExprDiags) {\n  if ((CKind == OMPC_aligned || CKind == OMPC_align) && !Result.isPowerOf2()) {\n    Diag(E->getExprLoc(), diag::warn_omp_alignment_not_power_of_two) << E->getSourceRange();"}}

[j]={{nb,4301,"static void checkAllocateClauses(Sema &S, DSAStackTy *Stack, ArrayRef<OMPClause *> Clauses) {\n  for (OMPClause *C : AllocateRange) {\n    // OpenMP, 2.11.4 allocate Clause, Restrictions.\n    // For task, taskloop or target directives, allocation requests to memory\n    // allocators with the trait access set to thread result in unspecified\n    // behavior.\n    if (AllocatorKind == OMPAllocateDeclAttr::OMPThreadMemAlloc && (isOpenMPTaskingDirective(Stack->getCurrentDirective()) || isOpenMPTargetExecutionDirective(Stack->getCurrentDirective()))) {\n      S.Diag(AC->getAllocator()->getExprLoc(), diag::warn_omp_allocate_thread_on_task_target_directive) << getOpenMPDirectiveName(Stack->getCurrentDirective());"}}

[j]={{M,807,"void Parser::parseOMPContextProperty(OMPTraitSelector &TISelector, llvm::omp::TraitSet Set, llvm::StringMap<SourceLocation> &Seen) {\n  Diag(PropertyLoc, diag::warn_omp_ctx_incompatible_property_for_selector) << getOpenMPContextTraitPropertyName(TIProperty.Kind, TIProperty.RawString) << getOpenMPContextTraitSelectorName(TISelector.Kind) << getOpenMPContextTraitSetName(Set);"}}

[j]={{M,940,"/// Parses an OpenMP context selector.\n///\n/// <trait-selector-name> [\'(\'[<trait-score>] <trait-property> [, <t-p>]* \')\']\nvoid Parser::parseOMPContextSelector(OMPTraitSelector &TISelector, llvm::omp::TraitSet Set, llvm::StringMap<SourceLocation> &SeenSelectors) {\n  if (!AllowsTraitScore && !Score.isUnset()) {\n    if (Score.isUsable()) {\n      Diag(ScoreLoc, diag::warn_omp_ctx_incompatible_score_for_property) << getOpenMPContextTraitSelectorName(TISelector.Kind) << getOpenMPContextTraitSetName(Set) << Score.get();"},{M,942,"/// Parses an OpenMP context selector.\n///\n/// <trait-selector-name> [\'(\'[<trait-score>] <trait-property> [, <t-p>]* \')\']\nvoid Parser::parseOMPContextSelector(OMPTraitSelector &TISelector, llvm::omp::TraitSet Set, llvm::StringMap<SourceLocation> &SeenSelectors) {\n  if (!AllowsTraitScore && !Score.isUnset()) {\n    if (Score.isUsable()) {\n    } else {\n      Diag(ScoreLoc, diag::warn_omp_ctx_incompatible_score_for_property) << getOpenMPContextTraitSelectorName(TISelector.Kind) << getOpenMPContextTraitSetName(Set) << \"<invalid>\";"}}

[j]={{M,906,"/// Parses an OpenMP context selector.\n///\n/// <trait-selector-name> [\'(\'[<trait-score>] <trait-property> [, <t-p>]* \')\']\nvoid Parser::parseOMPContextSelector(OMPTraitSelector &TISelector, llvm::omp::TraitSet Set, llvm::StringMap<SourceLocation> &SeenSelectors) {\n  if (!isValidTraitSelectorForTraitSet(TISelector.Kind, Set, AllowsTraitScore, RequiresProperty)) {\n    Diag(SelectorLoc, diag::warn_omp_ctx_incompatible_selector_for_set) << getOpenMPContextTraitSelectorName(TISelector.Kind) << getOpenMPContextTraitSetName(Set);"}}

[j]={{M,917,"/// Parses an OpenMP context selector.\n///\n/// <trait-selector-name> [\'(\'[<trait-score>] <trait-property> [, <t-p>]* \')\']\nvoid Parser::parseOMPContextSelector(OMPTraitSelector &TISelector, llvm::omp::TraitSet Set, llvm::StringMap<SourceLocation> &SeenSelectors) {\n  if (!Tok.is(tok::l_paren)) {\n    Diag(SelectorLoc, diag::warn_omp_ctx_selector_without_properties) << getOpenMPContextTraitSelectorName(TISelector.Kind) << getOpenMPContextTraitSetName(Set);"}}

[j]={{nb,18874,"void Sema::ActOnOpenMPDeclareTargetName(NamedDecl *ND, SourceLocation Loc, OMPDeclareTargetDeclAttr::MapTypeTy MT, DeclareTargetContextInfo &DTCI) {\n  // Diagnose marking after use as it may lead to incorrect diagnosis and\n  // codegen.\n  if (LangOpts.OpenMP >= 50 && (ND->isUsed(/*CheckUsedAttr=*/false) || ND->isReferenced()))\n    Diag(Loc, diag::warn_omp_declare_target_after_first_use);"}}

[j]={{nb,5869,"std::optional<std::pair<FunctionDecl *, Expr *>> Sema::checkOpenMPDeclareVariantFunction(Sema::DeclGroupPtrTy DG, Expr *VariantRef, OMPTraitInfo &TI, unsigned NumAppendArgs, SourceRange SR) {\n  if (!FD->isThisDeclarationADefinition() && FD->isDefined(Definition) && (LangOpts.EmitAllDecls || Context.DeclMustBeEmitted(Definition)))\n    Diag(SR.getBegin(), diag::warn_omp_declare_variant_after_emitted) << FD->getLocation();"}}

[j]={{nb,5864,"std::optional<std::pair<FunctionDecl *, Expr *>> Sema::checkOpenMPDeclareVariantFunction(Sema::DeclGroupPtrTy DG, Expr *VariantRef, OMPTraitInfo &TI, unsigned NumAppendArgs, SourceRange SR) {\n  // Allow #pragma omp declare variant only if the function is not used.\n  if (FD->isUsed(false))\n    Diag(SR.getBegin(), diag::warn_omp_declare_variant_after_used) << FD->getLocation();"}}

[j]={{M,695,"static bool checkForDuplicates(Parser &P, StringRef Name, SourceLocation NameLoc, llvm::StringMap<SourceLocation> &Seen, OMPContextLvl Lvl) {\n  P.Diag(NameLoc, diag::warn_omp_declare_variant_ctx_mutiple_use) << Lvl << Name;"}}

[j]={{M,721,"void Parser::parseOMPTraitPropertyKind(OMPTraitProperty &TIProperty, llvm::omp::TraitSet Set, llvm::omp::TraitSelector Selector, llvm::StringMap<SourceLocation> &Seen) {\n  Diag(NameLoc, diag::warn_omp_declare_variant_ctx_not_a_property) << Name << getOpenMPContextTraitSelectorName(Selector) << getOpenMPContextTraitSetName(Set);"}}

[j]={{M,830,"void Parser::parseOMPTraitSelectorKind(OMPTraitSelector &TISelector, llvm::omp::TraitSet Set, llvm::StringMap<SourceLocation> &Seen) {\n  Diag(NameLoc, diag::warn_omp_declare_variant_ctx_not_a_selector) << Name << getOpenMPContextTraitSetName(Set);"}}

[j]={{M,977,"void Parser::parseOMPTraitSetKind(OMPTraitSet &TISet, llvm::StringMap<SourceLocation> &Seen) {\n  Diag(NameLoc, diag::warn_omp_declare_variant_ctx_not_a_set) << Name;"}}

[j]={{M,864,"/// Parse optional \'score\' \'(\' <expr> \')\' \':\'.\nstatic ExprResult parseContextScore(Parser &P) {\n  // Parse \':\'\n  if (P.getCurToken().is(tok::colon))\n  else\n    P.Diag(P.getCurToken(), diag::warn_omp_declare_variant_expected) << \"\':\'\""},{M,1034,"/// Parses an OpenMP context selector set.\n///\n/// <trait-set-selector-name> \'=\' \'{\' <trait-selector> [, <trait-selector>]* \'}\'\nvoid Parser::parseOMPContextSelectorSet(OMPTraitSet &TISet, llvm::StringMap<SourceLocation> &SeenSets) {\n  // Parse \'=\'.\n  if (!TryConsumeToken(tok::equal))\n    Diag(Tok.getLocation(), diag::warn_omp_declare_variant_expected) << \"=\" << (\"context set name \\\"\" + getOpenMPContextTraitSetName(TISet.Kind) + \"\\\"\").str();"},{M,1040,"/// Parses an OpenMP context selector set.\n///\n/// <trait-set-selector-name> \'=\' \'{\' <trait-selector> [, <trait-selector>]* \'}\'\nvoid Parser::parseOMPContextSelectorSet(OMPTraitSet &TISet, llvm::StringMap<SourceLocation> &SeenSets) {\n  // Parse \'{\'.\n  if (Tok.is(tok::l_brace)) {\n  } else {\n    Diag(Tok.getLocation(), diag::warn_omp_declare_variant_expected) << \"{\" << (\"\'=\' that follows the context set name \\\"\" + getOpenMPContextTraitSetName(TISet.Kind) + \"\\\"\").str();"},{M,1055,"/// Parses an OpenMP context selector set.\n///\n/// <trait-set-selector-name> \'=\' \'{\' <trait-selector> [, <trait-selector>]* \'}\'\nvoid Parser::parseOMPContextSelectorSet(OMPTraitSet &TISet, llvm::StringMap<SourceLocation> &SeenSets) {\n  // Parse \'}\'.\n  if (Tok.is(tok::r_brace)) {\n  } else {\n    Diag(Tok.getLocation(), diag::warn_omp_declare_variant_expected) << \"}\" << (\"context selectors for the context set \\\"\" + getOpenMPContextTraitSetName(TISet.Kind) + \"\\\"\").str();"}}

[j]={{nb,6019,"std::optional<std::pair<FunctionDecl *, Expr *>> Sema::checkOpenMPDeclareVariantFunction(Sema::DeclGroupPtrTy DG, Expr *VariantRef, OMPTraitInfo &TI, unsigned NumAppendArgs, SourceRange SR) {\n  // Check if variant function is not marked with declare variant directive.\n  if (NewFD->hasAttrs() && NewFD->hasAttr<OMPDeclareVariantAttr>()) {\n    Diag(VariantRef->getExprLoc(), diag::warn_omp_declare_variant_marked_as_declare_variant) << VariantRef->getSourceRange();"}}

[j]={{nb,5889,"std::optional<std::pair<FunctionDecl *, Expr *>> Sema::checkOpenMPDeclareVariantFunction(Sema::DeclGroupPtrTy DG, Expr *VariantRef, OMPTraitInfo &TI, unsigned NumAppendArgs, SourceRange SR) {\n  // Deal with non-constant score and user condition expressions.\n  auto HandleNonConstantScoresAndConditions = [this](Expr *&E, bool IsScore) -> bool {\n    if (IsScore) {\n      Diag(E->getExprLoc(), diag::warn_omp_declare_variant_score_not_constant) << E;"}}

[j]={{M,684,"static StringRef getNameFromIdOrString(Parser &P, Token &Tok, OMPContextLvl Lvl) {\n  P.Diag(Tok.getLocation(), diag::warn_omp_declare_variant_string_literal_or_identifier) << Lvl;"}}

[j]={{M,2847,"/// Parsing of OpenMP clauses.\n///\n///    clause:\n///      if-clause | final-clause | num_threads-clause | safelen-clause |\n///      default-clause | private-clause | firstprivate-clause | shared-clause\n///      | linear-clause | aligned-clause | collapse-clause | bind-clause |\n///      lastprivate-clause | reduction-clause | proc_bind-clause |\n///      schedule-clause | copyin-clause | copyprivate-clause | untied-clause |\n///      mergeable-clause | flush-clause | read-clause | write-clause |\n///      update-clause | capture-clause | seq_cst-clause | device-clause |\n///      simdlen-clause | threads-clause | simd-clause | num_teams-clause |\n///      thread_limit-clause | priority-clause | grainsize-clause |\n///      nogroup-clause | num_tasks-clause | hint-clause | to-clause |\n///      from-clause | is_device_ptr-clause | task_reduction-clause |\n///      in_reduction-clause | allocator-clause | allocate-clause |\n///      acq_rel-clause | acquire-clause | release-clause | relaxed-clause |\n///      depobj-clause | destroy-clause | detach-clause | inclusive-clause |\n///      exclusive-clause | uses_allocators-clause | use_device_addr-clause |\n///      has_device_addr\n///\nOMPClause *Parser::ParseOpenMPClause(OpenMPDirectiveKind DKind, OpenMPClauseKind CKind, bool FirstClause) {\n  case OMPC_doacross:\n    if (getLangOpts().OpenMP >= 52 && DKind == OMPD_ordered && CKind == OMPC_depend)\n      Diag(Tok, diag::warn_omp_depend_in_ordered_deprecated);"}}

[j]={{M,1571,"void Parser::skipUntilPragmaOpenMPEnd(OpenMPDirectiveKind DKind) {\n  Diag(Tok, diag::warn_omp_extra_tokens_at_eol) << getOpenMPDirectiveName(DKind);"}}

[j]={{nb,16487,"OMPClause *Sema::ActOnOpenMPLinearClause(ArrayRef<Expr *> VarList, Expr *Step, SourceLocation StartLoc, SourceLocation LParenLoc, OpenMPLinearClauseKind LinKind, SourceLocation LinLoc, SourceLocation ColonLoc, SourceLocation EndLoc) {\n  if (Step && !Step->isValueDependent() && !Step->isTypeDependent() && !Step->isInstantiationDependent() && !Step->containsUnexpandedParameterPack()) {\n    // Warn about zero linear step (it would be probably better specified as\n    // making corresponding variables \'const\').\n    if (std::optional<llvm::APSInt> Result = StepExpr->getIntegerConstantExpr(Context)) {\n      if (!Result->isNegative() && !Result->isStrictlyPositive())\n        Diag(StepLoc, diag::warn_omp_linear_step_zero) << Vars[0] << (Vars.size() > 1);"}}

[j]={{nb,7068,"/// Build the expression to calculate the number of iterations.\nExpr *OpenMPIterationSpaceChecker::buildNumIterations(Scope *S, ArrayRef<LoopIterationSpace> ResultIterSpaces, bool LimitedType, llvm::MapVector<const Expr *, DeclRefExpr *> &Captures) const {\n  if (LimitedType) {\n    if (NewSize != C.getTypeSize(Type)) {\n      if (NewSize < C.getTypeSize(Type)) {\n        SemaRef.Diag(DefaultLoc, diag::warn_omp_loop_64_bit_var) << InitSrcRange << ConditionSrcRange;"}}

[j]={{nb,15799,"static bool actOnOMPReductionKindClause(Sema &S, DSAStackTy *Stack, OpenMPClauseKind ClauseKind, ArrayRef<Expr *> VarList, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation ColonLoc, SourceLocation EndLoc, CXXScopeSpec &ReductionIdScopeSpec, const DeclarationNameInfo &ReductionId, ArrayRef<Expr *> UnresolvedReductions, ReductionData &RD) {\n  // OpenMP 5.2, 5.5.5 (see page 627, line 18) reduction Clause, Restrictions\n  // A reduction clause with the minus (-) operator was deprecated\n  if (OOK == OO_Minus && S.LangOpts.OpenMP == 52)\n    S.Diag(ReductionId.getLoc(), diag::warn_omp_minus_in_reduction_deprecated);"}}

[j]={{M,1503,"void Parser::ParseOMPDeclareTargetClauses(Sema::DeclareTargetContextInfo &DTCI) {\n  while (Tok.isNot(tok::annot_pragma_openmp_end)) {\n    if (HasIdentifier) {\n      // Parse \'device_type\' clause and go to next clause if any.\n      if (IsDeviceTypeClause) {\n        if (DevTypeData) {\n          if (DeviceTypeLoc.isValid()) {\n            Diag(DevTypeData->Loc, diag::warn_omp_more_one_device_type_clause);"}}

[j]={{M,3021,"/// Parses a comma-separated list of interop-types and a prefer_type list.\n///\nbool Parser::ParseOMPInteropInfo(OMPInteropInfo &InteropInfo, OpenMPClauseKind Kind) {\n  while (Tok.is(tok::identifier)) {\n    if (Tok.getIdentifierInfo()->isStr(\"target\")) {\n      // OpenMP 5.1 [2.15.1, interop Construct, Restrictions]\n      // Each interop-type may be specified on an action-clause at most\n      // once.\n      if (IsTarget)\n        Diag(Tok, diag::warn_omp_more_one_interop_type) << \"target\";"},{M,3026,"/// Parses a comma-separated list of interop-types and a prefer_type list.\n///\nbool Parser::ParseOMPInteropInfo(OMPInteropInfo &InteropInfo, OpenMPClauseKind Kind) {\n  while (Tok.is(tok::identifier)) {\n    if (Tok.getIdentifierInfo()->isStr(\"target\")) {\n    } else if (Tok.getIdentifierInfo()->isStr(\"targetsync\")) {\n      if (IsTargetSync)\n        Diag(Tok, diag::warn_omp_more_one_interop_type) << \"targetsync\";"}}

[j]={{M,3685,"bool Parser::ParseOpenMPReservedLocator(OpenMPClauseKind Kind, Sema::OpenMPVarListDataTy &Data, const LangOptions &LangOpts) {\n  if (Tok.is(tok::identifier) && Tok.getIdentifierInfo()->isStr(\"omp_all_memory\")) {\n    if (Data.ExtraModifier == OMPC_DEPEND_outallmemory || Data.ExtraModifier == OMPC_DEPEND_inoutallmemory)\n      Diag(Tok, diag::warn_omp_more_one_omp_all_memory);"}}

[j]={{nb,3930,"static bool checkNestingOfRegions(Sema &SemaRef, const DSAStackTy *Stack, OpenMPDirectiveKind CurrentRegion, const DeclarationNameInfo &CurrentName, OpenMPDirectiveKind CancelRegion, OpenMPBindClauseKind BindKind, SourceLocation StartLoc) {\n  if (Stack->getCurScope()) {\n    if (isOpenMPSimdDirective(ParentRegion) && ((SemaRef.LangOpts.OpenMP <= 45 && CurrentRegion != OMPD_ordered) || (SemaRef.LangOpts.OpenMP >= 50 && CurrentRegion != OMPD_ordered && CurrentRegion != OMPD_simd && CurrentRegion != OMPD_atomic && CurrentRegion != OMPD_scan))) {\n      SemaRef.Diag(StartLoc, (CurrentRegion != OMPD_simd) ? diag::err_omp_prohibited_region_simd : diag::warn_omp_nesting_simd) << (SemaRef.LangOpts.OpenMP >= 50 ? 1 : 0);"}}

[j]={{nb,17149,"static bool checkTypeMappable(SourceLocation SL, SourceRange SR, Sema &SemaRef, DSAStackTy *Stack, QualType QTy, bool FullCheck = true) {\n  if (FullCheck && !SemaRef.CurContext->isDependentContext() && !QTy.isTriviallyCopyableType(SemaRef.Context))\n    SemaRef.Diag(SL, diag::warn_omp_non_trivial_type_mapped) << QTy << SR;"}}

[j]={{nb,18930,"static void checkDeclInTargetContext(SourceLocation SL, SourceRange SR, Sema &SemaRef, Decl *D) {\n  SemaRef.Diag(VD->getLocation(), diag::warn_omp_not_in_target_context);"}}

[j]={{z,4636,"ExprResult Sema::ActOnOMPArraySectionExpr(Expr *Base, SourceLocation LBLoc, Expr *LowerBound, SourceLocation ColonLocFirst, SourceLocation ColonLocSecond, Expr *Length, Expr *Stride, SourceLocation RBLoc) {\n  // C99 6.5.2.1p1\n  if (LowerBound) {\n    if (LowerBound->getType()->isSpecificBuiltinType(BuiltinType::Char_S) || LowerBound->getType()->isSpecificBuiltinType(BuiltinType::Char_U))\n      Diag(LowerBound->getExprLoc(), diag::warn_omp_section_is_char) << 0 << LowerBound->getSourceRange();"},{z,4645,"ExprResult Sema::ActOnOMPArraySectionExpr(Expr *Base, SourceLocation LBLoc, Expr *LowerBound, SourceLocation ColonLocFirst, SourceLocation ColonLocSecond, Expr *Length, Expr *Stride, SourceLocation RBLoc) {\n  if (Length) {\n    if (Length->getType()->isSpecificBuiltinType(BuiltinType::Char_S) || Length->getType()->isSpecificBuiltinType(BuiltinType::Char_U))\n      Diag(Length->getExprLoc(), diag::warn_omp_section_is_char) << 1 << Length->getSourceRange();"},{z,4654,"ExprResult Sema::ActOnOMPArraySectionExpr(Expr *Base, SourceLocation LBLoc, Expr *LowerBound, SourceLocation ColonLocFirst, SourceLocation ColonLocSecond, Expr *Length, Expr *Stride, SourceLocation RBLoc) {\n  if (Stride) {\n    if (Stride->getType()->isSpecificBuiltinType(BuiltinType::Char_S) || Stride->getType()->isSpecificBuiltinType(BuiltinType::Char_U))\n      Diag(Stride->getExprLoc(), diag::warn_omp_section_is_char) << 1 << Stride->getSourceRange();"}}

[j]={{M,1365,"/// `omp assumes` or `omp begin/end assumes` <clause> [[,]<clause>]...\n/// where\n///\n///  clause:\n///    \'ext_IMPL_DEFINED\'\n///    \'absent\' \'(\' directive-name [, directive-name]* \')\'\n///    \'contains\' \'(\' directive-name [, directive-name]* \')\'\n///    \'holds\' \'(\' scalar-expression \')\'\n///    \'no_openmp\'\n///    \'no_openmp_routines\'\n///    \'no_parallelism\'\n///\nvoid Parser::ParseOpenMPAssumesDirective(OpenMPDirectiveKind DKind, SourceLocation Loc) {\n  while (Tok.isNot(tok::annot_pragma_openmp_end)) {\n    // Handle unknown clauses by skipping them.\n    if (Idx == -1) {\n      Diag(StartLoc, diag::warn_omp_unknown_assumption_clause_missing_id) << llvm::omp::getOpenMPDirectiveName(DKind) << llvm::omp::getAllAssumeClauseOptions() << NextIsLPar;"}}

[j]={{M,1381,"/// `omp assumes` or `omp begin/end assumes` <clause> [[,]<clause>]...\n/// where\n///\n///  clause:\n///    \'ext_IMPL_DEFINED\'\n///    \'absent\' \'(\' directive-name [, directive-name]* \')\'\n///    \'contains\' \'(\' directive-name [, directive-name]* \')\'\n///    \'holds\' \'(\' scalar-expression \')\'\n///    \'no_openmp\'\n///    \'no_openmp_routines\'\n///    \'no_parallelism\'\n///\nvoid Parser::ParseOpenMPAssumesDirective(OpenMPDirectiveKind DKind, SourceLocation Loc) {\n  while (Tok.isNot(tok::annot_pragma_openmp_end)) {\n    if (NextIsLPar) {\n      Diag(Tok.getLocation(), diag::warn_omp_unknown_assumption_clause_without_args) << II;"}}

[j]={{nb,18837,"void Sema::DiagnoseUnterminatedOpenMPDeclareTarget() {\n  Diag(DTCI.Loc, diag::warn_omp_unterminated_declare_target) << getOpenMPDirectiveName(DTCI.Kind);"}}

[j]={{nb,2684,"static bool checkPreviousOMPAllocateAttribute(Sema &S, DSAStackTy *Stack, Expr *RefExpr, VarDecl *VD, OMPAllocateDeclAttr::AllocatorTypeTy AllocatorKind, Expr *Allocator) {\n  if (!AllocatorsMatch) {\n    S.Diag(AllocatorLoc, diag::warn_omp_used_different_allocator) << (Allocator ? 1 : 0) << AllocatorStream.str() << (PrevAllocator ? 1 : 0) << PrevAllocatorStream.str() << AllocatorRange;"}}

[j]={{N,1755,"void Sema::CheckImplementationIvars(ObjCImplementationDecl *ImpDecl, ObjCIvarDecl **ivars, unsigned numIvars, SourceLocation RBrace) {\n  if (LangOpts.ObjCRuntime.isNonFragile()) {\n    if (ImpDecl->getSuperClass())\n      Diag(ImpDecl->getLocation(), diag::warn_on_superclass_use);"}}

[j]={{B,7297,"static void handleOpenCLNoSVMAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n  if (S.LangOpts.getOpenCLCompatibleVersion() < 200)\n  else\n    S.Diag(AL.getLoc(), diag::warn_opencl_attr_deprecated_ignored) << AL << S.LangOpts.getOpenCLVersionString();"}}

[j]={{x,1632,"// OpenCL v2.0 s6.13.9 - Address space qualifier functions.\n// Performs semantic analysis for the to_global/local/private call.\n// \\param S Reference to the semantic analyzer.\n// \\param BuiltinID ID of the builtin function.\n// \\param Call A pointer to the builtin call.\n// \\return True if a semantic error has been found, false otherwise.\nstatic bool SemaOpenCLBuiltinToAddr(Sema &S, unsigned BuiltinID, CallExpr *Call) {\n  if (RT->getPointeeType().getAddressSpace() != LangAS::opencl_generic) {\n    S.Diag(Call->getArg(0)->getBeginLoc(), diag::warn_opencl_generic_address_space_arg) << Call->getDirectCallee()->getNameInfo().getAsString() << Call->getArg(0)->getSourceRange();"}}

[j]={{"clang/lib/Basic/Targets.cpp",796,"/// validateOpenCLTarget  - Check that OpenCL target has valid\n/// options setting based on OpenCL version.\nbool TargetInfo::validateOpenCLTarget(const LangOptions &Opts, DiagnosticsEngine &Diags) const {\n  auto diagnoseNotSupportedCore = [&](llvm::StringRef Name, auto... OptArgs) {\n    if (OpenCLOptions::isOpenCLOptionCoreIn(Opts, OptArgs...) && !hasFeatureEnabled(OpenCLFeaturesMap, Name))\n      Diags.Report(diag::warn_opencl_unsupported_core_feature) << Name << Opts.OpenCLCPlusPlus << Opts.getOpenCLVersionTuple().getAsString();"}}

[j]={{x,11585,"void Sema::CheckReturnValExpr(Expr *RetValExp, QualType lhsType, SourceLocation ReturnLoc, bool isObjCMethod, const AttrVec *Attrs, const FunctionDecl *FD) {\n  // C++11 [basic.stc.dynamic.allocation]p4:\n  //  If an allocation function declared with a non-throwing\n  //  exception-specification fails to allocate storage, it shall return\n  //  a null pointer. Any other allocation function that fails to allocate\n  //  storage shall indicate failure only by throwing an exception [...]\n  if (FD) {\n    if (Op == OO_New || Op == OO_Array_New) {\n      if (!Proto->isNothrow(/*ResultIfDependent*/ true) && CheckNonNullExpr(*this, RetValExp))\n        Diag(ReturnLoc, diag::warn_operator_new_returns_null) << FD << getLangOpts().CPlusPlus11;"}}

[j]={{"clang/lib/Frontend/CompilerInvocation.cpp",424,"static bool FixupInvocation(CompilerInvocation &Invocation, DiagnosticsEngine &Diags, const ArgList &Args, InputKind IK) {\n  // -cl-strict-aliasing needs to emit diagnostic in the case where CL > 1.0.\n  // This option should be deprecated for CL > 1.0 because\n  // this option was added for compatibility with OpenCL 1.0.\n  if (Args.getLastArg(OPT_cl_strict_aliasing) && (LangOpts.getOpenCLCompatibleVersion() > 100))\n    Diags.Report(diag::warn_option_invalid_ocl_version) << LangOpts.getOpenCLVersionString() << Args.getLastArg(OPT_cl_strict_aliasing)->getAsString(Args);"}}

[j]={{x,9802,"bool CheckPrintfHandler::HandlePrintfSpecifier(const analyze_printf::PrintfSpecifier &FS, const char *startSpecifier, unsigned specifierLen, const TargetInfo &Target) {\n  // %n is not allowed with os_log.\n  if (FSType == Sema::FST_OSLog && CS.getKind() == ConversionSpecifier::nArg) {\n    EmitFormatDiagnostic(S.PDiag(diag::warn_os_log_format_narg), getLocationOfByte(CS.getStart()),"}}

[j]={{x,12303,"static int classifyConstantValue(Expr *Constant) {\n  // diag::warn_out_of_range_compare and diag::warn_tautological_bool_compare."},{x,12419,"static bool CheckTautologicalComparison(Sema &S, BinaryOperator *E, Expr *Constant, Expr *Other, const llvm::APSInt &Value, bool RhsConstant) {\n  // FIXME: We use a somewhat different formatting for the in-range cases and\n  // cases involving boolean values for historical reasons. We should pick a\n  // consistent way of presenting these diagnostics.\n  if (!InRange || Other->isKnownToHaveBooleanValue()) {\n    S.DiagRuntimeBehavior(E->getOperatorLoc(), E, S.PDiag(!InRange ? diag::warn_out_of_range_compare : diag::warn_tautological_bool_compare) << OS.str() << classifyConstantValue(Constant) << OtherT << OtherIsBooleanDespiteType << *Result << E->getLHS()->getSourceRange() << E->getRHS()->getSourceRange());"}}

[j]={{Lb,2001,"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 (OperatorNew) {\n    // Warn if the type is over-aligned and is being allocated by (unaligned)\n    // global operator new.\n    if (PlacementArgs.empty() && !PassAlignment && (OperatorNew->isImplicit() || (OperatorNew->getBeginLoc().isValid() && getSourceManager().isInSystemHeader(OperatorNew->getBeginLoc())))) {\n      if (Alignment > NewAlignment)\n        Diag(StartLoc, diag::warn_overaligned_type) << AllocType << unsigned(Alignment / Context.getCharWidth()) << unsigned(NewAlignment / Context.getCharWidth());"}}

[j]={{z,13766,"static void DiagnoseShiftCompare(Sema &S, SourceLocation OpLoc, Expr *LHSExpr, Expr *RHSExpr) {\n  S.Diag(OpLoc, diag::warn_overloaded_shift_in_comparison) << LHSExpr->getSourceRange() << RHSExpr->getSourceRange() << (Kind == OO_LessLess);"}}

[j]={{Y,8798,"/// Diagnose methods which overload virtual methods in a base class\n/// without overriding any.\nvoid Sema::DiagnoseHiddenVirtualMethods(CXXMethodDecl *MD) {\n  if (Diags.isIgnored(diag::warn_overloaded_virtual, MD->getLocation()))"},{Y,8804,"/// Diagnose methods which overload virtual methods in a base class\n/// without overriding any.\nvoid Sema::DiagnoseHiddenVirtualMethods(CXXMethodDecl *MD) {\n  if (!OverloadedMethods.empty()) {\n    Diag(MD->getLocation(), diag::warn_overloaded_virtual) << MD << (OverloadedMethods.size() > 1);"}}

[j]={{Y,15369,"bool Sema::CheckOverridingFunctionAttributes(const CXXMethodDecl *New, const CXXMethodDecl *Old) {\n  if (OldFT->hasExtParameterInfos()) {\n    for (unsigned I = 0, E = OldFT->getNumParams(); I != E; ++I)\n      // A parameter of the overriding method should be annotated with noescape\n      // if the corresponding parameter of the overridden method is annotated.\n      if (OldFT->getExtParameterInfo(I).isNoEscape() && !NewFT->getExtParameterInfo(I).isNoEscape()) {\n        Diag(New->getParamDecl(I)->getLocation(), diag::warn_overriding_method_missing_noescape);"},{N,112,"/// Issue a warning if the parameter of the overridden method is non-escaping\n/// but the parameter of the overriding method is not.\nstatic bool diagnoseNoescape(const ParmVarDecl *NewD, const ParmVarDecl *OldD, Sema &S) {\n  if (OldD->hasAttr<NoEscapeAttr>() && !NewD->hasAttr<NoEscapeAttr>()) {\n    S.Diag(NewD->getLocation(), diag::warn_overriding_method_missing_noescape);"}}

[j]={{ac,2087,"void ItaniumRecordLayoutBuilder::CheckFieldPadding(uint64_t Offset, uint64_t UnpaddedOffset, uint64_t UnpackedOffset, unsigned UnpackedAlign, bool isPacked, const FieldDecl *D) {\n  // Warn if padding was introduced to the struct/class.\n  if (!IsUnion && Offset > UnpaddedOffset) {\n    if (D->getIdentifier())\n    else\n      Diag(D->getLocation(), diag::warn_padded_struct_anon_field) << getPaddingDiagFromTagKind(D->getParent()->getTagKind()) << Context.getTypeDeclType(D->getParent()) << PadSize << (InBits ? 1 : 0); // (byte|bit)"}}

[j]={{ac,2084,"void ItaniumRecordLayoutBuilder::CheckFieldPadding(uint64_t Offset, uint64_t UnpaddedOffset, uint64_t UnpackedOffset, unsigned UnpackedAlign, bool isPacked, const FieldDecl *D) {\n  // Warn if padding was introduced to the struct/class.\n  if (!IsUnion && Offset > UnpaddedOffset) {\n    if (D->getIdentifier())\n      Diag(D->getLocation(), diag::warn_padded_struct_field) << getPaddingDiagFromTagKind(D->getParent()->getTagKind()) << Context.getTypeDeclType(D->getParent()) << PadSize << (InBits ? 1 : 0) // (byte|bit)"}}

[j]={{ac,1991,"void ItaniumRecordLayoutBuilder::FinishLayout(const NamedDecl *D) {\n  if (const RecordDecl *RD = dyn_cast<RecordDecl>(D)) {\n    // Warn if padding was introduced to the struct/class/union.\n    if (getSizeInBits() > UnpaddedSize) {\n      Diag(RD->getLocation(), diag::warn_padded_struct_size) << Context.getTypeDeclType(RD) << PadSize << (InBits ? 1 : 0); // (byte|bit)"}}

[j]={{x,6317,"/// Warn if a pointer or reference argument passed to a function points to an\n/// object that is less aligned than the parameter. This can happen when\n/// creating a typedef with a lower alignment than the original type and then\n/// calling functions defined in terms of the original type.\nvoid Sema::CheckArgAlignment(SourceLocation Loc, NamedDecl *FDecl, StringRef ParamName, QualType ArgTy, QualType ParamTy) {\n  // If the argument is less aligned than the parameter, there is a\n  // potential alignment issue.\n  if (ArgAlign < ParamAlign)\n    Diag(Loc, diag::warn_param_mismatched_alignment) << (int)ArgAlign.getQuantity() << (int)ParamAlign.getQuantity() << ParamName << (FDecl != nullptr) << FDecl;"}}

[j]={{D,1798,"class ConsumedWarningsHandler : public ConsumedWarningsHandlerBase {\n  void warnParamReturnTypestateMismatch(SourceLocation Loc, StringRef VariableName, StringRef ExpectedState, StringRef ObservedState) override {\n    PartialDiagnosticAt Warning(Loc, S.PDiag(diag::warn_param_return_typestate_mismatch) << VariableName << ExpectedState << ObservedState);"}}

[j]={{D,1805,"class ConsumedWarningsHandler : public ConsumedWarningsHandlerBase {\n  void warnParamTypestateMismatch(SourceLocation Loc, StringRef ExpectedState, StringRef ObservedState) override {\n    PartialDiagnosticAt Warning(Loc, S.PDiag(diag::warn_param_typestate_mismatch) << ExpectedState << ObservedState);"}}

[j]={{G,12994,"void Sema::DiagnoseSizeOfParametersAndReturnValue(ArrayRef<ParmVarDecl *> Parameters, QualType ReturnTy, NamedDecl *D) {\n  // Warn if any parameter is pass-by-value and larger than the specified\n  // threshold.\n  for (const ParmVarDecl *Parameter : Parameters) {\n    if (Size > LangOpts.NumLargeByValueCopy)\n      Diag(Parameter->getLocation(), diag::warn_parameter_size) << Parameter << Size;"}}

[j]={{Q,3387,"/// Produce an appropriate diagnostic for an ambiguity between a function\n/// declarator and a C++ direct-initializer.\nstatic void warnAboutAmbiguousFunction(Sema &S, Declarator &D, DeclaratorChunk &DeclType, QualType RT) {\n  S.Diag(DeclType.Loc, FTI.NumParams ? diag::warn_parens_disambiguated_as_function_declaration : diag::warn_empty_parens_are_function_decl) << ParenRange;"}}

[j]={{Q,3527,"/// Produce an appropriate diagnostic for a declarator with top-level\n/// parentheses.\nstatic void warnAboutRedundantParens(Sema &S, Declarator &D, QualType T) {\n  S.Diag(Paren.Loc, diag::warn_parens_disambiguated_as_variable_declaration) << ParenRange << D.getIdentifier();"}}

[j]={{z,886,"void Sema::checkVariadicArgument(const Expr *E, VariadicCallType CT) {\n  case VAK_Valid:\n    if (Ty->isRecordType()) {\n      DiagRuntimeBehavior(E->getBeginLoc(), nullptr, PDiag(diag::warn_pass_class_arg_to_vararg) << Ty << CT << hasCStrMethod(E) << \".c_str()\");"}}

[j]={{vb,7163,"/// Provide warnings when std::move is used on construction.\nstatic void CheckMoveOnConstruction(Sema &S, const Expr *InitExpr, bool IsReturnStmt) {\n  if (IsReturnStmt) {\n  } else {\n    DiagID = diag::warn_pessimizing_move_on_initialization;"}}

[j]={{vb,7161,"/// Provide warnings when std::move is used on construction.\nstatic void CheckMoveOnConstruction(Sema &S, const Expr *InitExpr, bool IsReturnStmt) {\n  if (IsReturnStmt) {\n    // If we\'re returning a function parameter, copy elision\n    // is not possible.\n    if (isa<ParmVarDecl>(VD))\n    else\n      DiagID = diag::warn_pessimizing_move_on_return;"}}

[j]={{x,10801,"// Warn when using the wrong abs() function.\nvoid Sema::CheckAbsoluteValueFunction(const CallExpr *Call, const FunctionDecl *FDecl) {\n  // Taking the absolute value of a pointer is very suspicious, they probably\n  // wanted to index into an array, dereference a pointer, call a function, etc.\n  if (ArgType->isPointerType() || ArgType->canDecayToPointerType()) {\n    Diag(Call->getExprLoc(), diag::warn_pointer_abs) << DiagType << ArgType;"}}

[j]={{z,9884,"/// Diagnose invalid arithmetic on a null pointer.\n///\n/// If \\p IsGNUIdiom is true, the operation is using the \'p = (i8*)nullptr + n\'\n/// idiom, which we recognize as a GNU extension.\n///\nstatic void diagnoseArithmeticOnNullPointer(Sema &S, SourceLocation Loc, Expr *Pointer, bool IsGNUIdiom) {\n  if (IsGNUIdiom)\n  else\n    S.Diag(Loc, diag::warn_pointer_arith_null_ptr) << S.getLangOpts().CPlusPlus << Pointer->getSourceRange();"}}

[j]={{z,11140,"void Sema::CheckPtrComparisonWithNullChar(ExprResult &E, ExprResult &NullE) {\n  if (!E.get()->getType()->isAnyPointerType() && E.get()->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNotNull) == Expr::NPCK_ZeroExpression) {\n    if (const auto *CL = dyn_cast<CharacterLiteral>(E.get())) {\n      if (CL->getValue() == 0)\n        Diag(E.get()->getExprLoc(), diag::warn_pointer_compare) << NullValue << FixItHint::CreateReplacement(E.get()->getExprLoc(), NullValue ? \"NULL\" : \"(void *)0\");"},{z,11145,"void Sema::CheckPtrComparisonWithNullChar(ExprResult &E, ExprResult &NullE) {\n  if (!E.get()->getType()->isAnyPointerType() && E.get()->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNotNull) == Expr::NPCK_ZeroExpression) {\n    if (const auto *CL = dyn_cast<CharacterLiteral>(E.get())) {\n    } else if (const auto *CE = dyn_cast<CStyleCastExpr>(E.get())) {\n      if (T == Context.CharTy)\n        Diag(E.get()->getExprLoc(), diag::warn_pointer_compare) << NullValue << FixItHint::CreateReplacement(E.get()->getExprLoc(), NullValue ? \"NULL\" : \"(void *)0\");"}}

[j]={{Db,1747,"// Checks for undefined behavior in reinterpret_cast.\n// The cases that is checked for is:\n// *reinterpret_cast<T*>(&a)\n// reinterpret_cast<T&>(a)\n// where accessing \'a\' as type \'T\' will result in undefined behavior.\nvoid Sema::CheckCompatibleReinterpretCast(QualType SrcType, QualType DestType, bool IsDereference, SourceRange Range) {\n  unsigned DiagID = IsDereference ? diag::warn_pointer_indirection_from_incompatible_type : diag::warn_undefined_reinterpret_cast;"}}

[j]={{z,9898,"/// Diagnose invalid subraction on a null pointer.\n///\nstatic void diagnoseSubtractionOnNullPointer(Sema &S, SourceLocation Loc, Expr *Pointer, bool BothNull) {\n  S.DiagRuntimeBehavior(Loc, Pointer, S.PDiag(diag::warn_pointer_sub_null_ptr) << S.getLangOpts().CPlusPlus << Pointer->getSourceRange());"}}

[j]={{Db,2736,"/// Check the semantics of a C-style cast operation, in C.\nvoid CastOperation::CheckCStyleCast() {\n  // If either type is a pointer, the other type has to be either an\n  // integer or a pointer.\n  if (!DestType->isArithmeticType()) {\n  } else if (!SrcType->isArithmeticType()) {\n    if ((Self.Context.getTypeSize(SrcType) > Self.Context.getTypeSize(DestType)) && !DestType->isBooleanType()) {\n      if (SrcType->isVoidPointerType())\n      else if (DestType->isEnumeralType())\n        Diag = diag::warn_pointer_to_enum_cast;"}}

[j]={{Db,2131,"static TryCastResult TryReinterpretCast(Sema &Self, ExprResult &SrcExpr, QualType DestType, bool CStyle, SourceRange OpRange, unsigned &msg, CastKind &Kind) {\n  if (DestType->isIntegralType(Self.Context)) {\n    // C++ 5.2.10p4: A pointer can be explicitly converted to any integral\n    //  type large enough to hold it; except in Microsoft mode, where the\n    //  integral type size doesn\'t matter (except we don\'t allow bool).\n    if ((Self.Context.getTypeSize(SrcType) > Self.Context.getTypeSize(DestType))) {\n      if (MicrosoftException) {\n        unsigned Diag = SrcType->isVoidPointerType() ? diag::warn_void_pointer_to_int_cast : diag::warn_pointer_to_int_cast;"},{Db,2738,"/// Check the semantics of a C-style cast operation, in C.\nvoid CastOperation::CheckCStyleCast() {\n  // If either type is a pointer, the other type has to be either an\n  // integer or a pointer.\n  if (!DestType->isArithmeticType()) {\n  } else if (!SrcType->isArithmeticType()) {\n    if ((Self.Context.getTypeSize(SrcType) > Self.Context.getTypeSize(DestType)) && !DestType->isBooleanType()) {\n      if (SrcType->isVoidPointerType())\n      else if (DestType->isEnumeralType())\n      else\n        Diag = diag::warn_pointer_to_int_cast;"}}

[j]={{"clang/lib/Lex/InitHeaderSearch.cpp",128,"bool InitHeaderSearch::AddUnmappedPath(const Twine &Path, IncludeDirGroup Group, bool isFramework, std::optional<unsigned> UserEntryIdx) {\n  // If use system headers while cross-compiling, emit the warning.\n  if (HasSysroot && (MappedPathStr.startswith(\"/usr/include\") || MappedPathStr.startswith(\"/usr/local/include\"))) {\n    Headers.getDiags().Report(diag::warn_poison_system_directories) << MappedPathStr;"}}

[j]={{Z,1074,"ExprResult Sema::ParseObjCSelectorExpression(Selector Sel, SourceLocation AtLoc, SourceLocation SelLoc, SourceLocation LParenLoc, SourceLocation RParenLoc, bool WarnMultipleSelectors) {\n  if (!Method) {\n  } else {\n    if (onlyDirect) {\n    } else if (anyDirect) {\n      if (LikelyTargetMethod && LikelyTargetMethod->isDirectMethod()) {\n        Diag(AtLoc, diag::warn_potentially_direct_selector_expression) << Sel;"}}

[j]={{"clang/lib/Lex/PPMacroExpansion.cpp",533,"/// HandleMacroExpandedIdentifier - If an identifier token is read that is to be\n/// expanded as a macro, handle it and return the next token as \'Identifier\'.\nbool Preprocessor::HandleMacroExpandedIdentifier(Token &Identifier, const MacroDefinition &M) {\n  // If the macro definition is ambiguous, complain.\n  if (M.isAmbiguous()) {\n    Diag(Identifier, diag::warn_pp_ambiguous_macro) << Identifier.getIdentifierInfo();"}}

[j]={{dc,672,"/// EvaluateDirectiveSubExpr - Evaluate the subexpression whose first token is\n/// PeekTok, and whose precedence is PeekPrec.  This returns the result in LHS.\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, such as division by zero warnings.\nstatic bool EvaluateDirectiveSubExpr(PPValue &LHS, unsigned MinPrec, Token &PeekTok, bool ValueLive, bool &IncludedUndefinedIds, Preprocessor &PP) {\n  while (true) {\n    default:\n      // If this just promoted something from signed to unsigned, and if the\n      // value was negative, warn about it.\n      if (ValueLive && Res.isUnsigned()) {\n        if (!LHS.isUnsigned() && LHS.Val.isNegative())\n          PP.Diag(OpLoc, diag::warn_pp_convert_to_positive) << 0 << toString(LHS.Val, 10, true) + \" to \" + toString(LHS.Val, 10, false) << LHS.getRange() << RHS.getRange();"},{dc,674,"/// EvaluateDirectiveSubExpr - Evaluate the subexpression whose first token is\n/// PeekTok, and whose precedence is PeekPrec.  This returns the result in LHS.\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, such as division by zero warnings.\nstatic bool EvaluateDirectiveSubExpr(PPValue &LHS, unsigned MinPrec, Token &PeekTok, bool ValueLive, bool &IncludedUndefinedIds, Preprocessor &PP) {\n  while (true) {\n    default:\n      // If this just promoted something from signed to unsigned, and if the\n      // value was negative, warn about it.\n      if (ValueLive && Res.isUnsigned()) {\n        if (!RHS.isUnsigned() && RHS.Val.isNegative())\n          PP.Diag(OpLoc, diag::warn_pp_convert_to_positive) << 1 << toString(RHS.Val, 10, true) + \" to \" + toString(RHS.Val, 10, false) << LHS.getRange() << RHS.getRange();"}}

[j]={{"clang/lib/Lex/PPMacroExpansion.cpp",1468,"/// ExpandBuiltinMacro - If an identifier token is read that is to be expanded\n/// as a builtin macro, handle it and return the next token as \'Tok\'.\nvoid Preprocessor::ExpandBuiltinMacro(Token &Tok) {\n  if (II == Ident__LINE__) {\n  } else if (II == Ident__FILE__ || II == Ident__BASE_FILE__ || II == Ident__FILE_NAME__) {\n  } else if (II == Ident__DATE__) {\n    Diag(Tok.getLocation(), diag::warn_pp_date_time);"},{"clang/lib/Lex/PPMacroExpansion.cpp",1476,"/// ExpandBuiltinMacro - If an identifier token is read that is to be expanded\n/// as a builtin macro, handle it and return the next token as \'Tok\'.\nvoid Preprocessor::ExpandBuiltinMacro(Token &Tok) {\n  if (II == Ident__LINE__) {\n  } else if (II == Ident__FILE__ || II == Ident__BASE_FILE__ || II == Ident__FILE_NAME__) {\n  } else if (II == Ident__DATE__) {\n  } else if (II == Ident__TIME__) {\n    Diag(Tok.getLocation(), diag::warn_pp_date_time);"},{"clang/lib/Lex/PPMacroExpansion.cpp",1499,"/// ExpandBuiltinMacro - If an identifier token is read that is to be expanded\n/// as a builtin macro, handle it and return the next token as \'Tok\'.\nvoid Preprocessor::ExpandBuiltinMacro(Token &Tok) {\n  if (II == Ident__LINE__) {\n  } else if (II == Ident__FILE__ || II == Ident__BASE_FILE__ || II == Ident__FILE_NAME__) {\n  } else if (II == Ident__DATE__) {\n  } else if (II == Ident__TIME__) {\n  } else if (II == Ident__INCLUDE_LEVEL__) {\n  } else if (II == Ident__TIMESTAMP__) {\n    Diag(Tok.getLocation(), diag::warn_pp_date_time);"}}

[j]={{dc,465,"/// 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::minus: {\n    // If this operator is live and overflowed, report the issue.\n    if (Overflow && ValueLive)\n      PP.Diag(Loc, diag::warn_pp_expr_overflow) << Result.getRange();"},{dc,830,"/// EvaluateDirectiveSubExpr - Evaluate the subexpression whose first token is\n/// PeekTok, and whose precedence is PeekPrec.  This returns the result in LHS.\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, such as division by zero warnings.\nstatic bool EvaluateDirectiveSubExpr(PPValue &LHS, unsigned MinPrec, Token &PeekTok, bool ValueLive, bool &IncludedUndefinedIds, Preprocessor &PP) {\n  while (true) {\n    // If this operator is live and overflowed, report the issue.\n    if (Overflow && ValueLive)\n      PP.Diag(OpLoc, diag::warn_pp_expr_overflow) << LHS.getRange() << RHS.getRange();"}}

[j]={{H,839,"void Preprocessor::HandlePragmaHdrstop(Token &Tok) {\n  if (Tok.is(tok::l_paren)) {\n    Diag(Tok.getLocation(), diag::warn_pp_hdrstop_filename_ignored);"}}