Module:ClangDiags/DiagsLongData0: Difference between revisions

[k]={{zb,1244,"/// getCharAndSizeSlow - Peek a single \'character\' from the specified buffer,\n/// get its size, and return it.  This is tricky in several cases:\n///  1. If currently at the start of a trigraph, we warn about the trigraph,\n///      then either return the trigraph (skipping 3 chars) or the \'?\',\n///      depending on whether trigraphs are enabled or not.\n///  2. If this is an escaped newline (potentially with whitespace between\n///      the backslash and newline), implicitly skip the newline and return\n///      the char after it.\n///\n/// This handles the slow/uncommon case of the getCharAndSize method.  Here we\n/// know that we can accumulate into Size, and that we have already incremented\n/// Ptr by Size bytes.\n///\n/// NOTE: When this method is updated, getCharAndSizeSlowNoWarn (below) should\n/// be updated to match.\nchar Lexer::getCharAndSizeSlow(const char *Ptr, unsigned &Size, Token *Tok) {\n  Slash:\n    // See if we have optional whitespace characters between the slash and\n    // newline.\n    if (unsigned EscapedNewLineSize = getEscapedNewLineSize(Ptr)) {\n      // Warn if there was whitespace between the backslash and newline.\n      if (Ptr[0] != \'\\n\' && Ptr[0] != \'\\r\' && Tok && !isLexingRawMode())\n        Diag(Ptr, diag::backslash_newline_space);"},{zb,2291,"/// We have just read the // characters from input.  Skip until we find the\n/// newline character that terminates the comment.  Then update BufferPtr and\n/// return.\n///\n/// If we\'re in KeepCommentMode or any CommentHandler has inserted\n/// some tokens, this will store the first token and return true.\nbool Lexer::SkipLineComment(Token &Result, const char *CurPtr, bool &TokAtPhysicalStartOfLine) {\n  while (true) {\n    if (C != 0) {\n      // If there was space between the backslash and newline, warn about it.\n      if (HasSpace && !isLexingRawMode())\n        Diag(EscapePtr, diag::backslash_newline_space);"},{zb,2474,"/// isBlockCommentEndOfEscapedNewLine - Return true if the specified newline\n/// character (either \\\\n or \\\\r) is part of an escaped newline sequence.  Issue\n/// a diagnostic if so.  We know that the newline is inside of a block comment.\nstatic bool isEndOfBlockCommentWithEscapedNewLine(const char *CurPtr, Lexer *L, bool Trigraphs) {\n  // If there was space between the backslash and newline, warn about it.\n  if (SpacePos && !L->isLexingRawMode())\n    L->Diag(SpacePos, diag::backslash_newline_space);"}}

[k]={{s,5653,"bool Sema::CheckX86BuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID, CallExpr *TheCall) {\n  if (TT.getArch() != llvm::Triple::x86 && isX86_32Builtin(BuiltinID))\n    return Diag(TheCall->getCallee()->getBeginLoc(), diag::err_32_bit_builtin_64_bit_tgt);"}}

[k]={{s,3968,"bool Sema::CheckPPCBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID, CallExpr *TheCall) {\n  if (isPPC_64Builtin(BuiltinID) && !IsTarget64Bit)\n    return Diag(TheCall->getBeginLoc(), diag::err_64_bit_builtin_32_bit_tgt) << TheCall->getSourceRange();"}}

[k]={{Ib,209,"/// Handle_Pragma - Read a _Pragma directive, slice it up, process it, then\n/// return the first token after the directive.  The _Pragma token has just\n/// been read into \'Tok\'.\nvoid Preprocessor::Handle_Pragma(Token &Tok) {\n  if (Tok.isNot(tok::l_paren)) {\n    Diag(PragmaLoc, diag::err__Pragma_malformed);"},{Ib,216,"/// Handle_Pragma - Read a _Pragma directive, slice it up, process it, then\n/// return the first token after the directive.  The _Pragma token has just\n/// been read into \'Tok\'.\nvoid Preprocessor::Handle_Pragma(Token &Tok) {\n  if (!tok::isStringLiteral(Tok.getKind())) {\n    Diag(PragmaLoc, diag::err__Pragma_malformed);"},{Ib,242,"/// Handle_Pragma - Read a _Pragma directive, slice it up, process it, then\n/// return the first token after the directive.  The _Pragma token has just\n/// been read into \'Tok\'.\nvoid Preprocessor::Handle_Pragma(Token &Tok) {\n  if (Tok.isNot(tok::r_paren)) {\n    Diag(PragmaLoc, diag::err__Pragma_malformed);"},{Ib,258,"/// Handle_Pragma - Read a _Pragma directive, slice it up, process it, then\n/// return the first token after the directive.  The _Pragma token has just\n/// been read into \'Tok\'.\nvoid Preprocessor::Handle_Pragma(Token &Tok) {\n  if (Invalid) {\n    Diag(PragmaLoc, diag::err__Pragma_malformed);"},{Ib,352,"/// HandleMicrosoft__pragma - Like Handle_Pragma except the pragma text\n/// is not enclosed within a string literal.\nvoid Preprocessor::HandleMicrosoft__pragma(Token &Tok) {\n  if (Tok.isNot(tok::l_paren)) {\n    Diag(PragmaLoc, diag::err__Pragma_malformed);"}}

[k]={{q,2943,"/// mergeDeclAttributes - Copy attributes from the Old decl to the New one.\nvoid Sema::mergeDeclAttributes(NamedDecl *New, Decl *Old, AvailabilityMergeKind AMK) {\n  // Re-declaration cannot add abi_tag\'s.\n  if (const auto *NewAbiTagAttr = New->getAttr<AbiTagAttr>()) {\n    if (const auto *OldAbiTagAttr = Old->getAttr<AbiTagAttr>()) {\n    } else {\n      Diag(NewAbiTagAttr->getLocation(), diag::err_abi_tag_on_redeclaration);"}}

[k]={{s,14868,"/// CheckParmsForFunctionDef - Check that the parameters of the given\n/// function are appropriate for the definition of a function. This\n/// takes care of any checks that cannot be performed on the\n/// declaration itself, e.g., that the types of each of the function\n/// parameters are complete.\nbool Sema::CheckParmsForFunctionDef(ArrayRef<ParmVarDecl *> Parameters, bool CheckParameterNames) {\n  for (ParmVarDecl *Param : Parameters) {\n    if (!Param->isInvalidDecl() && (RequireCompleteType(Param->getLocation(), Param->getType(), diag::err_typecheck_decl_incomplete_type) || RequireNonAbstractType(Param->getBeginLoc(), Param->getOriginalType(), diag::err_abstract_type_in_decl, AbstractParamType))) {"},{q,11533,"/// AddInitializerToDecl - Adds the initializer Init to the\n/// declaration dcl. If DirectInit is true, this is C++ direct\n/// initialization rather than copy initialization.\nvoid Sema::AddInitializerToDecl(Decl *RealDecl, Expr *Init, bool DirectInit) {\n  if (!VDecl->getType()->isDependentType()) {\n    if (RequireNonAbstractType(VDecl->getLocation(), VDecl->getType(), diag::err_abstract_type_in_decl, AbstractVariableType))"},{q,11915,"/// ActOnInitializerError - Given that there was an error parsing an\n/// initializer for the given declaration, try to at least re-establish\n/// invariants such as whether a variable\'s type is either dependent or\n/// complete.\nvoid Sema::ActOnInitializerError(Decl *D) {\n  if (RequireNonAbstractType(VD->getLocation(), Ty, diag::err_abstract_type_in_decl, AbstractVariableType)) {"},{q,12028,"void Sema::ActOnUninitializedDecl(Decl *RealDecl) {\n  if (VarDecl *Var = dyn_cast<VarDecl>(RealDecl)) {\n    case VarDecl::DeclarationOnly:\n      if (!Type->isDependentType() && !Var->isInvalidDecl() && RequireNonAbstractType(Var->getLocation(), Type, diag::err_abstract_type_in_decl, AbstractVariableType))"},{q,12107,"void Sema::ActOnUninitializedDecl(Decl *RealDecl) {\n  if (VarDecl *Var = dyn_cast<VarDecl>(RealDecl)) {\n    if (RequireNonAbstractType(Var->getLocation(), Type, diag::err_abstract_type_in_decl, AbstractVariableType)) {"},{q,13395,"Decl *Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope, Decl *D, SkipBodyInfo *SkipBody, FnBodyKind BodyKind) {\n  if (!ResultType->isDependentType() && !ResultType->isVoidType() && !FD->isInvalidDecl() && BodyKind != FnBodyKind::Delete && (RequireCompleteType(FD->getLocation(), ResultType, diag::err_func_def_incomplete_result) || RequireNonAbstractType(FD->getLocation(), FD->getReturnType(), diag::err_abstract_type_in_decl, AbstractReturnType)))"},{q,15892,"/// Build a new FieldDecl and check its well-formedness.\n///\n/// This routine builds a new FieldDecl given the fields name, type,\n/// record, etc. \\p PrevDecl should refer to any previous declaration\n/// with the same name and in the same scope as the field to be\n/// created.\n///\n/// \\returns a new FieldDecl.\n///\n/// \\todo The Declarator argument is a hack. It will be removed once\nFieldDecl *Sema::CheckFieldDecl(DeclarationName Name, QualType T, TypeSourceInfo *TInfo, RecordDecl *Record, SourceLocation Loc, bool Mutable, Expr *BitWidth, InClassInitStyle InitStyle, SourceLocation TSSL, AccessSpecifier AS, NamedDecl *PrevDecl, Declarator *D) {\n  if (!InvalidDecl && RequireNonAbstractType(Loc, T, diag::err_abstract_type_in_decl, AbstractFieldType))"},{q,16531,"void Sema::ActOnFields(Scope *S, SourceLocation RecLoc, Decl *EnclosingDecl, ArrayRef<Decl *> Fields, SourceLocation LBrac, SourceLocation RBrac, const ParsedAttributesView &Attrs) {\n  for (ArrayRef<Decl *>::iterator i = Fields.begin(), end = Fields.end(); i != end; ++i) {\n    if (FDTy->isFunctionType()) {\n    } else if (FDTy->isIncompleteArrayType() && (Record || isa<ObjCContainerDecl>(EnclosingDecl))) {\n    } else if (!FDTy->isDependentType() && RequireCompleteSizedType(FD->getLocation(), FD->getType(), diag::err_field_incomplete_or_sizeless)) {\n    } else if (const RecordType *FDTTy = FDTy->getAs<RecordType>()) {\n      if (isa<ObjCContainerDecl>(EnclosingDecl) && RequireNonAbstractType(FD->getLocation(), FD->getType(), diag::err_abstract_type_in_decl, AbstractIvarType)) {"},{v,5185,"#include \"clang/AST/TypeLocNodes.def\"\n  CheckPolymorphic(PointerTypeLoc) CheckPolymorphic(ReferenceTypeLoc) CheckPolymorphic(MemberPointerTypeLoc) CheckPolymorphic(BlockPointerTypeLoc) CheckPolymorphic(AtomicTypeLoc)\n    // It matched; do some magic.\n    // FIXME: These should be at most warnings. See P0929R2, CWG1640, CWG1646.\n    if (Sel == Sema::AbstractArrayType) {\n    } else {\n      Info.S.Diag(Ctx->getLocation(), diag::err_abstract_type_in_decl) << Sel << T << TL.getSourceRange();"},{v,14202,"/// 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  if (!Invalid && !ExDeclType->isDependentType() && RequireNonAbstractType(Loc, ExDeclType, diag::err_abstract_type_in_decl, AbstractVariableType))"},{P,1086,"/// ActOnPropertyImplDecl - This routine performs semantic checks and\n/// builds the AST node for a property implementation declaration; declared\n/// as \\@synthesize or \\@dynamic.\n///\nDecl *Sema::ActOnPropertyImplDecl(Scope *S, SourceLocation AtLoc, SourceLocation PropertyLoc, bool Synthesize, IdentifierInfo *PropertyId, IdentifierInfo *PropertyIvar, SourceLocation PropertyIvarLoc, ObjCPropertyQueryKind QueryKind) {\n  // Check that we have a valid, previously declared ivar for @synthesize\n  if (Synthesize) {\n    if (!Ivar) {\n      if (RequireNonAbstractType(PropertyIvarLoc, PropertyIvarType, diag::err_abstract_type_in_decl, AbstractSynthesizedIvarType)) {"}}

[k]={{S,1435,"Sema::AccessResult Sema::CheckUnresolvedLookupAccess(UnresolvedLookupExpr *E, DeclAccessPair Found) {\n  Entity.setDiag(diag::err_access) << E->getSourceRange();"},{S,1451,"/// Perform access-control checking on a previously-unresolved member\n/// access which has now been resolved to a member.\nSema::AccessResult Sema::CheckUnresolvedMemberAccess(UnresolvedMemberExpr *E, DeclAccessPair Found) {\n  Entity.setDiag(diag::err_access) << E->getSourceRange();"},{S,1574,"/// Checks access to an overloaded operator new or delete.\nSema::AccessResult Sema::CheckAllocationAccess(SourceLocation OpLoc, SourceRange PlacementRange, CXXRecordDecl *NamingClass, DeclAccessPair Found, bool Diagnose) {\n  if (Diagnose)\n    Entity.setDiag(diag::err_access) << PlacementRange;"},{S,1608,"Sema::AccessResult Sema::CheckMemberOperatorAccess(SourceLocation OpLoc, Expr *ObjectExpr, const SourceRange &Range, DeclAccessPair Found) {\n  Entity.setDiag(diag::err_access) << ObjectExpr->getSourceRange() << Range;"},{S,1666,"Sema::AccessResult Sema::CheckAddressOfMemberAccess(Expr *OvlExpr, DeclAccessPair Found) {\n  Entity.setDiag(diag::err_access) << Ovl->getSourceRange();"},{S,1714,"/// Checks access to all the declarations in the given result set.\nvoid Sema::CheckLookupAccess(const LookupResult &R) {\n  for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I) {\n    if (I.getAccess() != AS_public) {\n      Entity.setDiag(diag::err_access);"}}

[k]={{S,1513,"/// Checks access to a constructor.\nSema::AccessResult Sema::CheckConstructorAccess(SourceLocation UseLoc, CXXConstructorDecl *Constructor, DeclAccessPair Found, const InitializedEntity &Entity, bool IsCopyBindingRefToTemp) {\n  case InitializedEntity::EK_Base:\n    PD = PDiag(diag::err_access_base_ctor);"}}

[k]={{S,1508,"/// Checks access to a constructor.\nSema::AccessResult Sema::CheckConstructorAccess(SourceLocation UseLoc, CXXConstructorDecl *Constructor, DeclAccessPair Found, const InitializedEntity &Entity, bool IsCopyBindingRefToTemp) {\n  default:\n    PD = PDiag(IsCopyBindingRefToTemp ? diag::ext_rvalue_to_reference_access_ctor : diag::err_access_ctor);"}}

[k]={{v,10379,"Decl *Sema::ActOnUsingDeclaration(Scope *S, AccessSpecifier AS, SourceLocation UsingLoc, SourceLocation TypenameLoc, CXXScopeSpec &SS, UnqualifiedId &Name, SourceLocation EllipsisLoc, const ParsedAttributesView &AttrList) {\n  // Warn about access declarations.\n  if (UsingLoc.isInvalid()) {\n    Diag(Name.getBeginLoc(), getLangOpts().CPlusPlus11 ? diag::err_access_decl : diag::warn_access_decl_deprecated) << FixItHint::CreateInsertion(SS.getRange().getBegin(), \"using \");"}}

[k]={{x,3204,"/// ActOnCXXDelete - Parsed a C++ \'delete\' expression (C++ 5.3.5), as in:\n/// @code ::delete ptr; @endcode\n/// or\n/// @code delete [] ptr; @endcode\nExprResult Sema::ActOnCXXDelete(SourceLocation StartLoc, bool UseGlobal, bool ArrayForm, Expr *ExE) {\n  if (!Ex.get()->isTypeDependent()) {\n    if (PointeeRD) {\n      if (CXXDestructorDecl *Dtor = LookupDestructor(PointeeRD)) {\n        CheckDestructorAccess(Ex.get()->getExprLoc(), Dtor, PDiag(diag::err_access_dtor) << PointeeElem);"}}

[k]={{v,4964,"void Sema::MarkBaseAndMemberDestructorsReferenced(SourceLocation Location, CXXRecordDecl *ClassDecl) {\n  // Bases.\n  for (const auto &Base : ClassDecl->bases()) {\n    CheckDestructorAccess(Base.getBeginLoc(), Dtor, PDiag(diag::err_access_dtor_base) << Base.getType() << Base.getSourceRange(), Context.getTypeDeclType(ClassDecl));"}}

[k]={{x,924,"/// CheckCXXThrowOperand - Validate the operand of a throw.\nbool Sema::CheckCXXThrowOperand(SourceLocation ThrowLoc, QualType ExceptionObjectTy, Expr *E) {\n  // If the class has a destructor, we must be able to call it.\n  if (!RD->hasIrrelevantDestructor()) {\n    if (CXXDestructorDecl *Destructor = LookupDestructor(RD)) {\n      CheckDestructorAccess(E->getExprLoc(), Destructor, PDiag(diag::err_access_dtor_exception) << Ty);"}}

[k]={{v,4917,"void Sema::MarkBaseAndMemberDestructorsReferenced(SourceLocation Location, CXXRecordDecl *ClassDecl) {\n  // Non-static data members.\n  for (auto *Field : ClassDecl->fields()) {\n    CheckDestructorAccess(Field->getLocation(), Dtor, PDiag(diag::err_access_dtor_field) << Field->getDeclName() << FieldType);"}}

[k]={{v,15810,"/// SetIvarInitializers - This routine builds initialization ASTs for the\n/// Objective-C implementation whose ivars need be initialized.\nvoid Sema::SetIvarInitializers(ObjCImplementationDecl *ObjCImplementation) {\n  if (ObjCInterfaceDecl *OID = ObjCImplementation->getClassInterface()) {\n    for (unsigned i = 0; i < ivars.size(); i++) {\n      // Be sure that the destructor is accessible and is marked as referenced.\n      if (const RecordType *RecordTy = Context.getBaseElementType(Field->getType())->getAs<RecordType>()) {\n        if (CXXDestructorDecl *Destructor = LookupDestructor(RD)) {\n          CheckDestructorAccess(Field->getLocation(), Destructor, PDiag(diag::err_access_dtor_ivar) << Context.getBaseElementType(Field->getType()));"}}

[k]={{x,6354,"ExprResult Sema::MaybeBindToTemporary(Expr *E) {\n  if (Destructor) {\n    CheckDestructorAccess(E->getExprLoc(), Destructor, PDiag(diag::err_access_dtor_temp) << E->getType());"},{x,6504,"/// Process the expression contained within a decltype. For such expressions,\n/// certain semantic checks on temporaries are delayed until this point, and\n/// are omitted for the \'topmost\' call in the decltype expression. If the\n/// topmost call bound a temporary, strip that temporary off the expression.\nExprResult Sema::ActOnDecltypeExpression(Expr *E) {\n  // Now all relevant types are complete, check the destructors are accessible\n  // and non-deleted, and annotate them on the temporaries.\n  for (unsigned I = 0, N = ExprEvalContexts.back().DelayedDecltypeBinds.size(); I != N; ++I) {\n    CheckDestructorAccess(Bind->getExprLoc(), Destructor, PDiag(diag::err_access_dtor_temp) << Bind->getType());"},{E,1560,"/// Check if the type of a class element has an accessible destructor, and marks\n/// it referenced. Returns true if we shouldn\'t form a reference to the\n/// destructor.\n///\n/// Aggregate initialization requires a class element\'s destructor be\n/// accessible per 11.6.1 [dcl.init.aggr]:\n///\n/// The destructor for each element of class type is potentially invoked\n/// (15.4 [class.dtor]) from the context where the aggregate initialization\n/// occurs.\nstatic bool checkDestructorReference(QualType ElementType, SourceLocation Loc, Sema &SemaRef) {\n  SemaRef.CheckDestructorAccess(Loc, Destructor, SemaRef.PDiag(diag::err_access_dtor_temp) << ElementType);"},{E,7604,"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_UserConversion: {\n      if (shouldBindAsTemporary(Entity))\n      else if (CreatedObject && shouldDestroyEntity(Entity)) {\n        if (const RecordType *Record = T->getAs<RecordType>()) {\n          S.CheckDestructorAccess(CurInit.get()->getBeginLoc(), Destructor, S.PDiag(diag::err_access_dtor_temp) << T);"}}

[k]={{v,13572,"void Sema::FinalizeVarWithDestructor(VarDecl *VD, const RecordType *Record) {\n  // If this is an array, we\'ll require the destructor during initialization, so\n  // we can skip over this. We still want to emit exit-time destructor warnings\n  // though.\n  if (!VD->getType()->isArrayType()) {\n    CheckDestructorAccess(VD->getLocation(), Destructor, PDiag(diag::err_access_dtor_var) << VD->getDeclName() << VD->getType());"}}

[k]={{v,4995,"void Sema::MarkVirtualBaseDestructorsReferenced(SourceLocation Location, CXXRecordDecl *ClassDecl, llvm::SmallPtrSetImpl<const RecordType *> *DirectVirtualBases) {\n  // Virtual bases.\n  for (const auto &VBase : ClassDecl->vbases()) {\n    if (CheckDestructorAccess(ClassDecl->getLocation(), Dtor, PDiag(diag::err_access_dtor_vbase) << Context.getTypeDeclType(ClassDecl) << VBase.getType(), Context.getTypeDeclType(ClassDecl)) == AR_accessible) {"},{v,4996,"void Sema::MarkVirtualBaseDestructorsReferenced(SourceLocation Location, CXXRecordDecl *ClassDecl, llvm::SmallPtrSetImpl<const RecordType *> *DirectVirtualBases) {\n  // Virtual bases.\n  for (const auto &VBase : ClassDecl->vbases()) {\n    if (CheckDestructorAccess(ClassDecl->getLocation(), Dtor, PDiag(diag::err_access_dtor_vbase) << Context.getTypeDeclType(ClassDecl) << VBase.getType(), Context.getTypeDeclType(ClassDecl)) == AR_accessible) {\n      CheckDerivedToBaseConversion(Context.getTypeDeclType(ClassDecl), VBase.getType(), diag::err_access_dtor_vbase, 0, ClassDecl->getLocation(), SourceRange(), DeclarationName(), nullptr);"}}

[k]={{S,1520,"/// Checks access to a constructor.\nSema::AccessResult Sema::CheckConstructorAccess(SourceLocation UseLoc, CXXConstructorDecl *Constructor, DeclAccessPair Found, const InitializedEntity &Entity, bool IsCopyBindingRefToTemp) {\n  case InitializedEntity::EK_ParenAggInitMember: {\n    PD = PDiag(diag::err_access_field_ctor);"}}

[k]={{S,1641,"/// Checks access to the target of a friend declaration.\nSema::AccessResult Sema::CheckFriendAccess(NamedDecl *target) {\n  entity.setDiag(diag::err_access_friend_function) << (method->getQualifier() ? method->getQualifierLoc().getSourceRange() : method->getNameInfo().getSourceRange());"}}

[k]={{S,1527,"/// Checks access to a constructor.\nSema::AccessResult Sema::CheckConstructorAccess(SourceLocation UseLoc, CXXConstructorDecl *Constructor, DeclAccessPair Found, const InitializedEntity &Entity, bool IsCopyBindingRefToTemp) {\n  case InitializedEntity::EK_LambdaCapture: {\n    PD = PDiag(diag::err_access_lambda_capture);"}}

[k]={{K,2937,"Parser::DeclGroupPtrTy Parser::ParseCXXClassMemberDeclarationWithPragmas(AccessSpecifier &AS, ParsedAttributes &AccessAttrs, DeclSpec::TST TagType, Decl *TagDecl) {\n  case tok::kw_protected: {\n    // The Microsoft extension __interface does not permit non-public\n    // access specifiers.\n    if (TagType == DeclSpec::TST_interface && AS != AS_public) {\n      Diag(ASLoc, diag::err_access_specifier_interface) << (AS == AS_protected);"}}

[k]={{Q,10700,"// A helper class to help with address of function resolution\n// - allows us to avoid passing around all those ugly parameters\nclass AddressOfFunctionResolver {\n  void EliminateAllExceptMostSpecializedTemplate() {\n    UnresolvedSetIterator Result = S.getMostSpecialized(MatchesCopy.begin(), MatchesCopy.end(), FailedCandidates, SourceExpr->getBeginLoc(), S.PDiag(), S.PDiag(diag::err_addr_ovl_ambiguous) << Matches[0].second->getDeclName(), S.PDiag(diag::note_ovl_candidate) << (unsigned)oc_function << (unsigned)ocs_described_template, Complain, TargetFunctionType);"},{Q,10763,"// A helper class to help with address of function resolution\n// - allows us to avoid passing around all those ugly parameters\nclass AddressOfFunctionResolver {\n  void ComplainMultipleMatchesFound() const {\n    S.Diag(OvlExpr->getBeginLoc(), diag::err_addr_ovl_ambiguous) << OvlExpr->getName() << OvlExpr->getSourceRange();"},{Q,10998,"/// Given an expression that refers to an overloaded function, try to\n/// resolve that overloaded function expression down to a single function.\n///\n/// This routine can only resolve template-ids that refer to a single function\n/// template, where that template-id refers to a single template whose template\n/// arguments are either provided by the template-id or have defaults,\n/// as described in C++0x [temp.arg.explicit]p3.\n///\n/// If no template-ids are found, no diagnostics are emitted and NULL is\n/// returned.\nFunctionDecl *Sema::ResolveSingleFunctionTemplateSpecialization(OverloadExpr *ovl, bool Complain, DeclAccessPair *FoundResult, TemplateSpecCandidateSet *FailedTSC) {\n  for (UnresolvedSetIterator I = ovl->decls_begin(), E = ovl->decls_end(); I != E; ++I) {\n    // Multiple matches; we can\'t resolve to a single declaration.\n    if (Matched) {\n      if (Complain) {\n        Diag(ovl->getExprLoc(), diag::err_addr_ovl_ambiguous) << ovl->getName();"}}

[k]={{Q,10752,"// A helper class to help with address of function resolution\n// - allows us to avoid passing around all those ugly parameters\nclass AddressOfFunctionResolver {\n  void ComplainIsInvalidFormOfPointerToMemberFunction() const {\n    S.Diag(OvlExpr->getNameLoc(), diag::err_addr_ovl_no_qualifier) << TargetType << OvlExpr->getSourceRange();"}}

[k]={{Q,10729,"// A helper class to help with address of function resolution\n// - allows us to avoid passing around all those ugly parameters\nclass AddressOfFunctionResolver {\n  void ComplainNoMatchesFound() const {\n    S.Diag(OvlExpr->getBeginLoc(), diag::err_addr_ovl_no_viable) << OvlExpr->getName() << TargetFunctionType << OvlExpr->getSourceRange();"}}

[k]={{Q,10759,"// A helper class to help with address of function resolution\n// - allows us to avoid passing around all those ugly parameters\nclass AddressOfFunctionResolver {\n  void ComplainOfInvalidConversion() const { S.Diag(OvlExpr->getBeginLoc(), diag::err_addr_ovl_not_func_ptrref) << OvlExpr->getName() << TargetType; }"}}

[k]={{Q,9045,"/// Returns true if we can take the address of the function.\n///\n/// \\param Complain - If true, we\'ll emit a diagnostic\n/// \\param InOverloadResolution - For the purposes of emitting a diagnostic, are\n///  we in overload resolution?\n/// \\param Loc - The location of the statement we\'re complaining about. Ignored\n///  if we\'re not complaining, or if we\'re in overload resolution.\nstatic bool checkAddressOfFunctionIsAvailable(Sema &S, const FunctionDecl *FD, bool Complain, bool InOverloadResolution, SourceLocation Loc) {\n  if (Complain) {\n    if (InOverloadResolution)\n    else\n      S.Diag(Loc, diag::err_address_of_function_with_pass_object_size_params) << FD << ParamNo;"}}

[k]={{kb,1321,"#include \"clang/Basic/TransformTypeTraits.def\"\n  case tok::ampamp: { // unary-expression: \'&&\' identifier\n    if (getCurScope()->getFnParent() == nullptr)\n      return ExprError(Diag(Tok, diag::err_address_of_label_outside_fn));"}}

[k]={{x,3127,"/// ActOnCXXDelete - Parsed a C++ \'delete\' expression (C++ 5.3.5), as in:\n/// @code ::delete ptr; @endcode\n/// or\n/// @code delete [] ptr; @endcode\nExprResult Sema::ActOnCXXDelete(SourceLocation StartLoc, bool UseGlobal, bool ArrayForm, Expr *ExE) {\n  if (!Ex.get()->isTypeDependent()) {\n    if (Pointee.getAddressSpace() != LangAS::Default && !getLangOpts().OpenCLCPlusPlus)\n      return Diag(Ex.get()->getBeginLoc(), diag::err_address_space_qualified_delete) << Pointee.getUnqualifiedType() << Pointee.getQualifiers().getAddressSpaceAttributePrintValue();"}}

[k]={{x,2086,"/// Checks that a type is suitable as the allocated type\n/// in a new-expression.\nbool Sema::CheckAllocatedType(QualType AllocType, SourceLocation Loc, SourceRange R) {\n  // C++ 5.3.4p1: \"[The] type shall be a complete object type, but not an\n  //  abstract class type or array thereof.\n  if (AllocType->isFunctionType())\n  else if (AllocType->isReferenceType())\n  else if (!AllocType->isDependentType() && RequireCompleteSizedType(Loc, AllocType, diag::err_new_incomplete_or_sizeless_type, R))\n  else if (RequireNonAbstractType(Loc, AllocType, diag::err_allocation_of_abstract_type))\n  else if (AllocType->isVariablyModifiedType())\n  else if (AllocType.getAddressSpace() != LangAS::Default && !getLangOpts().OpenCLCPlusPlus)\n    return Diag(Loc, diag::err_address_space_qualified_new) << AllocType.getUnqualifiedType() << AllocType.getQualifiers().getAddressSpaceAttributePrintValue();"}}

[k]={{Q,9028,"/// Returns true if we can take the address of the function.\n///\n/// \\param Complain - If true, we\'ll emit a diagnostic\n/// \\param InOverloadResolution - For the purposes of emitting a diagnostic, are\n///  we in overload resolution?\n/// \\param Loc - The location of the statement we\'re complaining about. Ignored\n///  if we\'re not complaining, or if we\'re in overload resolution.\nstatic bool checkAddressOfFunctionIsAvailable(Sema &S, const FunctionDecl *FD, bool Complain, bool InOverloadResolution, SourceLocation Loc) {\n  if (FD->getTrailingRequiresClause()) {\n    if (!Satisfaction.IsSatisfied) {\n      if (Complain) {\n        if (InOverloadResolution) {\n        } else\n          S.Diag(Loc, diag::err_addrof_function_constraints_not_satisfied) << FD;"}}

[k]={{Q,9008,"/// Returns true if we can take the address of the function.\n///\n/// \\param Complain - If true, we\'ll emit a diagnostic\n/// \\param InOverloadResolution - For the purposes of emitting a diagnostic, are\n///  we in overload resolution?\n/// \\param Loc - The location of the statement we\'re complaining about. Ignored\n///  if we\'re not complaining, or if we\'re in overload resolution.\nstatic bool checkAddressOfFunctionIsAvailable(Sema &S, const FunctionDecl *FD, bool Complain, bool InOverloadResolution, SourceLocation Loc) {\n  if (!isFunctionAlwaysEnabled(S.Context, FD)) {\n    if (Complain) {\n      if (InOverloadResolution)\n      else\n        S.Diag(Loc, diag::err_addrof_function_disabled_by_enable_if_attr) << FD;"}}

[k]={{p,1831,"static void handleTLSModelAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n  if (S.Context.getTargetInfo().getTriple().isOSAIX() && Model != \"global-dynamic\" && Model != \"local-exec\") {\n    S.Diag(LiteralLoc, diag::err_aix_attr_unsupported_tls_model) << Model;"}}

[k]={{O,1538,"#include \"clang/Driver/Options.inc\"\n  if (Arg *A = Args.getLastArg(OPT_ftlsmodel_EQ)) {\n    if (T.isOSAIX()) {\n      if (Name != \"global-dynamic\" && Name != \"local-exec\")\n        Diags.Report(diag::err_aix_unsupported_tls_model) << Name;"}}

[k]={{q,2749,"/// checkNewAttributesAfterDef - If we already have a definition, check that\n/// there are no new attributes in this declaration.\nstatic void checkNewAttributesAfterDef(Sema &S, Decl *New, const Decl *Old) {\n  for (unsigned I = 0, E = NewAttributes.size(); I != E;) {\n    if (isa<AliasAttr>(NewAttribute) || isa<IFuncAttr>(NewAttribute)) {\n      if (FunctionDecl *FD = dyn_cast<FunctionDecl>(New)) {\n      } else {\n        unsigned Diag = cast<VarDecl>(Def)->isThisDeclarationADefinition() == VarDecl::TentativeDefinition ? diag::err_alias_after_tentative : diag::err_redefinition;"}}

[k]={{K,789,"Decl *Parser::ParseAliasDeclarationAfterDeclarator(const ParsedTemplateInfo &TemplateInfo, SourceLocation UsingLoc, UsingDeclarator &D, SourceLocation &DeclEnd, AccessSpecifier AS, ParsedAttributes &Attrs, Decl **OwnedType) {\n  // Name must be an identifier.\n  if (D.Name.getKind() != UnqualifiedIdKind::IK_Identifier) {\n    Diag(D.Name.StartLocation, diag::err_alias_declaration_not_identifier);"},{K,794,"Decl *Parser::ParseAliasDeclarationAfterDeclarator(const ParsedTemplateInfo &TemplateInfo, SourceLocation UsingLoc, UsingDeclarator &D, SourceLocation &DeclEnd, AccessSpecifier AS, ParsedAttributes &Attrs, Decl **OwnedType) {\n  // Name must be an identifier.\n  if (D.Name.getKind() != UnqualifiedIdKind::IK_Identifier) {\n  } else if (D.TypenameLoc.isValid())\n    Diag(D.TypenameLoc, diag::err_alias_declaration_not_identifier) << FixItHint::CreateRemoval(SourceRange(D.TypenameLoc, D.SS.isNotEmpty() ? D.SS.getEndLoc() : D.TypenameLoc));"},{K,796,"Decl *Parser::ParseAliasDeclarationAfterDeclarator(const ParsedTemplateInfo &TemplateInfo, SourceLocation UsingLoc, UsingDeclarator &D, SourceLocation &DeclEnd, AccessSpecifier AS, ParsedAttributes &Attrs, Decl **OwnedType) {\n  // Name must be an identifier.\n  if (D.Name.getKind() != UnqualifiedIdKind::IK_Identifier) {\n  } else if (D.TypenameLoc.isValid())\n  else if (D.SS.isNotEmpty())\n    Diag(D.SS.getBeginLoc(), diag::err_alias_declaration_not_identifier) << FixItHint::CreateRemoval(D.SS.getRange());"}}

[k]={{K,798,"Decl *Parser::ParseAliasDeclarationAfterDeclarator(const ParsedTemplateInfo &TemplateInfo, SourceLocation UsingLoc, UsingDeclarator &D, SourceLocation &DeclEnd, AccessSpecifier AS, ParsedAttributes &Attrs, Decl **OwnedType) {\n  if (D.EllipsisLoc.isValid())\n    Diag(D.EllipsisLoc, diag::err_alias_declaration_pack_expansion) << FixItHint::CreateRemoval(SourceRange(D.EllipsisLoc));"}}

[k]={{K,782,"Decl *Parser::ParseAliasDeclarationAfterDeclarator(const ParsedTemplateInfo &TemplateInfo, SourceLocation UsingLoc, UsingDeclarator &D, SourceLocation &DeclEnd, AccessSpecifier AS, ParsedAttributes &Attrs, Decl **OwnedType) {\n  if (SpecKind != -1) {\n    Diag(Range.getBegin(), diag::err_alias_declaration_specialization) << SpecKind << Range;"}}

[k]={{q,6200,"static void checkAttributesAfterMerging(Sema &S, NamedDecl &ND) {\n  if (auto *VD = dyn_cast<VarDecl>(&ND)) {\n    if (VD->hasInit()) {\n      if (const auto *Attr = VD->getAttr<AliasAttr>()) {\n        S.Diag(Attr->getLocation(), diag::err_alias_is_definition) << VD << 0;"},{q,13321,"Decl *Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope, Decl *D, SkipBodyInfo *SkipBody, FnBodyKind BodyKind) {\n  // Check for defining attributes before the check for redefinition.\n  if (const auto *Attr = FD->getAttr<AliasAttr>()) {\n    Diag(Attr->getLocation(), diag::err_alias_is_definition) << FD << 0;"},{q,13326,"Decl *Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope, Decl *D, SkipBodyInfo *SkipBody, FnBodyKind BodyKind) {\n  if (const auto *Attr = FD->getAttr<IFuncAttr>()) {\n    Diag(Attr->getLocation(), diag::err_alias_is_definition) << FD << 1;"},{p,1769,"static void handleIFuncAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n  if (FD->isThisDeclarationADefinition()) {\n    S.Diag(AL.getLoc(), diag::err_alias_is_definition) << FD << 1;"},{p,1792,"static void handleAliasAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n  // Aliases should be on declarations, not definitions.\n  if (const auto *FD = dyn_cast<FunctionDecl>(D)) {\n    if (FD->isThisDeclarationADefinition()) {\n      S.Diag(AL.getLoc(), diag::err_alias_is_definition) << FD << 0;"},{p,1798,"static void handleAliasAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n  // Aliases should be on declarations, not definitions.\n  if (const auto *FD = dyn_cast<FunctionDecl>(D)) {\n  } else {\n    if (VD->isThisDeclarationADefinition() && VD->isExternallyVisible()) {\n      S.Diag(AL.getLoc(), diag::err_alias_is_definition) << VD << 0;"},{p,6753,"static void handleWebAssemblyExportNameAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n  if (FD->isThisDeclarationADefinition()) {\n    S.Diag(D->getLocation(), diag::err_alias_is_definition) << FD << 0;"}}

[k]={{p,1782,"static void handleAliasAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n  if (S.Context.getTargetInfo().getTriple().isOSDarwin()) {\n    S.Diag(AL.getLoc(), diag::err_alias_not_supported_on_darwin);"}}

[k]={{p,1786,"static void handleAliasAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n  if (S.Context.getTargetInfo().getTriple().isNVPTX()) {\n    S.Diag(AL.getLoc(), diag::err_alias_not_supported_on_nvptx);"}}

[k]={{v,11427,"Decl *Sema::ActOnAliasDeclaration(Scope *S, AccessSpecifier AS, MultiTemplateParamsArg TemplateParamLists, SourceLocation UsingLoc, UnqualifiedId &Name, const ParsedAttributesView &AttrList, TypeResult Type, Decl *DeclFromDeclSpec) {\n  if (TemplateParamLists.size()) {\n    if (TemplateParamLists.size() != 1) {\n      Diag(UsingLoc, diag::err_alias_template_extra_headers) << SourceRange(TemplateParamLists[1]->getTemplateLoc(), TemplateParamLists[TemplateParamLists.size() - 1]->getRAngleLoc());"}}

[k]={{"clang/lib/CodeGen/CodeGenModule.cpp",515,"static bool checkAliasedGlobal(DiagnosticsEngine &Diags, SourceLocation Location, bool IsIFunc, const llvm::GlobalValue *Alias, const llvm::GlobalValue *&GV, const llvm::MapVector<GlobalDecl, StringRef> &MangledDeclNames, SourceRange AliasRange) {\n  if (GV->isDeclaration()) {\n    Diags.Report(Location, diag::err_alias_to_undefined) << IsIFunc << IsIFunc;"},{"clang/lib/CodeGen/CodeGenModule.cpp",533,"static bool checkAliasedGlobal(DiagnosticsEngine &Diags, SourceLocation Location, bool IsIFunc, const llvm::GlobalValue *Alias, const llvm::GlobalValue *&GV, const llvm::MapVector<GlobalDecl, StringRef> &MangledDeclNames, SourceRange AliasRange) {\n  if (IsIFunc) {\n    if (!F) {\n      Diags.Report(Location, diag::err_alias_to_undefined) << IsIFunc << IsIFunc;"}}

[k]={{p,3785,"void Sema::AddAlignValueAttr(Decl *D, const AttributeCommonInfo &CI, Expr *E) {\n  if (!E->isValueDependent()) {\n    ExprResult ICE = VerifyIntegerConstantExpression(E, &Alignment, diag::err_align_value_attribute_argument_not_int);"}}

[k]={{p,3877,"/// Perform checking of type validity\n///\n/// C++11 [dcl.align]p1:\n///  An alignment-specifier may be applied to a variable or to a class\n///  data member, but it shall not be applied to a bit-field, a function\n///  parameter, the formal parameter of a catch clause, or a variable\n///  declared with the register storage class specifier. An\n///  alignment-specifier may also be applied to the declaration of a class\n///  or enumeration type.\n/// CWG 2354:\n///  CWG agreed to remove permission for alignas to be applied to\n///  enumerations.\n/// C11 6.7.5/2:\n///  An alignment attribute shall not be specified in a declaration of\n///  a typedef, or a bit-field, or a function, or a parameter, or an\n///  object declared with the register storage-class specifier.\nstatic bool validateAlignasAppliedType(Sema &S, Decl *D, const AlignedAttr &Attr, SourceLocation AttrLoc) {\n  if (DiagKind != -1) {\n    return S.Diag(AttrLoc, diag::err_alignas_attribute_wrong_decl_type) << &Attr << DiagKind;"}}

[k]={{q,2571,"/// Merge alignment attributes from \\p Old to \\p New, taking into account the\n/// special semantics of C11\'s _Alignas specifier and C++11\'s alignas attribute.\n///\n/// \\return \\c true if any attributes were added to \\p New.\nstatic bool mergeAlignedAttrs(Sema &S, NamedDecl *New, Decl *Old) {\n  if (OldAlignasAttr && NewAlignasAttr && OldAlign != NewAlign) {\n    if (OldAlign != NewAlign) {\n      S.Diag(NewAlignasAttr->getLocation(), diag::err_alignas_mismatch) << (unsigned)S.Context.toCharUnitsFromBits(OldAlign).getQuantity() << (unsigned)S.Context.toCharUnitsFromBits(NewAlign).getQuantity();"}}

[k]={{q,2585,"/// Merge alignment attributes from \\p Old to \\p New, taking into account the\n/// special semantics of C11\'s _Alignas specifier and C++11\'s alignas attribute.\n///\n/// \\return \\c true if any attributes were added to \\p New.\nstatic bool mergeAlignedAttrs(Sema &S, NamedDecl *New, Decl *Old) {\n  if (OldAlignasAttr && !NewAlignasAttr && isAttributeTargetADefinition(New)) {\n    S.Diag(New->getLocation(), diag::err_alignas_missing_on_definition) << OldAlignasAttr;"},{q,2792,"/// checkNewAttributesAfterDef - If we already have a definition, check that\n/// there are no new attributes in this declaration.\nstatic void checkNewAttributesAfterDef(Sema &S, Decl *New, const Decl *Old) {\n  for (unsigned I = 0, E = NewAttributes.size(); I != E;) {\n    if (isa<C11NoReturnAttr>(NewAttribute)) {\n    } else if (isa<UuidAttr>(NewAttribute)) {\n    } else if (const AlignedAttr *AA = dyn_cast<AlignedAttr>(NewAttribute)) {\n      if (AA->isAlignas()) {\n        S.Diag(Def->getLocation(), diag::err_alignas_missing_on_definition) << AA;"}}

[k]={{p,4039,"void Sema::CheckAlignasUnderalignment(Decl *D) {\n  if (Align && DiagTy->isSizelessType()) {\n  } else if (AlignasAttr && Align) {\n    if (NaturalAlign > RequestedAlign)\n      Diag(AlignasAttr->getLocation(), diag::err_alignas_underaligned) << DiagTy << (unsigned)NaturalAlign.getQuantity();"}}

[k]={{x,1720,"// Emit a diagnostic if an aligned allocation/deallocation function that is not\n// implemented in the standard library is selected.\nvoid Sema::diagnoseUnavailableAlignedAllocation(const FunctionDecl &FD, SourceLocation Loc) {\n  if (isUnavailableAlignedAllocationFunction(FD)) {\n    Diag(Loc, diag::err_aligned_allocation_unavailable) << IsDelete << FD.getType().getAsString() << OSName << OSVersion.getAsString() << OSVersion.empty();"}}

[k]={{p,3910,"void Sema::AddAlignedAttr(Decl *D, const AttributeCommonInfo &CI, Expr *E, bool IsPackExpansion) {\n  ExprResult ICE = VerifyIntegerConstantExpression(E, &Alignment, diag::err_aligned_attribute_argument_not_int);"}}

[k]={{p,3896,"void Sema::AddAlignedAttr(Decl *D, const AttributeCommonInfo &CI, Expr *E, bool IsPackExpansion) {\n  if (E->isValueDependent()) {\n    // We can\'t support a dependent alignment on a non-dependent type,\n    // because we have no way to model that a type is \"alignment-dependent\"\n    // but not dependent in any other way.\n    if (const auto *TND = dyn_cast<TypedefNameDecl>(D)) {\n      if (!TND->getUnderlyingType()->isDependentType()) {\n        Diag(AttrLoc, diag::err_alignment_dependent_typedef_name) << E->getSourceRange();"},{p,3974,"void Sema::AddAlignedAttr(Decl *D, const AttributeCommonInfo &CI, TypeSourceInfo *TS, bool IsPackExpansion) {\n  if (TS->getType()->isDependentType()) {\n    // We can\'t support a dependent alignment on a non-dependent type,\n    // because we have no way to model that a type is \"type-dependent\"\n    // but not dependent in any other way.\n    if (const auto *TND = dyn_cast<TypedefNameDecl>(D)) {\n      if (!TND->getUnderlyingType()->isDependentType()) {\n        Diag(AttrLoc, diag::err_alignment_dependent_typedef_name) << TS->getTypeLoc().getSourceRange();"}}

[k]={{s,299,"/// Check that the value argument for __builtin_is_aligned(value, alignment) and\n/// __builtin_aligned_{up,down}(value, alignment) is an integer or a pointer\n/// type (but not a function pointer) and that the alignment is a power-of-two.\nstatic bool SemaBuiltinAlignment(Sema &S, CallExpr *TheCall, unsigned ID) {\n  // We can\'t check validity of alignment if it is value dependent.\n  if (!AlignOp->isValueDependent() && AlignOp->EvaluateAsInt(AlignResult, S.Context, Expr::SE_AllowSideEffects)) {\n    if (!AlignValue.isPowerOf2()) {\n      S.Diag(AlignOp->getExprLoc(), diag::err_alignment_not_power_of_two);"},{s,8067,"/// Handle __builtin_alloca_with_align. This is declared\n/// as (size_t, size_t) where the second size_t must be a power of 2 greater\n/// than 8.\nbool Sema::SemaBuiltinAllocaWithAlign(CallExpr *TheCall) {\n  // We can\'t check the value of a dependent argument.\n  if (!Arg->isTypeDependent() && !Arg->isValueDependent()) {\n    if (!Result.isPowerOf2())\n      return Diag(TheCall->getBeginLoc(), diag::err_alignment_not_power_of_two) << Arg->getSourceRange();"},{s,8106,"/// Handle __builtin_assume_aligned. This is declared\n/// as (const void*, size_t, ...) and can take one optional constant int arg.\nbool Sema::SemaBuiltinAssumeAligned(CallExpr *TheCall) {\n  // We can\'t check the value of a dependent argument.\n  if (!SecondArg->isValueDependent()) {\n    if (!Result.isPowerOf2())\n      return Diag(TheCall->getBeginLoc(), diag::err_alignment_not_power_of_two) << SecondArg->getSourceRange();"},{p,1525,"void Sema::AddAssumeAlignedAttr(Decl *D, const AttributeCommonInfo &CI, Expr *E, Expr *OE) {\n  if (!E->isValueDependent()) {\n    if (!I->isPowerOf2()) {\n      Diag(AttrLoc, diag::err_alignment_not_power_of_two) << E->getSourceRange();"},{p,3790,"void Sema::AddAlignValueAttr(Decl *D, const AttributeCommonInfo &CI, Expr *E) {\n  if (!E->isValueDependent()) {\n    if (!Alignment.isPowerOf2()) {\n      Diag(AttrLoc, diag::err_alignment_not_power_of_two) << E->getSourceRange();"},{p,3930,"void Sema::AddAlignedAttr(Decl *D, const AttributeCommonInfo &CI, Expr *E, bool IsPackExpansion) {\n  // C++11 [dcl.align]p2:\n  //  -- if the constant expression evaluates to zero, the alignment\n  //      specifier shall have no effect\n  // C11 6.7.5p6:\n  //  An alignment specification of zero has no effect.\n  if (!(TmpAttr.isAlignas() && !Alignment)) {\n    if (!llvm::isPowerOf2_64(AlignVal)) {\n      Diag(AttrLoc, diag::err_alignment_not_power_of_two) << E->getSourceRange();"}}

[k]={{s,295,"/// Check that the value argument for __builtin_is_aligned(value, alignment) and\n/// __builtin_aligned_{up,down}(value, alignment) is an integer or a pointer\n/// type (but not a function pointer) and that the alignment is a power-of-two.\nstatic bool SemaBuiltinAlignment(Sema &S, CallExpr *TheCall, unsigned ID) {\n  // We can\'t check validity of alignment if it is value dependent.\n  if (!AlignOp->isValueDependent() && AlignOp->EvaluateAsInt(AlignResult, S.Context, Expr::SE_AllowSideEffects)) {\n    if (llvm::APSInt::compareValues(AlignValue, MaxValue) > 0) {\n      S.Diag(AlignOp->getExprLoc(), diag::err_alignment_too_big) << toString(MaxValue, 10);"},{s,8073,"/// Handle __builtin_alloca_with_align. This is declared\n/// as (size_t, size_t) where the second size_t must be a power of 2 greater\n/// than 8.\nbool Sema::SemaBuiltinAllocaWithAlign(CallExpr *TheCall) {\n  // We can\'t check the value of a dependent argument.\n  if (!Arg->isTypeDependent() && !Arg->isValueDependent()) {\n    if (Result > std::numeric_limits<int32_t>::max())\n      return Diag(TheCall->getBeginLoc(), diag::err_alignment_too_big) << std::numeric_limits<int32_t>::max() << Arg->getSourceRange();"}}

[k]={{s,291,"/// Check that the value argument for __builtin_is_aligned(value, alignment) and\n/// __builtin_aligned_{up,down}(value, alignment) is an integer or a pointer\n/// type (but not a function pointer) and that the alignment is a power-of-two.\nstatic bool SemaBuiltinAlignment(Sema &S, CallExpr *TheCall, unsigned ID) {\n  // We can\'t check validity of alignment if it is value dependent.\n  if (!AlignOp->isValueDependent() && AlignOp->EvaluateAsInt(AlignResult, S.Context, Expr::SE_AllowSideEffects)) {\n    if (AlignValue < 1) {\n      S.Diag(AlignOp->getExprLoc(), diag::err_alignment_too_small) << 1;"},{s,8070,"/// Handle __builtin_alloca_with_align. This is declared\n/// as (size_t, size_t) where the second size_t must be a power of 2 greater\n/// than 8.\nbool Sema::SemaBuiltinAllocaWithAlign(CallExpr *TheCall) {\n  // We can\'t check the value of a dependent argument.\n  if (!Arg->isTypeDependent() && !Arg->isValueDependent()) {\n    if (Result < Context.getCharWidth())\n      return Diag(TheCall->getBeginLoc(), diag::err_alignment_too_small) << (unsigned)Context.getCharWidth() << Arg->getSourceRange();"}}

[k]={{y,3919,"static bool CheckAlignOfExpr(Sema &S, Expr *E, UnaryExprOrTypeTrait ExprKind) {\n  // If it\'s a field, require the containing struct to have a\n  // complete definition so that we can compute the layout.\n  //\n  // This can happen in C++11 onwards, either by naming the member\n  // in a way that is not transformed into a member access expression\n  // (in an unevaluated operand, for instance), or by naming the member\n  // in a trailing-return-type.\n  //\n  // For the record, since __alignof__ on expressions is a GCC\n  // extension, GCC seems to permit this but always gives the\n  // nonsensical answer 0.\n  //\n  // We don\'t really need the layout here --- we could instead just\n  // directly check for all the appropriate alignment-lowing\n  // attributes --- but that would require duplicating a lot of\n  // logic that just isn\'t worth duplicating for such a marginal\n  // use-case.\n  if (FieldDecl *FD = dyn_cast_or_null<FieldDecl>(D)) {\n    // Fast path this check, since we at least know the record has a\n    // definition if we can find a member of it.\n    if (!FD->getParent()->isCompleteDefinition()) {\n      S.Diag(E->getExprLoc(), diag::err_alignof_member_of_incomplete_type) << E->getSourceRange();"}}

[k]={{w,1609,"/// TryStaticImplicitCast - Tests whether a conversion according to C++ 5.2.9p2\n/// is valid:\n///\n///  An expression e can be explicitly converted to a type T using a\n///  @c static_cast if the declaration \"T t(e);\" is well-formed [...].\nTryCastResult TryStaticImplicitCast(Sema &Self, ExprResult &SrcExpr, QualType DestType, Sema::CheckedConversionKind CCK, SourceRange OpRange, unsigned &msg, CastKind &Kind, bool ListInitialization) {\n  if (DestType->isRecordType()) {\n    if (Self.RequireCompleteType(OpRange.getBegin(), DestType, diag::err_bad_cast_incomplete) || Self.RequireNonAbstractType(OpRange.getBegin(), DestType, diag::err_allocation_of_abstract_type)) {"},{x,2081,"/// Checks that a type is suitable as the allocated type\n/// in a new-expression.\nbool Sema::CheckAllocatedType(QualType AllocType, SourceLocation Loc, SourceRange R) {\n  else if (RequireNonAbstractType(Loc, AllocType, diag::err_allocation_of_abstract_type))"},{x,3487,"static ExprResult BuildCXXCastArgument(Sema &S, SourceLocation CastLoc, QualType Ty, CastKind Kind, CXXMethodDecl *Method, DeclAccessPair FoundDecl, bool HadMultipleCandidates, Expr *From) {\n  case CK_ConstructorConversion: {\n    if (S.RequireNonAbstractType(CastLoc, Ty, diag::err_allocation_of_abstract_type))"},{E,7426,"ExprResult InitializationSequence::Perform(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, MultiExprArg Args, QualType *ResultType) {\n  // C++ [class.abstract]p2:\n  //  no objects of an abstract class can be created except as subobjects\n  //  of a class derived from it\n  auto checkAbstractType = [&](QualType T) -> bool {\n    return S.RequireNonAbstractType(Kind.getLocation(), T, diag::err_allocation_of_abstract_type);"}}

[k]={{y,7263,"ExprResult Sema::ActOnCastExpr(Scope *S, SourceLocation LParenLoc, Declarator &D, ParsedType &Ty, SourceLocation RParenLoc, Expr *CastExpr) {\n  if ((getLangOpts().AltiVec || getLangOpts().ZVector || getLangOpts().OpenCL) && castType->isVectorType() && (PE || PLE)) {\n    if (PLE && PLE->getNumExprs() == 0) {\n      Diag(PLE->getExprLoc(), diag::err_altivec_empty_initializer);"}}

[k]={{w,1470,"/// TryStaticDowncast - Common functionality of TryStaticReferenceDowncast and\n/// TryStaticPointerDowncast. Tests whether a static downcast from SrcType to\n/// DestType is possible and allowed.\nTryCastResult TryStaticDowncast(Sema &Self, CanQualType SrcType, CanQualType DestType, bool CStyle, SourceRange OpRange, QualType OrigSrcType, QualType OrigDestType, unsigned &msg, CastKind &Kind, CXXCastPath &BasePath) {\n  if (Paths.isAmbiguous(SrcType.getUnqualifiedType())) {\n    Self.Diag(OpRange.getBegin(), diag::err_ambiguous_base_to_derived_cast) << QualType(SrcType).getUnqualifiedType() << QualType(DestType).getUnqualifiedType() << PathDisplayStr << OpRange;"}}

[k]={{x,3107,"/// ActOnCXXDelete - Parsed a C++ \'delete\' expression (C++ 5.3.5), as in:\n/// @code ::delete ptr; @endcode\n/// or\n/// @code delete [] ptr; @endcode\nExprResult Sema::ActOnCXXDelete(SourceLocation StartLoc, bool UseGlobal, bool ArrayForm, Expr *ExE) {\n  if (!Ex.get()->isTypeDependent()) {\n    class DeleteConverter : public ContextualImplicitConverter {\n      SemaDiagnosticBuilder diagnoseAmbiguous(Sema &S, SourceLocation Loc, QualType T) override { return S.Diag(Loc, diag::err_ambiguous_delete_operand) << T; }"}}

[k]={{v,2697,"bool Sema::CheckDerivedToBaseConversion(QualType Derived, QualType Base, SourceLocation Loc, SourceRange Range, CXXCastPath *BasePath, bool IgnoreAccess) { return CheckDerivedToBaseConversion(Derived, Base, diag::err_upcast_to_inaccessible_base, diag::err_ambiguous_derived_to_base_conv, Loc, Range, DeclarationName(), BasePath, IgnoreAccess); }"},{Q,2694,"/// 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 (const PointerType *ToPtrType = ToType->getAs<PointerType>()) {\n    if (const PointerType *FromPtrType = FromType->getAs<PointerType>()) {\n      if (FromPointeeType->isRecordType() && ToPointeeType->isRecordType() && !Context.hasSameUnqualifiedType(FromPointeeType, ToPointeeType)) {\n        if (Diagnose) {\n          AmbiguousID = diag::err_ambiguous_derived_to_base_conv;"}}

[k]={{q,16235,"/// [class.dtor]p4:\n///  At the end of the definition of a class, overload resolution is\n///  performed among the prospective destructors declared in that class with\n///  an empty argument list to select the destructor for the class, also\n///  known as the selected destructor.\n///\n/// We do the overload resolution here, then mark the selected constructor in the AST.\n/// Later CXXRecordDecl::getDestructor() will return the selected constructor.\nstatic void ComputeSelectedDestructor(Sema &S, CXXRecordDecl *Record) {\n  case OR_Ambiguous:\n    Msg = diag::err_ambiguous_destructor;"}}

[k]={{v,6236,"class Sema::InheritedConstructorInfo {\n  InheritedConstructorInfo(Sema &S, SourceLocation UseLoc, ConstructorUsingShadowDecl *Shadow) : S(S), UseLoc(UseLoc) {\n    // Find the set of such base class subobjects and check that there\'s a\n    // unique constructed subobject.\n    for (auto *D : Shadow->redecls()) {\n      // [class.inhctor.init]p2:\n      //  If the constructor was inherited from multiple base class subobjects\n      //  of type B, the program is ill-formed.\n      if (!ConstructedBase) {\n      } else if (ConstructedBase != DConstructedBase && !Shadow->isInvalidDecl()) {\n        if (!DiagnosedMultipleConstructedBases) {\n          S.Diag(UseLoc, diag::err_ambiguous_inherited_constructor) << Shadow->getTargetDecl();"}}

[k]={{"clang/lib/Sema/SemaLookup.cpp",2577,"/// Produce a diagnostic describing the ambiguity that resulted\n/// from name lookup.\n///\n/// \\param Result The result of the ambiguous lookup to be diagnosed.\nvoid Sema::DiagnoseAmbiguousLookup(LookupResult &Result) {\n  case LookupResult::AmbiguousBaseSubobjectTypes: {\n    Diag(NameLoc, diag::err_ambiguous_member_multiple_subobject_types) << Name << LookupRange;"}}

[k]={{"clang/lib/Sema/SemaLookup.cpp",2566,"/// Produce a diagnostic describing the ambiguity that resulted\n/// from name lookup.\n///\n/// \\param Result The result of the ambiguous lookup to be diagnosed.\nvoid Sema::DiagnoseAmbiguousLookup(LookupResult &Result) {\n  case LookupResult::AmbiguousBaseSubobjects: {\n    Diag(NameLoc, diag::err_ambiguous_member_multiple_subobjects) << Name << SubobjectType << getAmbiguousPathsDisplayString(*Paths) << LookupRange;"}}

[k]={{w,1555,"/// TryStaticMemberPointerUpcast - Tests whether a conversion according to\n/// C++ 5.2.9p9 is valid:\n///\n///  An rvalue of type \"pointer to member of D of type cv1 T\" can be\n///  converted to an rvalue of type \"pointer to member of B of type cv2 T\",\n///  where B is a base class of D [...].\n///\nTryCastResult TryStaticMemberPointerUpcast(Sema &Self, ExprResult &SrcExpr, QualType SrcType, QualType DestType, bool CStyle, SourceRange OpRange, unsigned &msg, CastKind &Kind, CXXCastPath &BasePath) {\n  // B is a base of D. But is it an allowed base? If not, it\'s a hard error.\n  if (Paths.isAmbiguous(Self.Context.getCanonicalType(DestClass))) {\n    Self.Diag(OpRange.getBegin(), diag::err_ambiguous_memptr_conv) << 1 << SrcClass << DestClass << PathDisplayStr << OpRange;"},{Q,2802,"/// CheckMemberPointerConversion - Check the member pointer conversion from the\n/// expression From to the type ToType. This routine checks for ambiguous or\n/// virtual or inaccessible base-to-derived member pointer conversions\n/// for which IsMemberPointerConversion has already returned true. It returns\n/// true and produces a diagnostic if there was an error, or returns false\n/// otherwise.\nbool Sema::CheckMemberPointerConversion(Expr *From, QualType ToType, CastKind &Kind, CXXCastPath &BasePath, bool IgnoreBaseAccess) {\n  if (Paths.isAmbiguous(Context.getCanonicalType(FromClass).getUnqualifiedType())) {\n    Diag(From->getExprLoc(), diag::err_ambiguous_memptr_conv) << 0 << FromClass << ToClass << PathDisplayStr << From->getSourceRange();"}}

[k]={{"clang/lib/Sema/SemaLookup.cpp",2623,"/// Produce a diagnostic describing the ambiguity that resulted\n/// from name lookup.\n///\n/// \\param Result The result of the ambiguous lookup to be diagnosed.\nvoid Sema::DiagnoseAmbiguousLookup(LookupResult &Result) {\n  case LookupResult::AmbiguousReference: {\n    Diag(NameLoc, diag::err_ambiguous_reference) << Name << LookupRange;"}}

[k]={{x,2803,"bool Sema::FindDeallocationFunction(SourceLocation StartLoc, CXXRecordDecl *RD, DeclarationName Name, FunctionDecl *&Operator, bool Diagnose, bool WantSize, bool WantAligned) {\n  // We found multiple suitable operators; complain about the ambiguity.\n  // FIXME: The standard doesn\'t say to do this; it appears that the intent\n  // is that this should never happen.\n  if (!Matches.empty()) {\n    if (Diagnose) {\n      Diag(StartLoc, diag::err_ambiguous_suitable_delete_member_function_found) << Name << RD;"}}

[k]={{"clang/lib/Sema/SemaLookup.cpp",2598,"/// Produce a diagnostic describing the ambiguity that resulted\n/// from name lookup.\n///\n/// \\param Result The result of the ambiguous lookup to be diagnosed.\nvoid Sema::DiagnoseAmbiguousLookup(LookupResult &Result) {\n  case LookupResult::AmbiguousTagHiding: {\n    Diag(NameLoc, diag::err_ambiguous_tag_hiding) << Name << LookupRange;"}}

[k]={{"clang/lib/StaticAnalyzer/Checkers/ContainerModeling.cpp",876,"bool ento::shouldRegisterContainerModeling(const CheckerManager &mgr) {\n  if (!mgr.getAnalyzerOptions().ShouldAggressivelySimplifyBinaryOperation) {\n    mgr.getASTContext().getDiagnostics().Report(diag::err_analyzer_checker_incompatible_analyzer_option) << \"aggressive-binary-operation-simplification\""}}

[k]={{"clang/lib/StaticAnalyzer/Core/CheckerManager.cpp",51,"void CheckerManager::reportInvalidCheckerOptionValue(const CheckerBase *C, StringRef OptionName, StringRef ExpectedValueDesc) const { getDiagnostics().Report(diag::err_analyzer_checker_option_invalid_input) << (llvm::Twine() + C->getTagDescription() + \":\" + OptionName).str() << ExpectedValueDesc; }"},{"clang/lib/StaticAnalyzer/Frontend/CheckerRegistry.cpp",301,"/// Insert the checker/package option to AnalyzerOptions\' config table, and\n/// validate it, if the user supplied it on the command line.\nstatic void insertAndValidate(StringRef FullName, const CmdLineOption &Option, AnalyzerOptions &AnOpts, DiagnosticsEngine &Diags) {\n  if (Option.OptionType == \"bool\") {\n    if (SuppliedValue != \"true\" && SuppliedValue != \"false\") {\n      if (AnOpts.ShouldEmitErrorsOnInvalidConfigValue) {\n        Diags.Report(diag::err_analyzer_checker_option_invalid_input) << FullOption << \"a boolean value\";"},{"clang/lib/StaticAnalyzer/Frontend/CheckerRegistry.cpp",314,"/// Insert the checker/package option to AnalyzerOptions\' config table, and\n/// validate it, if the user supplied it on the command line.\nstatic void insertAndValidate(StringRef FullName, const CmdLineOption &Option, AnalyzerOptions &AnOpts, DiagnosticsEngine &Diags) {\n  if (Option.OptionType == \"int\") {\n    if (HasFailed) {\n      if (AnOpts.ShouldEmitErrorsOnInvalidConfigValue) {\n        Diags.Report(diag::err_analyzer_checker_option_invalid_input) << FullOption << \"an integer value\";"}}

[k]={{"clang/lib/StaticAnalyzer/Frontend/CheckerRegistry.cpp",377,"static void isOptionContainedIn(const CmdLineOptionList &OptionList, StringRef SuppliedChecker, StringRef SuppliedOption, const AnalyzerOptions &AnOpts, DiagnosticsEngine &Diags) {\n  if (llvm::none_of(OptionList, SameOptName)) {\n    Diags.Report(diag::err_analyzer_checker_option_unknown) << SuppliedChecker << SuppliedOption;"}}

[k]={{O,893,"static void initOption(AnalyzerOptions::ConfigTable &Config, DiagnosticsEngine *Diags, bool &OptionField, StringRef Name, bool DefaultVal) {\n  if (!PossiblyInvalidVal) {\n    if (Diags)\n      Diags->Report(diag::err_analyzer_config_invalid_input) << Name << \"a boolean\";"},{O,905,"static void initOption(AnalyzerOptions::ConfigTable &Config, DiagnosticsEngine *Diags, unsigned &OptionField, StringRef Name, unsigned DefaultVal) {\n  if (Diags && HasFailed)\n    Diags->Report(diag::err_analyzer_config_invalid_input) << Name << \"an unsigned\";"},{O,952,"#include \"clang/StaticAnalyzer/Core/AnalyzerOptions.def\"\n  if (AnOpts.ShouldTrackConditionsDebug && !AnOpts.ShouldTrackConditions)\n    Diags->Report(diag::err_analyzer_config_invalid_input) << \"track-conditions-debug\""},{O,956,"#include \"clang/StaticAnalyzer/Core/AnalyzerOptions.def\"\n  if (!AnOpts.CTUDir.empty() && !llvm::sys::fs::is_directory(AnOpts.CTUDir))\n    Diags->Report(diag::err_analyzer_config_invalid_input) << \"ctu-dir\""},{O,960,"#include \"clang/StaticAnalyzer/Core/AnalyzerOptions.def\"\n  if (!AnOpts.ModelPath.empty() && !llvm::sys::fs::is_directory(AnOpts.ModelPath))\n    Diags->Report(diag::err_analyzer_config_invalid_input) << \"model-path\""}}

[k]={{O,846,"#include \"clang/StaticAnalyzer/Core/Analyses.def\"\n  // Go through the analyzer configuration options.\n  for (const auto *A : Args.filtered(OPT_analyzer_config)) {\n    for (const auto &configVal : configVals) {\n      if (val.contains(\'=\')) {\n        Diags.Report(SourceLocation(), diag::err_analyzer_config_multiple_values) << configVal;"}}

[k]={{O,842,"#include \"clang/StaticAnalyzer/Core/Analyses.def\"\n  // Go through the analyzer configuration options.\n  for (const auto *A : Args.filtered(OPT_analyzer_config)) {\n    for (const auto &configVal : configVals) {\n      if (val.empty()) {\n        Diags.Report(SourceLocation(), diag::err_analyzer_config_no_value) << configVal;"}}

[k]={{O,854,"#include \"clang/StaticAnalyzer/Core/Analyses.def\"\n  // Go through the analyzer configuration options.\n  for (const auto *A : Args.filtered(OPT_analyzer_config)) {\n    for (const auto &configVal : configVals) {\n      // TODO: Check checker options too, possibly in CheckerRegistry.\n      // Leave unknown non-checker configs unclaimed.\n      if (!key.contains(\":\") && Opts.isUnknownAnalyzerConfig(key)) {\n        if (Opts.ShouldEmitErrorsOnInvalidConfigValue)\n          Diags.Report(diag::err_analyzer_config_unknown) << key;"}}

[k]={{O,771,"#ifndef LLVM_WITH_Z3\n      if (Value == AnalysisConstraints::Z3ConstraintsModel) {\n        Diags.Report(diag::err_analyzer_not_built_with_z3);"}}

[k]={{q,15689,"// Note that FieldName may be null for anonymous bitfields.\nExprResult Sema::VerifyBitField(SourceLocation FieldLoc, IdentifierInfo *FieldName, QualType FieldTy, bool IsMsStruct, Expr *BitWidth) {\n  if (Value.isSigned() && Value.isNegative()) {\n    return Diag(FieldLoc, diag::err_anon_bitfield_has_negative_width) << toString(Value, 10);"}}

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

[k]={{q,15881,"/// Build a new FieldDecl and check its well-formedness.\n///\n/// This routine builds a new FieldDecl given the fields name, type,\n/// record, etc. \\p PrevDecl should refer to any previous declaration\n/// with the same name and in the same scope as the field to be\n/// created.\n///\n/// \\returns a new FieldDecl.\n///\n/// \\todo The Declarator argument is a hack. It will be removed once\nFieldDecl *Sema::CheckFieldDecl(DeclarationName Name, QualType T, TypeSourceInfo *TInfo, RecordDecl *Record, SourceLocation Loc, bool Mutable, Expr *BitWidth, InClassInitStyle InitStyle, SourceLocation TSSL, AccessSpecifier AS, NamedDecl *PrevDecl, Declarator *D) {\n  // Anonymous bit-fields cannot be cv-qualified (CWG 2229).\n  if (!InvalidDecl && getLangOpts().CPlusPlus && !II && BitWidth && T.hasQualifiers()) {\n    Diag(Loc, diag::err_anon_bitfield_qualifiers);"}}

[k]={{K,1669,"#include \"clang/Basic/TransformTypeTraits.def\"\n  if (!Name && !TemplateId && (DS.getTypeSpecType() == DeclSpec::TST_error || TUK != Sema::TUK_Definition)) {\n    if (DS.getTypeSpecType() != DeclSpec::TST_error) {\n      Diag(StartLoc, diag::err_anon_type_definition) << DeclSpec::getSpecifierName(TagType, Policy);"}}

[k]={{D,4460,"/// ParseEnumSpecifier\n///      enum-specifier: [C99 6.7.2.2]\n///        \'enum\' identifier[opt] \'{\' enumerator-list \'}\'\n///[C99/C++]\'enum\' identifier[opt] \'{\' enumerator-list \',\' \'}\'\n/// [GNU]  \'enum\' attributes[opt] identifier[opt] \'{\' enumerator-list \',\' [opt]\n///                                                \'}\' attributes[opt]\n/// [MS]    \'enum\' __declspec[opt] identifier[opt] \'{\' enumerator-list \',\' [opt]\n///                                                \'}\'\n///        \'enum\' identifier\n/// [GNU]  \'enum\' attributes[opt] identifier\n///\n/// [C++11] enum-head \'{\' enumerator-list[opt] \'}\'\n/// [C++11] enum-head \'{\' enumerator-list \',\'  \'}\'\n///\n///      enum-head: [C++11]\n///        enum-key attribute-specifier-seq[opt] identifier[opt] enum-base[opt]\n///        enum-key attribute-specifier-seq[opt] nested-name-specifier\n///            identifier enum-base[opt]\n///\n///      enum-key: [C++11]\n///        \'enum\'\n///        \'enum\' \'class\'\n///        \'enum\' \'struct\'\n///\n///      enum-base: [C++11]\n///        \':\' type-specifier-seq\n///\n/// [C++] elaborated-type-specifier:\n/// [C++]  \'enum\' nested-name-specifier[opt] identifier\n///\nvoid Parser::ParseEnumSpecifier(SourceLocation StartLoc, DeclSpec &DS, const ParsedTemplateInfo &TemplateInfo, AccessSpecifier AS, DeclSpecContext DSC) {\n  // Parse the fixed underlying type.\n  if (Tok.is(tok::colon)) {\n    if (CanBeBitfield && !isEnumBase(CanBeOpaqueEnumDeclaration)) {\n      // Outside C++11, do not interpret the tokens as an enum-base if they do\n      // not make sense as one. In C++11, it\'s an error if this happens.\n      if (getLangOpts().CPlusPlus11)\n        Diag(Tok.getLocation(), diag::err_anonymous_enum_bitfield);"}}

[k]={{v,16095,"/// HandleMSProperty - Analyze a __delcspec(property) field of a C++ class.\n///\nMSPropertyDecl *Sema::HandleMSProperty(Scope *S, RecordDecl *Record, SourceLocation DeclStart, Declarator &D, Expr *BitWidth, InClassInitStyle InitStyle, AccessSpecifier AS, const ParsedAttr &MSPropertyAttr) {\n  if (!II) {\n    Diag(DeclStart, diag::err_anonymous_property);"}}

[k]={{q,5011,"/// BuildAnonymousStructOrUnion - Handle the declaration of an\n/// anonymous structure or union. Anonymous unions are a C++ feature\n/// (C++ [class.union]) and a C11 feature; anonymous structures\n/// are a C11 feature and GNU C++ extension.\nDecl *Sema::BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS, AccessSpecifier AS, RecordDecl *Record, const PrintingPolicy &Policy) {\n  if (getLangOpts().CPlusPlus) {\n    // C++ [class.union]p2:\n    //  The member-specification of an anonymous union shall only\n    //  define non-static data members. [Note: nested types and\n    //  functions cannot be declared within an anonymous union. ]\n    for (auto *Mem : Record->decls()) {\n      if (auto *FD = dyn_cast<FieldDecl>(Mem)) {\n      } else if (Mem->isImplicit()) {\n      } else if (isa<TagDecl>(Mem) && Mem->getDeclContext() != Record) {\n      } else if (auto *MemRecord = dyn_cast<RecordDecl>(Mem)) {\n      } else if (isa<AccessSpecDecl>(Mem)) {\n      } else if (isa<StaticAssertDecl>(Mem)) {\n      } else {\n        unsigned DK = diag::err_anonymous_record_bad_member;"}}

[k]={{q,4764,"/// We are trying to inject an anonymous member into the given scope;\n/// check if there\'s an existing declaration that can\'t be overloaded.\n///\n/// \\return true if this is a forbidden redeclaration\nstatic bool CheckAnonMemberRedeclaration(Sema &SemaRef, Scope *S, DeclContext *Owner, DeclarationName Name, SourceLocation NameLoc, bool IsUnion) {\n  SemaRef.Diag(NameLoc, diag::err_anonymous_record_member_redecl) << IsUnion << Name;"}}

[k]={{q,4970,"/// BuildAnonymousStructOrUnion - Handle the declaration of an\n/// anonymous structure or union. Anonymous unions are a C++ feature\n/// (C++ [class.union]) and a C11 feature; anonymous structures\n/// are a C11 feature and GNU C++ extension.\nDecl *Sema::BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS, AccessSpecifier AS, RecordDecl *Record, const PrintingPolicy &Policy) {\n  if (getLangOpts().CPlusPlus) {\n    // C++ [class.union]p2:\n    //  The member-specification of an anonymous union shall only\n    //  define non-static data members. [Note: nested types and\n    //  functions cannot be declared within an anonymous union. ]\n    for (auto *Mem : Record->decls()) {\n      if (auto *FD = dyn_cast<FieldDecl>(Mem)) {\n        if (FD->getAccess() != AS_public) {\n          Diag(FD->getLocation(), diag::err_anonymous_record_nonpublic_member) << Record->isUnion() << (FD->getAccess() == AS_protected);"}}

[k]={{q,5015,"/// BuildAnonymousStructOrUnion - Handle the declaration of an\n/// anonymous structure or union. Anonymous unions are a C++ feature\n/// (C++ [class.union]) and a C11 feature; anonymous structures\n/// are a C11 feature and GNU C++ extension.\nDecl *Sema::BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS, AccessSpecifier AS, RecordDecl *Record, const PrintingPolicy &Policy) {\n  if (getLangOpts().CPlusPlus) {\n    // C++ [class.union]p2:\n    //  The member-specification of an anonymous union shall only\n    //  define non-static data members. [Note: nested types and\n    //  functions cannot be declared within an anonymous union. ]\n    for (auto *Mem : Record->decls()) {\n      if (auto *FD = dyn_cast<FieldDecl>(Mem)) {\n      } else if (Mem->isImplicit()) {\n      } else if (isa<TagDecl>(Mem) && Mem->getDeclContext() != Record) {\n      } else if (auto *MemRecord = dyn_cast<RecordDecl>(Mem)) {\n      } else if (isa<AccessSpecDecl>(Mem)) {\n      } else if (isa<StaticAssertDecl>(Mem)) {\n      } else {\n        if (isa<TypeDecl>(Mem))\n        else if (isa<FunctionDecl>(Mem))\n          DK = diag::err_anonymous_record_with_function;"}}

[k]={{q,5017,"/// BuildAnonymousStructOrUnion - Handle the declaration of an\n/// anonymous structure or union. Anonymous unions are a C++ feature\n/// (C++ [class.union]) and a C11 feature; anonymous structures\n/// are a C11 feature and GNU C++ extension.\nDecl *Sema::BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS, AccessSpecifier AS, RecordDecl *Record, const PrintingPolicy &Policy) {\n  if (getLangOpts().CPlusPlus) {\n    // C++ [class.union]p2:\n    //  The member-specification of an anonymous union shall only\n    //  define non-static data members. [Note: nested types and\n    //  functions cannot be declared within an anonymous union. ]\n    for (auto *Mem : Record->decls()) {\n      if (auto *FD = dyn_cast<FieldDecl>(Mem)) {\n      } else if (Mem->isImplicit()) {\n      } else if (isa<TagDecl>(Mem) && Mem->getDeclContext() != Record) {\n      } else if (auto *MemRecord = dyn_cast<RecordDecl>(Mem)) {\n      } else if (isa<AccessSpecDecl>(Mem)) {\n      } else if (isa<StaticAssertDecl>(Mem)) {\n      } else {\n        if (isa<TypeDecl>(Mem))\n        else if (isa<FunctionDecl>(Mem))\n        else if (isa<VarDecl>(Mem))\n          DK = diag::err_anonymous_record_with_static;"}}

[k]={{q,4995,"/// BuildAnonymousStructOrUnion - Handle the declaration of an\n/// anonymous structure or union. Anonymous unions are a C++ feature\n/// (C++ [class.union]) and a C11 feature; anonymous structures\n/// are a C11 feature and GNU C++ extension.\nDecl *Sema::BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS, AccessSpecifier AS, RecordDecl *Record, const PrintingPolicy &Policy) {\n  if (getLangOpts().CPlusPlus) {\n    // C++ [class.union]p2:\n    //  The member-specification of an anonymous union shall only\n    //  define non-static data members. [Note: nested types and\n    //  functions cannot be declared within an anonymous union. ]\n    for (auto *Mem : Record->decls()) {\n      if (auto *FD = dyn_cast<FieldDecl>(Mem)) {\n      } else if (Mem->isImplicit()) {\n      } else if (isa<TagDecl>(Mem) && Mem->getDeclContext() != Record) {\n      } else if (auto *MemRecord = dyn_cast<RecordDecl>(Mem)) {\n        if (!MemRecord->isAnonymousStructOrUnion() && MemRecord->getDeclName()) {\n          // Visual C++ allows type definition in anonymous struct or union.\n          if (getLangOpts().MicrosoftExt)\n          else {\n            Diag(MemRecord->getLocation(), diag::err_anonymous_record_with_type) << Record->isUnion();"},{q,5013,"/// BuildAnonymousStructOrUnion - Handle the declaration of an\n/// anonymous structure or union. Anonymous unions are a C++ feature\n/// (C++ [class.union]) and a C11 feature; anonymous structures\n/// are a C11 feature and GNU C++ extension.\nDecl *Sema::BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS, AccessSpecifier AS, RecordDecl *Record, const PrintingPolicy &Policy) {\n  if (getLangOpts().CPlusPlus) {\n    // C++ [class.union]p2:\n    //  The member-specification of an anonymous union shall only\n    //  define non-static data members. [Note: nested types and\n    //  functions cannot be declared within an anonymous union. ]\n    for (auto *Mem : Record->decls()) {\n      if (auto *FD = dyn_cast<FieldDecl>(Mem)) {\n      } else if (Mem->isImplicit()) {\n      } else if (isa<TagDecl>(Mem) && Mem->getDeclContext() != Record) {\n      } else if (auto *MemRecord = dyn_cast<RecordDecl>(Mem)) {\n      } else if (isa<AccessSpecDecl>(Mem)) {\n      } else if (isa<StaticAssertDecl>(Mem)) {\n      } else {\n        if (isa<TypeDecl>(Mem))\n          DK = diag::err_anonymous_record_with_type;"},{q,5020,"/// BuildAnonymousStructOrUnion - Handle the declaration of an\n/// anonymous structure or union. Anonymous unions are a C++ feature\n/// (C++ [class.union]) and a C11 feature; anonymous structures\n/// are a C11 feature and GNU C++ extension.\nDecl *Sema::BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS, AccessSpecifier AS, RecordDecl *Record, const PrintingPolicy &Policy) {\n  if (getLangOpts().CPlusPlus) {\n    // C++ [class.union]p2:\n    //  The member-specification of an anonymous union shall only\n    //  define non-static data members. [Note: nested types and\n    //  functions cannot be declared within an anonymous union. ]\n    for (auto *Mem : Record->decls()) {\n      if (auto *FD = dyn_cast<FieldDecl>(Mem)) {\n      } else if (Mem->isImplicit()) {\n      } else if (isa<TagDecl>(Mem) && Mem->getDeclContext() != Record) {\n      } else if (auto *MemRecord = dyn_cast<RecordDecl>(Mem)) {\n      } else if (isa<AccessSpecDecl>(Mem)) {\n      } else if (isa<StaticAssertDecl>(Mem)) {\n      } else {\n        if (getLangOpts().MicrosoftExt && DK == diag::err_anonymous_record_with_type)"}}

[k]={{q,5037,"/// BuildAnonymousStructOrUnion - Handle the declaration of an\n/// anonymous structure or union. Anonymous unions are a C++ feature\n/// (C++ [class.union]) and a C11 feature; anonymous structures\n/// are a C11 feature and GNU C++ extension.\nDecl *Sema::BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS, AccessSpecifier AS, RecordDecl *Record, const PrintingPolicy &Policy) {\n  if (!Record->isUnion() && !Owner->isRecord()) {\n    Diag(Record->getLocation(), diag::err_anonymous_struct_not_member) << getLangOpts().CPlusPlus;"}}

[k]={{q,4923,"/// BuildAnonymousStructOrUnion - Handle the declaration of an\n/// anonymous structure or union. Anonymous unions are a C++ feature\n/// (C++ [class.union]) and a C11 feature; anonymous structures\n/// are a C11 feature and GNU C++ extension.\nDecl *Sema::BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS, AccessSpecifier AS, RecordDecl *Record, const PrintingPolicy &Policy) {\n  if (getLangOpts().CPlusPlus) {\n    if (Record->isUnion()) {\n      if (DS.getStorageClassSpec() != DeclSpec::SCS_static && (OwnerScope->isTranslationUnit() || (OwnerScope->isNamespace() && !cast<NamespaceDecl>(OwnerScope)->isAnonymousNamespace()))) {\n        Diag(Record->getLocation(), diag::err_anonymous_union_not_static) << FixItHint::CreateInsertion(Record->getLocation(), \"static \");"}}

[k]={{q,4932,"/// BuildAnonymousStructOrUnion - Handle the declaration of an\n/// anonymous structure or union. Anonymous unions are a C++ feature\n/// (C++ [class.union]) and a C11 feature; anonymous structures\n/// are a C11 feature and GNU C++ extension.\nDecl *Sema::BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS, AccessSpecifier AS, RecordDecl *Record, const PrintingPolicy &Policy) {\n  if (getLangOpts().CPlusPlus) {\n    if (Record->isUnion()) {\n      }\n      // C++ [class.union]p6:\n      //  A storage class is not allowed in a declaration of an\n      //  anonymous union in a class scope.\n      else if (DS.getStorageClassSpec() != DeclSpec::SCS_unspecified && isa<RecordDecl>(Owner)) {\n        Diag(DS.getStorageClassSpecLoc(), diag::err_anonymous_union_with_storage_spec) << FixItHint::CreateRemoval(DS.getStorageClassSpecLoc());"}}

[k]={{p,6655,"static void handleAnyX86InterruptAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n  // Interrupt handler must have void return type.\n  if (!getFunctionOrMethodResultType(D)->isVoidType()) {\n    S.Diag(getFunctionOrMethodResultSourceRange(D).getBegin(), diag::err_anyx86_interrupt_attribute) << (S.Context.getTargetInfo().getTriple().getArch() == llvm::Triple::x86 ? 0 : 1) << 0;"},{p,6661,"static void handleAnyX86InterruptAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n  if (NumParams < 1 || NumParams > 2) {\n    S.Diag(D->getBeginLoc(), diag::err_anyx86_interrupt_attribute) << (S.Context.getTargetInfo().getTriple().getArch() == llvm::Triple::x86 ? 0 : 1) << 1;"},{p,6666,"static void handleAnyX86InterruptAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n  // The first argument must be a pointer.\n  if (!getFunctionOrMethodParamType(D, 0)->isPointerType()) {\n    S.Diag(getFunctionOrMethodParamRange(D, 0).getBegin(), diag::err_anyx86_interrupt_attribute) << (S.Context.getTargetInfo().getTriple().getArch() == llvm::Triple::x86 ? 0 : 1) << 2;"},{p,6672,"static void handleAnyX86InterruptAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n  if (NumParams == 2 && (!getFunctionOrMethodParamType(D, 1)->isUnsignedIntegerType() || S.Context.getTypeSize(getFunctionOrMethodParamType(D, 1)) != TypeSize)) {\n    S.Diag(getFunctionOrMethodParamRange(D, 1).getBegin(), diag::err_anyx86_interrupt_attribute) << (S.Context.getTargetInfo().getTriple().getArch() == llvm::Triple::x86 ? 0 : 1) << 3 << S.Context.getIntTypeForBitwidth(TypeSize, /*Signed=*/false);"}}

[k]={{y,6321,"/// BuildResolvedCallExpr - Build a call to a resolved expression,\n/// i.e. an expression not of \\p OverloadTy.  The expression should\n/// unary-convert to an expression of function-pointer or\n/// block-pointer type.\n///\n/// \\param NDecl the declaration being called, if available\nExprResult Sema::BuildResolvedCallExpr(Expr *Fn, NamedDecl *NDecl, SourceLocation LParenLoc, ArrayRef<Expr *> Args, SourceLocation RParenLoc, Expr *Config, bool IsExecConfig, ADLCallKind UsesADL) {\n  // Functions with \'interrupt\' attribute cannot be called directly.\n  if (FDecl && FDecl->hasAttr<AnyX86InterruptAttr>()) {\n    Diag(Fn->getExprLoc(), diag::err_anyx86_interrupt_called);"}}

[k]={{q,13010,"ParmVarDecl *Sema::CheckParameter(DeclContext *DC, SourceLocation StartLoc, SourceLocation NameLoc, IdentifierInfo *Name, QualType T, TypeSourceInfo *TSInfo, StorageClass SC) {\n  // In ARC, infer a lifetime qualifier for appropriate parameter types.\n  if (getLangOpts().ObjCAutoRefCount && T.getObjCLifetime() == Qualifiers::OCL_None && T->isObjCLifetimeType()) {\n    // Special cases for arrays:\n    //  - if it\'s const, use __unsafe_unretained\n    //  - otherwise, it\'s an error\n    if (T->isArrayType()) {\n      if (!T.isConstQualified()) {\n        if (DelayedDiagnostics.shouldDelayDiagnostics())\n          DelayedDiagnostics.add(sema::DelayedDiagnostic::makeForbiddenType(NameLoc, diag::err_arc_array_param_no_ownership, T, false));"},{q,13012,"ParmVarDecl *Sema::CheckParameter(DeclContext *DC, SourceLocation StartLoc, SourceLocation NameLoc, IdentifierInfo *Name, QualType T, TypeSourceInfo *TSInfo, StorageClass SC) {\n  // In ARC, infer a lifetime qualifier for appropriate parameter types.\n  if (getLangOpts().ObjCAutoRefCount && T.getObjCLifetime() == Qualifiers::OCL_None && T->isObjCLifetimeType()) {\n    // Special cases for arrays:\n    //  - if it\'s const, use __unsafe_unretained\n    //  - otherwise, it\'s an error\n    if (T->isArrayType()) {\n      if (!T.isConstQualified()) {\n        if (DelayedDiagnostics.shouldDelayDiagnostics())\n        else\n          Diag(NameLoc, diag::err_arc_array_param_no_ownership) << TSInfo->getTypeLoc().getSourceRange();"},{p,8744,"/// Handle a delayed forbidden-type diagnostic.\nstatic void handleDelayedForbiddenType(Sema &S, DelayedDiagnostic &DD, Decl *D) {\n  if (S.getLangOpts().ObjCAutoRefCount)\n    if (const auto *FD = dyn_cast<FunctionDecl>(D)) {\n      if (FD->hasAttr<UnavailableAttr>() && DD.getForbiddenTypeDiagnostic() == diag::err_arc_array_param_no_ownership) {"}}

[k]={{X,186,"class PropertiesRewriter {\n  void removeAssignForDefaultStrong(PropsTy &props, SourceLocation atLoc) const {\n    for (PropsTy::iterator I = props.begin(), E = props.end(); I != E; ++I) {\n      if (I->ImplD)\n        Pass.TA.clearDiagnostic(diag::err_arc_strong_property_ownership, diag::err_arc_assign_property_ownership, diag::err_arc_inconsistent_property_ownership, I->IvarD->getLocation());"},{X,207,"class PropertiesRewriter {\n  void rewriteAssign(PropsTy &props, SourceLocation atLoc) const {\n    for (PropsTy::iterator I = props.begin(), E = props.end(); I != E; ++I) {\n      if (I->ImplD)\n        Pass.TA.clearDiagnostic(diag::err_arc_strong_property_ownership, diag::err_arc_assign_property_ownership, diag::err_arc_inconsistent_property_ownership, I->IvarD->getLocation());"},{X,225,"class PropertiesRewriter {\n  void maybeAddWeakOrUnsafeUnretainedAttr(PropsTy &props, SourceLocation atLoc) const {\n    for (PropsTy::iterator I = props.begin(), E = props.end(); I != E; ++I) {\n      if (I->ImplD) {\n        Pass.TA.clearDiagnostic(diag::err_arc_strong_property_ownership, diag::err_arc_assign_property_ownership, diag::err_arc_inconsistent_property_ownership, I->IvarD->getLocation());"},{P,641,"static void checkARCPropertyImpl(Sema &S, SourceLocation propertyImplLoc, ObjCPropertyDecl *property, ObjCIvarDecl *ivar) {\n  case Qualifiers::OCL_ExplicitNone:\n    S.Diag(ivar->getLocation(), diag::err_arc_assign_property_ownership) << property->getDeclName() << ivar->getDeclName() << ((property->getPropertyAttributesAsWritten() & ObjCPropertyAttribute::kind_assign) != 0);"}}

[k]={{s,2882,"bool Sema::CheckARMBuiltinExclusiveCall(unsigned BuiltinID, CallExpr *TheCall, unsigned MaxWidth) {\n  case Qualifiers::OCL_Autoreleasing:\n    Diag(DRE->getBeginLoc(), diag::err_arc_atomic_ownership) << ValType << PointerArg->getSourceRange();"},{s,6833,"ExprResult Sema::BuildAtomicExpr(SourceRange CallRange, SourceRange ExprRange, SourceLocation RParenLoc, MultiExprArg Args, AtomicExpr::AtomicOp Op, AtomicArgumentOrder ArgOrder) {\n  case Qualifiers::OCL_Autoreleasing:\n    Diag(ExprRange.getBegin(), diag::err_arc_atomic_ownership) << ValType << Ptr->getSourceRange();"},{s,7136,"/// We have a call to a function like __sync_fetch_and_add, which is an\n/// overloaded function based on the pointer type of its first argument.\n/// The main BuildCallExpr routines have already promoted the types of\n/// arguments because all of these calls are prototyped as void(...).\n///\n/// This function goes through and does final semantic checking for these\n/// builtins, as well as generating any warnings.\nExprResult Sema::SemaBuiltinAtomicOverloaded(ExprResult TheCallResult) {\n  case Qualifiers::OCL_Autoreleasing:\n    Diag(DRE->getBeginLoc(), diag::err_arc_atomic_ownership) << ValType << FirstArg->getSourceRange();"}}

[k]={{y,16696,"// Returns true if the capture by block was successful.\nstatic bool captureInBlock(BlockScopeInfo *BSI, ValueDecl *Var, SourceLocation Loc, const bool BuildAndDiagnose, QualType &CaptureType, QualType &DeclRefType, const bool Nested, Sema &S, bool Invalid) {\n  // Forbid the block-capture of autoreleasing variables.\n  if (!Invalid && CaptureType.getObjCLifetime() == Qualifiers::OCL_Autoreleasing) {\n    if (BuildAndDiagnose) {\n      S.Diag(Loc, diag::err_arc_autoreleasing_capture) << /*block*/ 0;"},{y,16827,"/// Capture the given variable in the lambda.\nstatic bool captureInLambda(LambdaScopeInfo *LSI, ValueDecl *Var, SourceLocation Loc, const bool BuildAndDiagnose, QualType &CaptureType, QualType &DeclRefType, const bool RefersToCapturedVariable, const Sema::TryCaptureKind Kind, SourceLocation EllipsisLoc, const bool IsTopScope, Sema &S, bool Invalid) {\n  // Compute the type of the field that will capture this variable.\n  if (ByRef) {\n  } else {\n    // Forbid the lambda copy-capture of autoreleasing variables.\n    if (!Invalid && CaptureType.getObjCLifetime() == Qualifiers::OCL_Autoreleasing) {\n      if (BuildAndDiagnose) {\n        S.Diag(Loc, diag::err_arc_autoreleasing_capture) << /*lambda*/ 1;"}}

[k]={{q,6113,"bool Sema::inferObjCARCLifetime(ValueDecl *decl) {\n  if (lifetime == Qualifiers::OCL_Autoreleasing) {\n    if (kind != -1U) {\n      Diag(decl->getLocation(), diag::err_arc_autoreleasing_var) << kind;"}}

[k]={{G,3826,"ExprResult Sema::BuildObjCBridgedCast(SourceLocation LParenLoc, ObjCBridgeCastKind Kind, SourceLocation BridgeKeywordLoc, TypeSourceInfo *TSInfo, Expr *SubExpr) {\n  if (T->isDependentType() || SubExpr->isTypeDependent()) {\n  } else if (T->isObjCARCBridgableType() && FromType->isCARCBridgableType()) {\n  } else if (T->isCARCBridgableType() && FromType->isObjCARCBridgableType()) {\n  } else {\n    Diag(LParenLoc, diag::err_arc_bridge_cast_incompatible) << FromType << T << Kind << SubExpr->getSourceRange() << TSInfo->getTypeLoc().getSourceRange();"}}

[k]={{G,3786,"ExprResult Sema::BuildObjCBridgedCast(SourceLocation LParenLoc, ObjCBridgeCastKind Kind, SourceLocation BridgeKeywordLoc, TypeSourceInfo *TSInfo, Expr *SubExpr) {\n  if (T->isDependentType() || SubExpr->isTypeDependent()) {\n  } else if (T->isObjCARCBridgableType() && FromType->isCARCBridgableType()) {\n    case OBC_BridgeRetained: {\n      Diag(BridgeKeywordLoc, diag::err_arc_bridge_cast_wrong_kind) << 2 << FromType << (T->isBlockPointerType() ? 1 : 0) << T << SubExpr->getSourceRange() << Kind;"},{G,3816,"ExprResult Sema::BuildObjCBridgedCast(SourceLocation LParenLoc, ObjCBridgeCastKind Kind, SourceLocation BridgeKeywordLoc, TypeSourceInfo *TSInfo, Expr *SubExpr) {\n  if (T->isDependentType() || SubExpr->isTypeDependent()) {\n  } else if (T->isObjCARCBridgableType() && FromType->isCARCBridgableType()) {\n  } else if (T->isCARCBridgableType() && FromType->isObjCARCBridgableType()) {\n    case OBC_BridgeTransfer: {\n      Diag(BridgeKeywordLoc, diag::err_arc_bridge_cast_wrong_kind) << (FromType->isBlockPointerType() ? 1 : 0) << FromType << 2 << T << SubExpr->getSourceRange() << Kind;"}}

[k]={{kb,2708,"/// ParseParenExpression - This parses the unit that starts with a \'(\' token,\n/// based on what is allowed by ExprType.  The actual thing parsed is returned\n/// in ExprType. If stopIfCastExpr is true, it will only return the parsed type,\n/// not the parsed cast-expression.\n///\n/// \\verbatim\n///      primary-expression: [C99 6.5.1]\n///        \'(\' expression \')\'\n/// [GNU]  \'(\' compound-statement \')\'      (if !ParenExprOnly)\n///      postfix-expression: [C99 6.5.2]\n///        \'(\' type-name \')\' \'{\' initializer-list \'}\'\n///        \'(\' type-name \')\' \'{\' initializer-list \',\' \'}\'\n///      cast-expression: [C99 6.5.4]\n///        \'(\' type-name \')\' cast-expression\n/// [ARC]  bridged-cast-expression\n/// [ARC] bridged-cast-expression:\n///        (__bridge type-name) cast-expression\n///        (__bridge_transfer type-name) cast-expression\n///        (__bridge_retained type-name) cast-expression\n///      fold-expression: [C++1z]\n///        \'(\' cast-expression fold-operator \'...\' \')\'\n///        \'(\' \'...\' fold-operator cast-expression \')\'\n///        \'(\' cast-expression fold-operator \'...\'\n///                fold-operator cast-expression \')\'\n/// [OPENMP] Array shaping operation\n///      \'(\' \'[\' expression \']\' { \'[\' expression \']\' } cast-expression\n/// \\endverbatim\nExprResult Parser::ParseParenExpression(ParenParseOption &ExprType, bool stopIfCastExpr, bool isTypeCast, ParsedType &CastTy, SourceLocation &RParenLoc) {\n  // None of these cases should fall through with an invalid Result\n  // unless they\'ve already reported an error.\n  if (ExprType >= CompoundStmt && Tok.is(tok::l_brace)) {\n  } else if (ExprType >= CompoundLiteral && BridgeCast) {\n    if (tokenKind == tok::kw___bridge)\n    else if (tokenKind == tok::kw___bridge_transfer)\n    else if (tokenKind == tok::kw___bridge_retained)\n    else {\n      if (!PP.getSourceManager().isInSystemHeader(BridgeKeywordLoc))\n        Diag(BridgeKeywordLoc, diag::err_arc_bridge_retain) << FixItHint::CreateReplacement(BridgeKeywordLoc, \"__bridge_retained\");"}}

[k]={{hb,193,"class UnbridgedCastRewriter : public RecursiveASTVisitor<UnbridgedCastRewriter> {\n  void rewriteToBridgedCast(CastExpr *E, ObjCBridgeCastKind Kind, Transaction &Trans) {\n    if (!TA.hasDiagnostic(diag::err_arc_mismatched_cast, diag::err_arc_cast_requires_bridge, E->getBeginLoc())) {"},{hb,211,"class UnbridgedCastRewriter : public RecursiveASTVisitor<UnbridgedCastRewriter> {\n  void rewriteToBridgedCast(CastExpr *E, ObjCBridgeCastKind Kind, Transaction &Trans) {\n    TA.clearDiagnostic(diag::err_arc_mismatched_cast, diag::err_arc_cast_requires_bridge, E->getBeginLoc());"},{hb,285,"class UnbridgedCastRewriter : public RecursiveASTVisitor<UnbridgedCastRewriter> {\n  void rewriteBlockCopyMacro(CastExpr *E) {\n    Pass.TA.clearDiagnostic(diag::err_arc_mismatched_cast, diag::err_arc_cast_requires_bridge, OuterRange);"},{hb,293,"class UnbridgedCastRewriter : public RecursiveASTVisitor<UnbridgedCastRewriter> {\n  void removeBlockReleaseMacro(CastExpr *E) {\n    Pass.TA.clearDiagnostic(diag::err_arc_mismatched_cast, diag::err_arc_cast_requires_bridge, OuterRange);"},{G,3195,"static void diagnoseObjCARCConversion(Sema &S, SourceRange castRange, QualType castType, ARCConversionTypeClass castACTC, Expr *castExpr, Expr *realCast, ARCConversionTypeClass exprACTC, Sema::CheckedConversionKind CCK) {\n  // Bridge from an ARC type to a CF type.\n  if (castACTC == ACTC_retainable && isAnyRetainable(exprACTC)) {\n    S.Diag(loc, diag::err_arc_cast_requires_bridge) << convKindForDiag << 2                                    // of C pointer type"},{G,3218,"static void diagnoseObjCARCConversion(Sema &S, SourceRange castRange, QualType castType, ARCConversionTypeClass castACTC, Expr *castExpr, Expr *realCast, ARCConversionTypeClass exprACTC, Sema::CheckedConversionKind CCK) {\n  // Bridge from a CF type to an ARC type.\n  if (exprACTC == ACTC_retainable && isAnyRetainable(castACTC)) {\n    S.Diag(loc, diag::err_arc_cast_requires_bridge) << convKindForDiag << unsigned(castExprType->isBlockPointerType()) // of ObjC|block type"}}

[k]={{R,1958,"ExprResult Sema::CheckObjCForCollectionOperand(SourceLocation forLoc, Expr *collection) {\n  if (iface && (getLangOpts().ObjCAutoRefCount ? RequireCompleteType(forLoc, QualType(objectType, 0), diag::err_arc_collection_forward, collection) : !isCompleteType(forLoc, QualType(objectType, 0)))) {"}}

[k]={{w,2768,"/// Check the semantics of a C-style cast operation, in C.\nvoid CastOperation::CheckCStyleCast() {\n  // ARC imposes extra restrictions on casts.\n  if (Self.getLangOpts().allowsNonTrivialObjCLifetimeQualifiers()) {\n    if (Self.getLangOpts().ObjCAutoRefCount && CastPtr) {\n    } else if (!Self.CheckObjCARCUnavailableWeakConversion(DestType, SrcType)) {\n      Self.Diag(SrcExpr.get()->getBeginLoc(), diag::err_arc_convesion_of_weak_unavailable) << 1 << SrcType << DestType << SrcExpr.get()->getSourceRange();"},{x,3811,"/// PerformImplicitConversion - Perform an implicit conversion of the\n/// expression From to the type ToType by following the standard\n/// conversion sequence SCS. Returns the converted\n/// expression. Flavor is the context in which we\'re performing this\n/// conversion, for use in error messages.\nExprResult Sema::PerformImplicitConversion(Expr *From, QualType ToType, const StandardConversionSequence &SCS, AssignmentAction Action, CheckedConversionKind CCK) {\n  case ICK_Pointer_Conversion: {\n    if (SCS.IncompatibleObjC && Action != AA_Casting) {\n    } else if (getLangOpts().allowsNonTrivialObjCLifetimeQualifiers() && !CheckObjCARCUnavailableWeakConversion(ToType, From->getType())) {\n      if (Action == AA_Initializing)\n      else\n        Diag(From->getBeginLoc(), diag::err_arc_convesion_of_weak_unavailable) << (Action == AA_Casting) << From->getType() << ToType << From->getSourceRange();"}}

[k]={{I,2021,"/// In ARC, check whether the conventional meanings of the two methods\n/// match.  If they don\'t, it\'s a hard error.\nstatic bool checkMethodFamilyMismatch(Sema &S, ObjCMethodDecl *impl, ObjCMethodDecl *decl) {\n  if (declFamily == OMF_None) {\n    errorID = diag::err_arc_gained_method_convention;"}}

[k]={{"clang/lib/ARCMigrate/TransRetainReleaseDealloc.cpp",364,"class RetainReleaseDeallocRemover : public RecursiveASTVisitor<RetainReleaseDeallocRemover> {\n  void clearDiagnostics(SourceLocation loc) const { Pass.TA.clearDiagnostic(diag::err_arc_illegal_explicit_message, diag::err_unavailable, diag::err_unavailable_message, loc); }"},{G,2622,"/// 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  // In ARC, forbid the user from sending messages to\n  // retain/release/autorelease/dealloc/retainCount explicitly.\n  if (getLangOpts().ObjCAutoRefCount) {\n    case OMF_retainCount:\n      Diag(SelLoc, diag::err_arc_illegal_explicit_message) << Sel << RecRange;"}}

[k]={{I,353,"/// ActOnStartOfObjCMethodDef - This routine sets up parameters; invisible\n/// and user declared, in the method definition\'s AST.\nvoid Sema::ActOnStartOfObjCMethodDef(Scope *FnBodyScope, Decl *D) {\n  // In ARC, disallow definition of retain/release/autorelease/retainCount\n  if (getLangOpts().ObjCAutoRefCount) {\n    case OMF_autorelease:\n      Diag(MDecl->getLocation(), diag::err_arc_illegal_method_def) << 0 << MDecl->getSelector();"},{P,1204,"/// ActOnPropertyImplDecl - This routine performs semantic checks and\n/// builds the AST node for a property implementation declaration; declared\n/// as \\@synthesize or \\@dynamic.\n///\nDecl *Sema::ActOnPropertyImplDecl(Scope *S, SourceLocation AtLoc, SourceLocation PropertyLoc, bool Synthesize, IdentifierInfo *PropertyId, IdentifierInfo *PropertyIvar, SourceLocation PropertyIvarLoc, ObjCPropertyQueryKind QueryKind) {\n  if (ObjCMethodDecl *getterMethod = property->getGetterMethodDecl()) {\n    if (getLangOpts().ObjCAutoRefCount && Synthesize)\n      case OMF_autorelease:\n        Diag(getterMethod->getLocation(), diag::err_arc_illegal_method_def) << 1 << getterMethod->getSelector();"}}

[k]={{G,1097,"ExprResult Sema::ParseObjCSelectorExpression(Selector Sel, SourceLocation AtLoc, SourceLocation SelLoc, SourceLocation LParenLoc, SourceLocation RParenLoc, bool WarnMultipleSelectors) {\n  // In ARC, forbid the user from using @selector for\n  // retain/release/autorelease/dealloc/retainCount.\n  if (getLangOpts().ObjCAutoRefCount) {\n    case OMF_dealloc:\n      Diag(AtLoc, diag::err_arc_illegal_selector) << Sel << SourceRange(LParenLoc, RParenLoc);"}}

[k]={{"clang/lib/ARCMigrate/TransGCAttrs.cpp",275,"static void checkAllAtProps(MigrationContext &MigrateCtx, SourceLocation AtLoc, IndivPropsTy &IndProps) {\n  for (unsigned i = 0, e = ATLs.size(); i != e; ++i) {\n    TA.clearDiagnostic(diag::err_arc_inconsistent_property_ownership, ATLs[i].second->getLocation());"},{X,186,"class PropertiesRewriter {\n  void removeAssignForDefaultStrong(PropsTy &props, SourceLocation atLoc) const {\n    for (PropsTy::iterator I = props.begin(), E = props.end(); I != E; ++I) {\n      if (I->ImplD)\n        Pass.TA.clearDiagnostic(diag::err_arc_strong_property_ownership, diag::err_arc_assign_property_ownership, diag::err_arc_inconsistent_property_ownership, I->IvarD->getLocation());"},{X,207,"class PropertiesRewriter {\n  void rewriteAssign(PropsTy &props, SourceLocation atLoc) const {\n    for (PropsTy::iterator I = props.begin(), E = props.end(); I != E; ++I) {\n      if (I->ImplD)\n        Pass.TA.clearDiagnostic(diag::err_arc_strong_property_ownership, diag::err_arc_assign_property_ownership, diag::err_arc_inconsistent_property_ownership, I->IvarD->getLocation());"},{X,225,"class PropertiesRewriter {\n  void maybeAddWeakOrUnsafeUnretainedAttr(PropsTy &props, SourceLocation atLoc) const {\n    for (PropsTy::iterator I = props.begin(), E = props.end(); I != E; ++I) {\n      if (I->ImplD) {\n        Pass.TA.clearDiagnostic(diag::err_arc_strong_property_ownership, diag::err_arc_assign_property_ownership, diag::err_arc_inconsistent_property_ownership, I->IvarD->getLocation());"},{P,92,"/// Check the internal consistency of a property declaration with\n/// an explicit ownership qualifier.\nstatic void checkPropertyDeclWithOwnership(Sema &S, ObjCPropertyDecl *property) {\n  S.Diag(property->getLocation(), diag::err_arc_inconsistent_property_ownership) << property->getDeclName() << expectedLifetime << propertyLifetime;"}}

[k]={{r,1822,"/// Given that we\'re building a pointer or reference to the given\nstatic QualType inferARCLifetimeForPointee(Sema &S, QualType type, SourceLocation loc, bool isReference) {\n  // If the object type is const-qualified, we can safely use\n  // __unsafe_unretained.  This is safe (because there are no read\n  // barriers), and it\'ll be safe to coerce anything but __weak* to\n  // the resulting type.\n  if (type.isConstQualified()) {\n  } else if (type->isObjCARCImplicitlyUnretainedType()) {\n  } else if (S.isUnevaluatedContext()) {\n  } else {\n    // These types can show up in private ivars in system headers, so\n    // we need this to not be an error in those cases.  Instead we\n    // want to delay.\n    if (S.DelayedDiagnostics.shouldDelayDiagnostics()) {\n      S.DelayedDiagnostics.add(sema::DelayedDiagnostic::makeForbiddenType(loc, diag::err_arc_indirect_no_ownership, type, isReference));"},{r,1824,"/// Given that we\'re building a pointer or reference to the given\nstatic QualType inferARCLifetimeForPointee(Sema &S, QualType type, SourceLocation loc, bool isReference) {\n  // If the object type is const-qualified, we can safely use\n  // __unsafe_unretained.  This is safe (because there are no read\n  // barriers), and it\'ll be safe to coerce anything but __weak* to\n  // the resulting type.\n  if (type.isConstQualified()) {\n  } else if (type->isObjCARCImplicitlyUnretainedType()) {\n  } else if (S.isUnevaluatedContext()) {\n  } else {\n    // These types can show up in private ivars in system headers, so\n    // we need this to not be an error in those cases.  Instead we\n    // want to delay.\n    if (S.DelayedDiagnostics.shouldDelayDiagnostics()) {\n    } else {\n      S.Diag(loc, diag::err_arc_indirect_no_ownership) << type << isReference;"}}

[k]={{I,103,"/// Check whether the given method, which must be in the \'init\'\n/// family, is a valid member of that family.\n///\n/// \\param receiverTypeIfCall - if null, check this as if declaring it;\n///  if non-null, check this as if making a call to it with the given\n///  receiver type\n///\n/// \\return true to indicate that there was an error and appropriate\n///  actions were taken\nbool Sema::checkInitMethod(ObjCMethodDecl *method, QualType receiverTypeIfCall) {\n  Diag(loc, diag::err_arc_init_method_unrelated_result_type);"}}

[k]={{I,2016,"/// In ARC, check whether the conventional meanings of the two methods\n/// match.  If they don\'t, it\'s a hard error.\nstatic bool checkMethodFamilyMismatch(Sema &S, ObjCMethodDecl *impl, ObjCMethodDecl *decl) {\n  unsigned errorID = diag::err_arc_lost_method_convention;"}}

[k]={{G,2481,"/// 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 (!Method) {\n    if (receiverIsIdLike || ReceiverType->isBlockPointerType() || (Receiver && Context.isObjCNSObjectType(Receiver->getType()))) {\n    } else if (ReceiverType->isObjCClassOrClassKindOfType() || ReceiverType->isObjCQualifiedClassType()) {\n    } else {\n      // We allow sending a message to a qualified ID (\"id<foo>\"), which is ok as\n      // long as one of the protocols implements the selector (if not, warn).\n      // And as long as message is not deprecated/unavailable (warn if it is).\n      if (const ObjCObjectPointerType *QIdTy = ReceiverType->getAsObjCQualifiedIdType()) {\n      } else if (const ObjCObjectPointerType *OCIType = ReceiverType->getAsObjCInterfacePointerType()) {\n        if (!Method) {\n          if (!Method && getLangOpts().ObjCAutoRefCount) {\n            Diag(SelLoc, diag::err_arc_may_not_respond) << OCIType->getPointeeType() << Sel << RecRange << SourceRange(SelectorLocs.front(), SelectorLocs.back());"}}

[k]={{G,1413,"bool Sema::CheckMessageArgumentTypes(const Expr *Receiver, QualType ReceiverType, MultiExprArg Args, Selector Sel, ArrayRef<SourceLocation> SelectorLocs, ObjCMethodDecl *Method, bool isClassMessage, bool isSuperMessage, SourceLocation lbrac, SourceLocation rbrac, SourceRange RecRange, QualType &ReturnType, ExprValueKind &VK) {\n  if (!Method) {\n    if (getLangOpts().ObjCAutoRefCount)\n      DiagID = diag::err_arc_method_not_found;"}}

[k]={{hb,193,"class UnbridgedCastRewriter : public RecursiveASTVisitor<UnbridgedCastRewriter> {\n  void rewriteToBridgedCast(CastExpr *E, ObjCBridgeCastKind Kind, Transaction &Trans) {\n    if (!TA.hasDiagnostic(diag::err_arc_mismatched_cast, diag::err_arc_cast_requires_bridge, E->getBeginLoc())) {"},{hb,211,"class UnbridgedCastRewriter : public RecursiveASTVisitor<UnbridgedCastRewriter> {\n  void rewriteToBridgedCast(CastExpr *E, ObjCBridgeCastKind Kind, Transaction &Trans) {\n    TA.clearDiagnostic(diag::err_arc_mismatched_cast, diag::err_arc_cast_requires_bridge, E->getBeginLoc());"},{hb,285,"class UnbridgedCastRewriter : public RecursiveASTVisitor<UnbridgedCastRewriter> {\n  void rewriteBlockCopyMacro(CastExpr *E) {\n    Pass.TA.clearDiagnostic(diag::err_arc_mismatched_cast, diag::err_arc_cast_requires_bridge, OuterRange);"},{hb,293,"class UnbridgedCastRewriter : public RecursiveASTVisitor<UnbridgedCastRewriter> {\n  void removeBlockReleaseMacro(CastExpr *E) {\n    Pass.TA.clearDiagnostic(diag::err_arc_mismatched_cast, diag::err_arc_cast_requires_bridge, OuterRange);"},{G,3236,"static void diagnoseObjCARCConversion(Sema &S, SourceRange castRange, QualType castType, ARCConversionTypeClass castACTC, Expr *castExpr, Expr *realCast, ARCConversionTypeClass exprACTC, Sema::CheckedConversionKind CCK) {\n  S.Diag(loc, diag::err_arc_mismatched_cast) << !convKindForDiag << srcKind << castExprType << castType << castRange << castExpr->getSourceRange();"}}

[k]={{I,2973,"void Sema::DiagnoseMultipleMethodInGlobalPool(SmallVectorImpl<ObjCMethodDecl *> &Methods, Selector Sel, SourceRange R, bool receiverIdOrClass) {\n  if (issueDiagnostic) {\n    if (issueError)\n      Diag(R.getBegin(), diag::err_arc_multiple_method_decl) << Sel << R;"}}

[k]={{x,2091,"/// Checks that a type is suitable as the allocated type\n/// in a new-expression.\nbool Sema::CheckAllocatedType(QualType AllocType, SourceLocation Loc, SourceRange R) {\n  // C++ 5.3.4p1: \"[The] type shall be a complete object type, but not an\n  //  abstract class type or array thereof.\n  if (AllocType->isFunctionType())\n  else if (AllocType->isReferenceType())\n  else if (!AllocType->isDependentType() && RequireCompleteSizedType(Loc, AllocType, diag::err_new_incomplete_or_sizeless_type, R))\n  else if (RequireNonAbstractType(Loc, AllocType, diag::err_allocation_of_abstract_type))\n  else if (AllocType->isVariablyModifiedType())\n  else if (AllocType.getAddressSpace() != LangAS::Default && !getLangOpts().OpenCLCPlusPlus)\n  else if (getLangOpts().ObjCAutoRefCount) {\n    if (const ArrayType *AT = Context.getAsArrayType(AllocType)) {\n      if (BaseAllocType.getObjCLifetime() == Qualifiers::OCL_None && BaseAllocType->isObjCLifetimeType())\n        return Diag(Loc, diag::err_arc_new_array_without_ownership) << BaseAllocType;"}}

[k]={{G,3575,"Sema::ARCConversionResult Sema::CheckObjCConversion(SourceRange castRange, QualType castType, Expr *&castExpr, CheckedConversionKind CCK, bool Diagnose, bool DiagnoseCFAudited, BinaryOperatorKind Opc) {\n  if (exprACTC == castACTC) {\n    // Check for viability and report error if casting an rvalue to a\n    // life-time qualifier.\n    if (castACTC == ACTC_retainable && (CCK == CCK_CStyleCast || CCK == CCK_OtherCast) && castType != castExprType) {\n      if (QDT != castType && QDT.getObjCLifetime() != Qualifiers::OCL_None) {\n        if (Diagnose) {\n          Diag(loc, diag::err_arc_nolifetime_behavior);"}}

[k]={{E,5049,"/// Check whether the given expression is a valid operand for an\n/// indirect copy/restore.\nstatic void checkIndirectCopyRestoreSource(Sema &S, Expr *src) {\n  S.Diag(src->getExprLoc(), diag::err_arc_nonlocal_writeback) << ((unsigned)iik - 1) // shift index into diagnostic explanations"}}

[k]={{X,226,"class PropertiesRewriter {\n  void maybeAddWeakOrUnsafeUnretainedAttr(PropsTy &props, SourceLocation atLoc) const {\n    for (PropsTy::iterator I = props.begin(), E = props.end(); I != E; ++I) {\n      if (I->ImplD) {\n        Pass.TA.clearDiagnostic(diag::err_arc_objc_property_default_assign_on_object, I->ImplD->getLocation());"},{P,1073,"/// ActOnPropertyImplDecl - This routine performs semantic checks and\n/// builds the AST node for a property implementation declaration; declared\n/// as \\@synthesize or \\@dynamic.\n///\nDecl *Sema::ActOnPropertyImplDecl(Scope *S, SourceLocation AtLoc, SourceLocation PropertyLoc, bool Synthesize, IdentifierInfo *PropertyId, IdentifierInfo *PropertyIvar, SourceLocation PropertyIvarLoc, ObjCPropertyQueryKind QueryKind) {\n  // Check that we have a valid, previously declared ivar for @synthesize\n  if (Synthesize) {\n    if (!Ivar) {\n      // In ARC, give the ivar a lifetime qualifier based on the\n      // property attributes.\n      if ((getLangOpts().ObjCAutoRefCount || isARCWeak) && !PropertyIvarType.getObjCLifetime() && PropertyIvarType->isObjCRetainableType()) {\n        // It\'s an error if we have to do this and the user didn\'t\n        // explicitly write an ownership attribute on the property.\n        if (!hasWrittenStorageAttribute(property, QueryKind) && !(kind & ObjCPropertyAttribute::kind_strong)) {\n          Diag(PropertyDiagLoc, diag::err_arc_objc_property_default_assign_on_object);"}}

[k]={{G,2643,"/// 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  // In ARC, forbid the user from sending messages to\n  // retain/release/autorelease/dealloc/retainCount explicitly.\n  if (getLangOpts().ObjCAutoRefCount) {\n    case OMF_performSelector:\n      if (Method && NumArgs >= 1) {\n        if (const auto *SelExp = dyn_cast<ObjCSelectorExpr>(Args[0]->IgnoreParens())) {\n          if (SelMethod) {\n            case OMF_init:\n              // Issue error, unless ns_returns_not_retained.\n              if (!SelMethod->hasAttr<NSReturnsNotRetainedAttr>()) {\n                Diag(SelLoc, diag::err_arc_perform_selector_retains);"},{G,2651,"/// 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  // In ARC, forbid the user from sending messages to\n  // retain/release/autorelease/dealloc/retainCount explicitly.\n  if (getLangOpts().ObjCAutoRefCount) {\n    case OMF_performSelector:\n      if (Method && NumArgs >= 1) {\n        if (const auto *SelExp = dyn_cast<ObjCSelectorExpr>(Args[0]->IgnoreParens())) {\n          if (SelMethod) {\n            default:\n              // +0 call. OK. unless ns_returns_retained.\n              if (SelMethod->hasAttr<NSReturnsRetainedAttr>()) {\n                Diag(SelLoc, diag::err_arc_perform_selector_retains);"}}

[k]={{x,6777,"ExprResult Sema::BuildPseudoDestructorExpr(Expr *Base, SourceLocation OpLoc, tok::TokenKind OpKind, const CXXScopeSpec &SS, TypeSourceInfo *ScopeTypeInfo, SourceLocation CCLoc, SourceLocation TildeLoc, PseudoDestructorTypeStorage Destructed) {\n  // C++ [expr.pseudo]p2:\n  //  [...] The cv-unqualified versions of the object type and of the type\n  //  designated by the pseudo-destructor-name shall be the same type.\n  if (DestructedTypeInfo) {\n    if (!DestructedType->isDependentType() && !ObjectType->isDependentType()) {\n      if (!Context.hasSameUnqualifiedType(DestructedType, ObjectType)) {\n      } else if (DestructedType.getObjCLifetime() != ObjectType.getObjCLifetime()) {\n        if (DestructedType.getObjCLifetime() == Qualifiers::OCL_None) {\n        } else {\n          Diag(DestructedTypeStart, diag::err_arc_pseudo_dtor_inconstant_quals) << ObjectType << DestructedType << Base->getSourceRange() << DestructedTypeInfo->getTypeLoc().getSourceRange();"}}

[k]={{G,2139,"/// \\param ReceiverType The type of the object receiving the\n/// message. When \\p ReceiverTypeInfo is non-NULL, this is the same\n/// type as that refers to. For a superclass send, this is the type of\n/// the superclass.\n///\n/// \\param SuperLoc The location of the \"super\" keyword in a\n/// superclass message.\n///\n/// \\param Sel The selector to which the message is being sent.\n///\n/// \\param Method The method that this class 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::BuildClassMessage(TypeSourceInfo *ReceiverTypeInfo, QualType ReceiverType, SourceLocation SuperLoc, Selector Sel, ObjCMethodDecl *Method, SourceLocation LBracLoc, ArrayRef<SourceLocation> SelectorLocs, SourceLocation RBracLoc, MultiExprArg ArgsIn, bool isImplicit) {\n  // Find the method we are messaging.\n  if (!Method) {\n    if (RequireCompleteType(Loc, Context.getObjCInterfaceType(Class), (getLangOpts().ObjCAutoRefCount ? diag::err_arc_receiver_forward_class : diag::warn_receiver_forward_class), TypeRange)) {"}}

[k]={{G,2461,"/// 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 (!Method) {\n    if (receiverIsIdLike || ReceiverType->isBlockPointerType() || (Receiver && Context.isObjCNSObjectType(Receiver->getType()))) {\n    } else if (ReceiverType->isObjCClassOrClassKindOfType() || ReceiverType->isObjCQualifiedClassType()) {\n    } else {\n      // We allow sending a message to a qualified ID (\"id<foo>\"), which is ok as\n      // long as one of the protocols implements the selector (if not, warn).\n      // And as long as message is not deprecated/unavailable (warn if it is).\n      if (const ObjCObjectPointerType *QIdTy = ReceiverType->getAsObjCQualifiedIdType()) {\n      } else if (const ObjCObjectPointerType *OCIType = ReceiverType->getAsObjCInterfacePointerType()) {\n        if (RequireCompleteType(Loc, OCIType->getPointeeType(), getLangOpts().ObjCAutoRefCount ? diag::err_arc_receiver_forward_instance : diag::warn_receiver_forward_instance, RecRange)) {"}}

[k]={{X,186,"class PropertiesRewriter {\n  void removeAssignForDefaultStrong(PropsTy &props, SourceLocation atLoc) const {\n    for (PropsTy::iterator I = props.begin(), E = props.end(); I != E; ++I) {\n      if (I->ImplD)\n        Pass.TA.clearDiagnostic(diag::err_arc_strong_property_ownership, diag::err_arc_assign_property_ownership, diag::err_arc_inconsistent_property_ownership, I->IvarD->getLocation());"},{X,207,"class PropertiesRewriter {\n  void rewriteAssign(PropsTy &props, SourceLocation atLoc) const {\n    for (PropsTy::iterator I = props.begin(), E = props.end(); I != E; ++I) {\n      if (I->ImplD)\n        Pass.TA.clearDiagnostic(diag::err_arc_strong_property_ownership, diag::err_arc_assign_property_ownership, diag::err_arc_inconsistent_property_ownership, I->IvarD->getLocation());"},{X,225,"class PropertiesRewriter {\n  void maybeAddWeakOrUnsafeUnretainedAttr(PropsTy &props, SourceLocation atLoc) const {\n    for (PropsTy::iterator I = props.begin(), E = props.end(); I != E; ++I) {\n      if (I->ImplD) {\n        Pass.TA.clearDiagnostic(diag::err_arc_strong_property_ownership, diag::err_arc_assign_property_ownership, diag::err_arc_inconsistent_property_ownership, I->IvarD->getLocation());"},{P,633,"static void checkARCPropertyImpl(Sema &S, SourceLocation propertyImplLoc, ObjCPropertyDecl *property, ObjCIvarDecl *ivar) {\n  case Qualifiers::OCL_Strong:\n    S.Diag(ivar->getLocation(), diag::err_arc_strong_property_ownership) << property->getDeclName() << ivar->getDeclName() << ivarLifetime;"}}

[k]={{q,6128,"bool Sema::inferObjCARCLifetime(ValueDecl *decl) {\n  if (VarDecl *var = dyn_cast<VarDecl>(decl)) {\n    // Thread-local variables cannot have lifetime.\n    if (lifetime && lifetime != Qualifiers::OCL_ExplicitNone && var->getTLSKind()) {\n      Diag(var->getLocation(), diag::err_arc_thread_ownership) << var->getType();"}}

[k]={{y,15239,"bool Sema::DiagnoseAssignmentResult(AssignConvertType ConvTy, SourceLocation Loc, QualType DstType, QualType SrcType, Expr *SrcExpr, AssignmentAction Action, bool *Complained) {\n  case IncompatiblePointer:\n    if (Action == AA_Passing_CFAudited) {\n      DiagKind = diag::err_arc_typecheck_convert_incompatible_pointer;"}}

[k]={{O,3075,"#include \"clang/Driver/Options.inc\"\n  if (Opts.ObjC) {\n    if (Args.hasArg(OPT_fobjc_gc_only))\n    else if (Args.hasArg(OPT_fobjc_gc))\n    else if (Args.hasArg(OPT_fobjc_arc)) {\n      if (!Opts.ObjCRuntime.allowsARC())\n        Diags.Report(diag::err_arc_unsupported_on_runtime);"}}

[k]={{"clang/lib/Driver/ToolChains/Darwin.cpp",2857,"void Darwin::CheckObjCARC() const {\n  getDriver().Diag(diag::err_arc_unsupported_on_toolchain);"}}

[k]={{"clang/lib/ARCMigrate/TransGCAttrs.cpp",204,"static void checkWeakGCAttrs(MigrationContext &MigrateCtx) {\n  for (unsigned i = 0, e = MigrateCtx.GCAttrs.size(); i != e; ++i) {\n    if (Attr.Kind == MigrationContext::GCAttrOccurrence::Weak) {\n      if (!canApplyWeak(MigrateCtx.Pass.Ctx, Attr.ModifiedType,\n        TA.clearDiagnostic(diag::err_arc_weak_no_runtime, diag::err_arc_unsupported_weak_class, Attr.Loc);"},{r,6245,"/// handleObjCOwnershipTypeAttr - Process an objc_ownership\n/// attribute on the specified type.\n///\n/// Returns \'true\' if the attribute was handled.\nstatic bool handleObjCOwnershipTypeAttr(TypeProcessingState &state, ParsedAttr &attr, QualType &type) {\n  // Forbid __weak for class objects marked as\n  // objc_arc_weak_reference_unavailable\n  if (lifetime == Qualifiers::OCL_Weak) {\n    if (const ObjCObjectPointerType *ObjT = type->getAs<ObjCObjectPointerType>()) {\n      if (ObjCInterfaceDecl *Class = ObjT->getInterfaceDecl()) {\n        if (Class->isArcWeakrefUnavailable()) {\n          S.Diag(AttrLoc, diag::err_arc_unsupported_weak_class);"}}

[k]={{"clang/lib/ARCMigrate/TransUnusedInitDelegate.cpp",49,"class UnusedInitRewriter : public RecursiveASTVisitor<UnusedInitRewriter> {\n  bool VisitObjCMessageExpr(ObjCMessageExpr *ME) {\n    if (ME->isDelegateInitCall() && isRemovable(ME) && Pass.TA.hasDiagnostic(diag::err_arc_unused_init_message, ME->getExprLoc())) {"},{"clang/lib/ARCMigrate/TransUnusedInitDelegate.cpp",51,"class UnusedInitRewriter : public RecursiveASTVisitor<UnusedInitRewriter> {\n  bool VisitObjCMessageExpr(ObjCMessageExpr *ME) {\n    if (ME->isDelegateInitCall() && isRemovable(ME) && Pass.TA.hasDiagnostic(diag::err_arc_unused_init_message, ME->getExprLoc())) {\n      Pass.TA.clearDiagnostic(diag::err_arc_unused_init_message, ME->getExprLoc());"},{R,311,"void Sema::DiagnoseUnusedExprResult(const Stmt *S, unsigned DiagID) {\n  if (const ObjCMessageExpr *ME = dyn_cast<ObjCMessageExpr>(E)) {\n    if (getLangOpts().ObjCAutoRefCount && ME->isDelegateInitCall()) {\n      Diag(Loc, diag::err_arc_unused_init_message) << R1;"}}

[k]={{p,8715,"/// Is the given declaration allowed to use a forbidden type?\n/// If so, it\'ll still be annotated with an attribute that makes it\n/// illegal to actually use.\nstatic bool isForbiddenTypeAllowed(Sema &S, Decl *D, const DelayedDiagnostic &diag, UnavailableAttr::ImplicitReason &reason) {\n  // Silently accept unsupported uses of __weak in both user and system\n  // declarations when it\'s been disabled, for ease of integration with\n  // -fno-objc-arc files.  We do have to take some care against attempts\n  // to define such things;  for now, we\'ve only done that for ivars\n  // and properties.\n  if ((isa<ObjCIvarDecl>(D) || isa<ObjCPropertyDecl>(D))) {\n    if (diag.getForbiddenTypeDiagnostic() == diag::err_arc_weak_disabled || diag.getForbiddenTypeDiagnostic() == diag::err_arc_weak_no_runtime) {"},{I,3103,"/// Diagnose attempts to define ARC-__weak ivars when __weak is disabled.\nstatic void DiagnoseWeakIvars(Sema &S, ObjCImplementationDecl *ID) {\n  for (auto ivar = ID->getClassInterface()->all_declared_ivar_begin(); ivar; ivar = ivar->getNextIvar()) {\n    if (ivar->getType().getObjCLifetime() == Qualifiers::OCL_Weak) {\n      if (S.getLangOpts().ObjCWeakRuntime) {\n        S.Diag(ivar->getLocation(), diag::err_arc_weak_disabled);"},{r,6230,"/// handleObjCOwnershipTypeAttr - Process an objc_ownership\n/// attribute on the specified type.\n///\n/// Returns \'true\' if the attribute was handled.\nstatic bool handleObjCOwnershipTypeAttr(TypeProcessingState &state, ParsedAttr &attr, QualType &type) {\n  // Sometimes, __weak isn\'t allowed.\n  if (lifetime == Qualifiers::OCL_Weak && !S.getLangOpts().ObjCWeak && !NonObjCPointer) {\n    unsigned diagnostic = (S.getLangOpts().ObjCWeakRuntime ? diag::err_arc_weak_disabled : diag::err_arc_weak_no_runtime);"}}

[k]={{"clang/lib/Sema/SemaExprMember.cpp",1200,"/// Look up the given member of the given non-type-dependent\n/// expression.  This can return in one of two ways:\n///  * If it returns a sentinel null-but-valid result, the caller will\n///    assume that lookup was performed and the results written into\n///    the provided structure.  It will take over from there.\n///  * Otherwise, the returned expression will be produced in place of\n///    an ordinary member expression.\n///\n/// The ObjCImpDecl bit is a gross hack that will need to be properly\n/// fixed for ObjC++.\nstatic ExprResult LookupMemberExpr(Sema &S, LookupResult &R, ExprResult &BaseExpr, bool &IsArrow, SourceLocation OpLoc, CXXScopeSpec &SS, Decl *ObjCImpDecl, bool HasTemplateArgs, SourceLocation TemplateKWLoc) {\n  // Handle ivar access to Objective-C objects.\n  if (const ObjCObjectType *OTy = BaseType->getAs<ObjCObjectType>()) {\n    if (S.getLangOpts().ObjCWeak) {\n      if (DeclRefExpr *DE = dyn_cast<DeclRefExpr>(BaseExp))\n        if (DE->getType().getObjCLifetime() == Qualifiers::OCL_Weak) {\n          S.Diag(DE->getLocation(), diag::err_arc_weak_ivar_access);"}}

[k]={{"clang/lib/ARCMigrate/TransGCAttrs.cpp",204,"static void checkWeakGCAttrs(MigrationContext &MigrateCtx) {\n  for (unsigned i = 0, e = MigrateCtx.GCAttrs.size(); i != e; ++i) {\n    if (Attr.Kind == MigrationContext::GCAttrOccurrence::Weak) {\n      if (!canApplyWeak(MigrateCtx.Pass.Ctx, Attr.ModifiedType,\n        TA.clearDiagnostic(diag::err_arc_weak_no_runtime, diag::err_arc_unsupported_weak_class, Attr.Loc);"},{p,8715,"/// Is the given declaration allowed to use a forbidden type?\n/// If so, it\'ll still be annotated with an attribute that makes it\n/// illegal to actually use.\nstatic bool isForbiddenTypeAllowed(Sema &S, Decl *D, const DelayedDiagnostic &diag, UnavailableAttr::ImplicitReason &reason) {\n  // Silently accept unsupported uses of __weak in both user and system\n  // declarations when it\'s been disabled, for ease of integration with\n  // -fno-objc-arc files.  We do have to take some care against attempts\n  // to define such things;  for now, we\'ve only done that for ivars\n  // and properties.\n  if ((isa<ObjCIvarDecl>(D) || isa<ObjCPropertyDecl>(D))) {\n    if (diag.getForbiddenTypeDiagnostic() == diag::err_arc_weak_disabled || diag.getForbiddenTypeDiagnostic() == diag::err_arc_weak_no_runtime) {"},{I,3105,"/// Diagnose attempts to define ARC-__weak ivars when __weak is disabled.\nstatic void DiagnoseWeakIvars(Sema &S, ObjCImplementationDecl *ID) {\n  for (auto ivar = ID->getClassInterface()->all_declared_ivar_begin(); ivar; ivar = ivar->getNextIvar()) {\n    if (ivar->getType().getObjCLifetime() == Qualifiers::OCL_Weak) {\n      if (S.getLangOpts().ObjCWeakRuntime) {\n      } else {\n        S.Diag(ivar->getLocation(), diag::err_arc_weak_no_runtime);"},{r,6230,"/// handleObjCOwnershipTypeAttr - Process an objc_ownership\n/// attribute on the specified type.\n///\n/// Returns \'true\' if the attribute was handled.\nstatic bool handleObjCOwnershipTypeAttr(TypeProcessingState &state, ParsedAttr &attr, QualType &type) {\n  // Sometimes, __weak isn\'t allowed.\n  if (lifetime == Qualifiers::OCL_Weak && !S.getLangOpts().ObjCWeak && !NonObjCPointer) {\n    unsigned diagnostic = (S.getLangOpts().ObjCWeakRuntime ? diag::err_arc_weak_disabled : diag::err_arc_weak_no_runtime);"}}

[k]={{y,15367,"bool Sema::DiagnoseAssignmentResult(AssignConvertType ConvTy, SourceLocation Loc, QualType DstType, QualType SrcType, Expr *SrcExpr, AssignmentAction Action, bool *Complained) {\n  case IncompatibleObjCWeakRef:\n    DiagKind = diag::err_arc_weak_unavailable_assign;"},{x,3809,"/// PerformImplicitConversion - Perform an implicit conversion of the\n/// expression From to the type ToType by following the standard\n/// conversion sequence SCS. Returns the converted\n/// expression. Flavor is the context in which we\'re performing this\n/// conversion, for use in error messages.\nExprResult Sema::PerformImplicitConversion(Expr *From, QualType ToType, const StandardConversionSequence &SCS, AssignmentAction Action, CheckedConversionKind CCK) {\n  case ICK_Pointer_Conversion: {\n    if (SCS.IncompatibleObjC && Action != AA_Casting) {\n    } else if (getLangOpts().allowsNonTrivialObjCLifetimeQualifiers() && !CheckObjCARCUnavailableWeakConversion(ToType, From->getType())) {\n      if (Action == AA_Initializing)\n        Diag(From->getBeginLoc(), diag::err_arc_weak_unavailable_assign);"}}

[k]={{P,1043,"/// ActOnPropertyImplDecl - This routine performs semantic checks and\n/// builds the AST node for a property implementation declaration; declared\n/// as \\@synthesize or \\@dynamic.\n///\nDecl *Sema::ActOnPropertyImplDecl(Scope *S, SourceLocation AtLoc, SourceLocation PropertyLoc, bool Synthesize, IdentifierInfo *PropertyId, IdentifierInfo *PropertyIvar, SourceLocation PropertyIvarLoc, ObjCPropertyQueryKind QueryKind) {\n  // Check that we have a valid, previously declared ivar for @synthesize\n  if (Synthesize) {\n    if (kind & ObjCPropertyAttribute::kind_weak) {\n      // Add GC __weak to the ivar type if the property is weak.\n      if (getLangOpts().getGC() != LangOptions::NonGC) {\n      } else {\n        if (!getLangOpts().ObjCWeak) {\n        } else {\n          if (const ObjCObjectPointerType *ObjT = PropertyIvarType->getAs<ObjCObjectPointerType>()) {\n            if (ObjI && ObjI->isArcWeakrefUnavailable()) {\n              Diag(property->getLocation(), diag::err_arc_weak_unavailable_property) << PropertyIvarType;"}}

[k]={{"clang/lib/Driver/ToolChains/Arch/ARM.cpp",210,"void arm::setArchNameInTriple(const Driver &D, const ArgList &Args, types::ID InputType, llvm::Triple &Triple) {\n  if (IsMProfile && ARMModeRequested) {\n    if (MCPU.size())\n    else\n      D.Diag(diag::err_arch_unsupported_isa) << tools::arm::getARMArch(MArch, Triple) << \"ARM\";"}}

[k]={{"clang/lib/ARCMigrate/TransAPIUses.cpp",76,"class APIChecker : public RecursiveASTVisitor<APIChecker> {\n  bool VisitObjCMessageExpr(ObjCMessageExpr *E) {\n    // NSInvocation.\n    if (E->isInstanceMessage() && E->getReceiverInterface() && E->getReceiverInterface()->getName() == \"NSInvocation\") {\n      if (pointee.getObjCLifetime() > Qualifiers::OCL_ExplicitNone)\n        Pass.TA.report(parm->getBeginLoc(), diag::err_arcmt_nsinvocation_ownership, parm->getSourceRange()) << selName;"}}

[k]={{q,13053,"ParmVarDecl *Sema::CheckParameter(DeclContext *DC, SourceLocation StartLoc, SourceLocation NameLoc, IdentifierInfo *Name, QualType T, TypeSourceInfo *TSInfo, StorageClass SC) {\n  // ISO/IEC TR 18037 S6.7.3: \"The type of an object with automatic storage\n  // duration shall not be qualified by an address-space qualifier.\"\n  // Since all parameters have automatic store duration, they can not have\n  // an address space.\n  if (T.getAddressSpace() != LangAS::Default &&\n    Diag(NameLoc, diag::err_arg_with_address_space);"},{I,4286,"/// Build a type-check a new Objective-C exception variable declaration.\nVarDecl *Sema::BuildObjCExceptionDecl(TypeSourceInfo *TInfo, QualType T, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, bool Invalid) {\n  // ISO/IEC TR 18037 S6.7.3: \"The type of an object with automatic storage\n  // duration shall not be qualified by an address-space qualifier.\"\n  // Since all parameters have automatic store duration, they can not have\n  // an address space.\n  if (T.getAddressSpace() != LangAS::Default) {\n    Diag(IdLoc, diag::err_arg_with_address_space);"}}

[k]={{s,8224,"/// SemaBuiltinConstantArgRange - Handle a check if argument ArgNum of CallExpr\n/// TheCall is a constant expression in the range [Low, High].\nbool Sema::SemaBuiltinConstantArgRange(CallExpr *TheCall, int ArgNum, int Low, int High, bool RangeIsError) {\n  if (Result.getSExtValue() < Low || Result.getSExtValue() > High) {\n    if (RangeIsError)\n      return Diag(TheCall->getBeginLoc(), diag::err_argument_invalid_range) << toString(Result, 10) << Low << High << Arg->getSourceRange();"}}

[k]={{s,3959,"/// Returns true if the argument consists of one contiguous run of 1s with any\n/// number of 0s on either side. The 1s are allowed to wrap from LSB to MSB, so\n/// 0x000FFF0, 0x0000FFFF, 0xFF0000FF, 0x0 are all runs. 0x0F0F0000 is not,\n/// since all 1s are not contiguous.\nbool Sema::SemaValueIsRunOfOnes(CallExpr *TheCall, unsigned ArgNum) {\n  return Diag(TheCall->getBeginLoc(), diag::err_argument_not_contiguous_bit_field) << ArgNum << Arg->getSourceRange();"}}

[k]={{s,8249,"/// SemaBuiltinConstantArgMultiple - Handle a check if argument ArgNum of CallExpr\n/// TheCall is a constant expression is a multiple of Num..\nbool Sema::SemaBuiltinConstantArgMultiple(CallExpr *TheCall, int ArgNum, unsigned Num) {\n  if (Result.getSExtValue() % Num != 0)\n    return Diag(TheCall->getBeginLoc(), diag::err_argument_not_multiple) << Num << Arg->getSourceRange();"}}

[k]={{s,8273,"/// SemaBuiltinConstantArgPower2 - Check if argument ArgNum of TheCall is a\n/// constant expression representing a power of 2.\nbool Sema::SemaBuiltinConstantArgPower2(CallExpr *TheCall, int ArgNum) {\n  return Diag(TheCall->getBeginLoc(), diag::err_argument_not_power_of_2) << Arg->getSourceRange();"}}

[k]={{s,8320,"/// SemaBuiltinConstantArgShiftedByte - Check if argument ArgNum of TheCall is\n/// a constant expression representing an arbitrary byte value shifted left by\n/// a multiple of 8 bits.\nbool Sema::SemaBuiltinConstantArgShiftedByte(CallExpr *TheCall, int ArgNum, unsigned ArgBits) {\n  return Diag(TheCall->getBeginLoc(), diag::err_argument_not_shifted_byte) << Arg->getSourceRange();"}}

[k]={{s,8348,"/// SemaBuiltinConstantArgShiftedByteOr0xFF - Check if argument ArgNum of\n/// TheCall is a constant expression representing either a shifted byte value,\n/// or a value of the form 0x??FF (i.e. a member of the arithmetic progression\n/// 0x00FF, 0x01FF, ..., 0xFFFF). This strange range check is needed for some\n/// Arm MVE intrinsics.\nbool Sema::SemaBuiltinConstantArgShiftedByteOrXXFF(CallExpr *TheCall, int ArgNum, unsigned ArgBits) {\n  return Diag(TheCall->getBeginLoc(), diag::err_argument_not_shifted_byte_or_xxff) << Arg->getSourceRange();"}}

[k]={{D,1420,"void Parser::ParseSwiftNewTypeAttribute(IdentifierInfo &AttrName, SourceLocation AttrNameLoc, ParsedAttributes &Attrs, SourceLocation *EndLoc, IdentifierInfo *ScopeName, SourceLocation ScopeLoc, ParsedAttr::Form Form) {\n  if (Tok.is(tok::r_paren)) {\n    Diag(Tok.getLocation(), diag::err_argument_required_after_attribute);"},{D,6343,"/// ParseFunctionDeclarator - We are after the identifier and have parsed the\n/// declarator D up to a paren, which indicates that we are parsing function\n/// arguments.\n///\n/// If FirstArgAttrs is non-null, then the caller parsed those attributes\n/// immediately after the open paren - they will be applied to the DeclSpec\n/// of the first parameter.\n///\n/// If RequiresArg is true, then the first argument of the function is required\n/// to be present and required to not be an identifier list.\n///\n/// For C++, after the parameter-list, it also parses the cv-qualifier-seq[opt],\n/// (C++11) ref-qualifier[opt], exception-specification[opt],\n/// (C++11) attribute-specifier-seq[opt], (C++11) trailing-return-type[opt] and\n/// (C++2a) the trailing requires-clause.\n///\n/// [C++11] exception-specification:\n///          dynamic-exception-specification\n///          noexcept-specification\n///\nvoid Parser::ParseFunctionDeclarator(Declarator &D, ParsedAttributes &FirstArgAttrs, BalancedDelimiterTracker &Tracker, bool IsAmbiguous, bool RequiresArg) {\n  if (isFunctionDeclaratorIdentifierList()) {\n    if (RequiresArg)\n      Diag(Tok, diag::err_argument_required_after_attribute);"},{D,6360,"/// ParseFunctionDeclarator - We are after the identifier and have parsed the\n/// declarator D up to a paren, which indicates that we are parsing function\n/// arguments.\n///\n/// If FirstArgAttrs is non-null, then the caller parsed those attributes\n/// immediately after the open paren - they will be applied to the DeclSpec\n/// of the first parameter.\n///\n/// If RequiresArg is true, then the first argument of the function is required\n/// to be present and required to not be an identifier list.\n///\n/// For C++, after the parameter-list, it also parses the cv-qualifier-seq[opt],\n/// (C++11) ref-qualifier[opt], exception-specification[opt],\n/// (C++11) attribute-specifier-seq[opt], (C++11) trailing-return-type[opt] and\n/// (C++2a) the trailing requires-clause.\n///\n/// [C++11] exception-specification:\n///          dynamic-exception-specification\n///          noexcept-specification\n///\nvoid Parser::ParseFunctionDeclarator(Declarator &D, ParsedAttributes &FirstArgAttrs, BalancedDelimiterTracker &Tracker, bool IsAmbiguous, bool RequiresArg) {\n  if (isFunctionDeclaratorIdentifierList()) {\n  } else {\n    if (Tok.isNot(tok::r_paren))\n    else if (RequiresArg)\n      Diag(Tok, diag::err_argument_required_after_attribute);"}}

[k]={{y,4298,"/// Diagnose if arithmetic on the given ObjC pointer is illegal.\n///\n/// \\return true on error\nstatic bool checkArithmeticOnObjCPointer(Sema &S, SourceLocation opLoc, Expr *op) {\n  S.Diag(opLoc, diag::err_arithmetic_nonfragile_interface) << op->getType()->castAs<ObjCObjectPointerType>()->getPointeeType() << op->getSourceRange();"}}

[k]={{s,2805,"bool Sema::CheckARMCoprocessorImmediate(const TargetInfo &TI, const Expr *CoprocArg, bool WantCDE) {\n  if (IsCDECoproc != WantCDE)\n    return Diag(CoprocArg->getBeginLoc(), diag::err_arm_invalid_coproc) << (int)CoprocNo << (int)WantCDE << CoprocArg->getSourceRange();"}}

[k]={{s,8510,"/// SemaBuiltinARMSpecialReg - Handle a check if argument ArgNum of CallExpr\n/// TheCall is an ARM/AArch64 special register string literal.\nbool Sema::SemaBuiltinARMSpecialReg(unsigned BuiltinID, CallExpr *TheCall, int ArgNum, unsigned ExpectedFieldNum, bool AllowName) {\n  if (Fields.size() != ExpectedFieldNum && !(AllowName && Fields.size() == 1))\n    return Diag(TheCall->getBeginLoc(), diag::err_arm_invalid_specialreg) << Arg->getSourceRange();"},{s,8549,"/// SemaBuiltinARMSpecialReg - Handle a check if argument ArgNum of CallExpr\n/// TheCall is an ARM/AArch64 special register string literal.\nbool Sema::SemaBuiltinARMSpecialReg(unsigned BuiltinID, CallExpr *TheCall, int ArgNum, unsigned ExpectedFieldNum, bool AllowName) {\n  // If the string is the name of a register then we cannot check that it is\n  // valid here but if the string is of one the forms described in ACLE then we\n  // can check that the supplied fields are integers and within the valid\n  // ranges.\n  if (Fields.size() > 1) {\n    if (!ValidString)\n      return Diag(TheCall->getBeginLoc(), diag::err_arm_invalid_specialreg) << Arg->getSourceRange();"}}

[k]={{E,2828,"ExprResult Sema::ActOnDesignatedInitializer(Designation &Desig, SourceLocation EqualOrColonLoc, bool GNUSyntax, ExprResult Init) {\n  // Build designators and check array designator expressions.\n  for (unsigned Idx = 0; Idx < Desig.getNumDesignators(); ++Idx) {\n    if (D.isFieldDesignator()) {\n    } else if (D.isArrayDesignator()) {\n    } else if (D.isArrayRangeDesignator()) {\n      if (!StartIndex || !EndIndex)\n      else {\n        if (!StartDependent && !EndDependent && EndValue < StartValue) {\n          Diag(D.getEllipsisLoc(), diag::err_array_designator_empty_range) << toString(StartValue, 10) << toString(EndValue, 10) << StartIndex->getSourceRange() << EndIndex->getSourceRange();"}}

[k]={{E,2774,"/// Check that the given Index expression is a valid array designator\n/// value. This is essentially just a wrapper around\n/// VerifyIntegerConstantExpression that also checks for negative values\n/// and produces a reasonable diagnostic if there is a\n/// failure. Returns the index expression, possibly with an implicit cast\n/// added, on success.  If everything went okay, Value will receive the\n/// value of the constant expression.\nstatic ExprResult CheckArrayDesignatorExpr(Sema &S, Expr *Index, llvm::APSInt &Value) {\n  if (Value.isSigned() && Value.isNegative())\n    return S.Diag(Loc, diag::err_array_designator_negative) << toString(Value, 10) << Index->getSourceRange();"}}

[k]={{E,2483,"/// Check the well-formedness of a C99 designated initializer.\n///\n/// Determines whether the designated initializer @p DIE, which\n/// resides at the given @p Index within the initializer list @p\n/// IList, is well-formed for a current object of type @p DeclType\n/// (C99 6.7.8). The actual subobject that this designator refers to\n/// within the current subobject is returned in either\n/// @p NextField or @p NextElementIndex (whichever is appropriate).\n///\n/// @param IList  The initializer list in which this designated\n/// initializer occurs.\n///\n/// @param DIE The designated initializer expression.\n///\n/// @param DesigIdx  The index of the current designator.\n///\n/// @param CurrentObjectType The type of the \"current object\" (C99 6.7.8p17),\n/// into which the designation in @p DIE should refer.\n///\n/// @param NextField  If non-NULL and the first designator in @p DIE is\n/// a field, this will be set to the field declaration corresponding\n/// to the field named by the designator. On input, this is expected to be\n/// the next field that would be initialized in the absence of designation,\n/// if the complete object being initialized is a struct.\n///\n/// @param NextElementIndex  If non-NULL and the first designator in @p\n/// DIE is an array designator or GNU array-range designator, this\n/// will be set to the last index initialized by this designator.\n///\n/// @param Index  Index into @p IList where the designated initializer\n/// @p DIE occurs.\n///\n/// @param StructuredList  The initializer list expression that\n/// describes all of the subobject initializers in the order they\'ll\n/// actually be initialized.\n///\n/// @returns true if there was an error, false otherwise.\nbool InitListChecker::CheckDesignatedInitializer(const InitializedEntity &Entity, InitListExpr *IList, DesignatedInitExpr *DIE, unsigned DesigIdx, QualType &CurrentObjectType, RecordDecl::field_iterator *NextField, llvm::APSInt *NextElementIndex, unsigned &Index, InitListExpr *StructuredList, unsigned &StructuredIndex, bool FinishSubobjectInit, bool TopLevelObject) {\n  if (!AT) {\n    if (!VerifyOnly)\n      SemaRef.Diag(D->getLBracketLoc(), diag::err_array_designator_non_array) << CurrentObjectType;"}}

[k]={{E,2518,"/// Check the well-formedness of a C99 designated initializer.\n///\n/// Determines whether the designated initializer @p DIE, which\n/// resides at the given @p Index within the initializer list @p\n/// IList, is well-formed for a current object of type @p DeclType\n/// (C99 6.7.8). The actual subobject that this designator refers to\n/// within the current subobject is returned in either\n/// @p NextField or @p NextElementIndex (whichever is appropriate).\n///\n/// @param IList  The initializer list in which this designated\n/// initializer occurs.\n///\n/// @param DIE The designated initializer expression.\n///\n/// @param DesigIdx  The index of the current designator.\n///\n/// @param CurrentObjectType The type of the \"current object\" (C99 6.7.8p17),\n/// into which the designation in @p DIE should refer.\n///\n/// @param NextField  If non-NULL and the first designator in @p DIE is\n/// a field, this will be set to the field declaration corresponding\n/// to the field named by the designator. On input, this is expected to be\n/// the next field that would be initialized in the absence of designation,\n/// if the complete object being initialized is a struct.\n///\n/// @param NextElementIndex  If non-NULL and the first designator in @p\n/// DIE is an array designator or GNU array-range designator, this\n/// will be set to the last index initialized by this designator.\n///\n/// @param Index  Index into @p IList where the designated initializer\n/// @p DIE occurs.\n///\n/// @param StructuredList  The initializer list expression that\n/// describes all of the subobject initializers in the order they\'ll\n/// actually be initialized.\n///\n/// @returns true if there was an error, false otherwise.\nbool InitListChecker::CheckDesignatedInitializer(const InitializedEntity &Entity, InitListExpr *IList, DesignatedInitExpr *DIE, unsigned DesigIdx, QualType &CurrentObjectType, RecordDecl::field_iterator *NextField, llvm::APSInt *NextElementIndex, unsigned &Index, InitListExpr *StructuredList, unsigned &StructuredIndex, bool FinishSubobjectInit, bool TopLevelObject) {\n  if (isa<ConstantArrayType>(AT)) {\n    if (DesignatedEndIndex >= MaxElements) {\n      if (!VerifyOnly)\n        SemaRef.Diag(IndexExpr->getBeginLoc(), diag::err_array_designator_too_large) << toString(DesignatedEndIndex, 10) << toString(MaxElements, 10) << IndexExpr->getSourceRange();"}}

[k]={{r,2156,"bool Sema::checkArrayElementAlignment(QualType EltTy, SourceLocation Loc) {\n  Diag(Loc, diag::err_array_element_alignment) << EltTy << Size.getQuantity() << Alignment.getQuantity();"}}

[k]={{q,12048,"void Sema::ActOnUninitializedDecl(Decl *RealDecl) {\n  if (VarDecl *Var = dyn_cast<VarDecl>(RealDecl)) {\n    case VarDecl::TentativeDefinition:\n      // File scope. C99 6.9.2p2: A declaration of an identifier for an\n      // object that has file scope without an initializer, and without a\n      // storage-class specifier or with the storage-class specifier \"static\",\n      // constitutes a tentative definition. Note: A tentative definition with\n      // external linkage is valid (C99 6.2.2p5).\n      if (!Var->isInvalidDecl()) {\n        if (const IncompleteArrayType *ArrayT = Context.getAsIncompleteArrayType(Type)) {\n          if (RequireCompleteSizedType(Var->getLocation(), ArrayT->getElementType(), diag::err_array_incomplete_or_sizeless_type))"},{y,6598,"ExprResult Sema::BuildCompoundLiteralExpr(SourceLocation LParenLoc, TypeSourceInfo *TInfo, SourceLocation RParenLoc, Expr *LiteralExpr) {\n  if (literalType->isArrayType()) {\n    if (RequireCompleteSizedType(LParenLoc, Context.getBaseElementType(literalType), diag::err_array_incomplete_or_sizeless_type, SourceRange(LParenLoc, LiteralExpr->getSourceRange().getEnd())))"},{r,2196,"/// Build an array type.\n///\n/// \\param T The type of each element in the array.\n///\n/// \\param ASM C99 array size modifier (e.g., \'*\', \'static\').\n///\n/// \\param ArraySize Expression describing the size of the array.\n///\n/// \\param Brackets The range from the opening \'[\' to the closing \']\'.\n///\n/// \\param Entity The name of the entity that involves the array\n/// type, if known.\n///\n/// \\returns A suitable array type, if there are no errors. Otherwise,\n/// returns a NULL type.\nQualType Sema::BuildArrayType(QualType T, ArrayType::ArraySizeModifier ASM, Expr *ArraySize, unsigned Quals, SourceRange Brackets, DeclarationName Entity) {\n  if (getLangOpts().CPlusPlus) {\n    if (T->isVoidType() || T->isIncompleteArrayType()) {\n      Diag(Loc, diag::err_array_incomplete_or_sizeless_type) << 0 << T;"},{r,2213,"/// Build an array type.\n///\n/// \\param T The type of each element in the array.\n///\n/// \\param ASM C99 array size modifier (e.g., \'*\', \'static\').\n///\n/// \\param ArraySize Expression describing the size of the array.\n///\n/// \\param Brackets The range from the opening \'[\' to the closing \']\'.\n///\n/// \\param Entity The name of the entity that involves the array\n/// type, if known.\n///\n/// \\returns A suitable array type, if there are no errors. Otherwise,\n/// returns a NULL type.\nQualType Sema::BuildArrayType(QualType T, ArrayType::ArraySizeModifier ASM, Expr *ArraySize, unsigned Quals, SourceRange Brackets, DeclarationName Entity) {\n  if (getLangOpts().CPlusPlus) {\n  } else {\n    if (!T.isWebAssemblyReferenceType() && RequireCompleteSizedType(Loc, T, diag::err_array_incomplete_or_sizeless_type))"},{r,2227,"/// Build an array type.\n///\n/// \\param T The type of each element in the array.\n///\n/// \\param ASM C99 array size modifier (e.g., \'*\', \'static\').\n///\n/// \\param ArraySize Expression describing the size of the array.\n///\n/// \\param Brackets The range from the opening \'[\' to the closing \']\'.\n///\n/// \\param Entity The name of the entity that involves the array\n/// type, if known.\n///\n/// \\returns A suitable array type, if there are no errors. Otherwise,\n/// returns a NULL type.\nQualType Sema::BuildArrayType(QualType T, ArrayType::ArraySizeModifier ASM, Expr *ArraySize, unsigned Quals, SourceRange Brackets, DeclarationName Entity) {\n  if (T->isSizelessType() && !T.isWebAssemblyReferenceType()) {\n    Diag(Loc, diag::err_array_incomplete_or_sizeless_type) << 1 << T;"}}

[k]={{E,8149,"bool InitializationSequence::Diagnose(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, ArrayRef<Expr *> Args) {\n  case FK_NonConstantArrayInit:\n    S.Diag(Kind.getLocation(), (Failure == FK_ArrayTypeMismatch ? diag::err_array_init_different_type : diag::err_array_init_non_constant_array)) << DestType.getNonReferenceType() << OnlyArg->getType() << Args[0]->getSourceRange();"}}

[k]={{E,8138,"bool InitializationSequence::Diagnose(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, ArrayRef<Expr *> Args) {\n  case FK_IncompatWideStringIntoWideChar:\n    S.Diag(Kind.getLocation(), diag::err_array_init_incompat_wide_string_into_wchar);"}}

[k]={{E,8132,"bool InitializationSequence::Diagnose(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, ArrayRef<Expr *> Args) {\n  case FK_NarrowStringIntoWideCharArray:\n    S.Diag(Kind.getLocation(), diag::err_array_init_narrow_string_into_wchar);"}}

[k]={{E,8149,"bool InitializationSequence::Diagnose(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, ArrayRef<Expr *> Args) {\n  case FK_NonConstantArrayInit:\n    S.Diag(Kind.getLocation(), (Failure == FK_ArrayTypeMismatch ? diag::err_array_init_different_type : diag::err_array_init_non_constant_array)) << DestType.getNonReferenceType() << OnlyArg->getType() << Args[0]->getSourceRange();"}}

[k]={{E,8123,"bool InitializationSequence::Diagnose(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, ArrayRef<Expr *> Args) {\n  case FK_ArrayNeedsInitList:\n    S.Diag(Kind.getLocation(), diag::err_array_init_not_init_list) << 0;"},{E,8126,"bool InitializationSequence::Diagnose(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, ArrayRef<Expr *> Args) {\n  case FK_ArrayNeedsInitListOrStringLiteral:\n    S.Diag(Kind.getLocation(), diag::err_array_init_not_init_list) << 1;"},{E,8129,"bool InitializationSequence::Diagnose(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, ArrayRef<Expr *> Args) {\n  case FK_ArrayNeedsInitListOrWideStringLiteral:\n    S.Diag(Kind.getLocation(), diag::err_array_init_not_init_list) << 2;"}}

[k]={{E,8141,"bool InitializationSequence::Diagnose(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, ArrayRef<Expr *> Args) {\n  case FK_PlainStringIntoUTF8Char:\n    S.Diag(Kind.getLocation(), diag::err_array_init_plain_string_into_char8_t);"}}

[k]={{E,8145,"bool InitializationSequence::Diagnose(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, ArrayRef<Expr *> Args) {\n  case FK_UTF8StringIntoPlainChar:\n    S.Diag(Kind.getLocation(), diag::err_array_init_utf8_string_into_char) << DestType->isSignedIntegerType() << S.getLangOpts().CPlusPlus20;"}}

[k]={{E,8135,"bool InitializationSequence::Diagnose(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, ArrayRef<Expr *> Args) {\n  case FK_WideStringIntoCharArray:\n    S.Diag(Kind.getLocation(), diag::err_array_init_wide_string_into_char);"}}

[k]={{x,1638,"/// Parsed a C++ \'new\' expression (C++ 5.3.4).\n///\n/// E.g.:\n/// @code new (memory) int[size][4] @endcode\n/// or\n/// @code ::new Foo(23, \"hello\") @endcode\n///\n/// \\param StartLoc The first location of the expression.\n/// \\param UseGlobal True if \'new\' was prefixed with \'::\'.\n/// \\param PlacementLParen Opening paren of the placement arguments.\n/// \\param PlacementArgs Placement new arguments.\n/// \\param PlacementRParen Closing paren of the placement arguments.\n/// \\param TypeIdParens If the type is in parens, the source range.\n/// \\param D The type to be allocated, as well as array dimensions.\n/// \\param Initializer The initializing expression or initializer-list, or null\n///  if there is none.\nExprResult Sema::ActOnCXXNew(SourceLocation StartLoc, bool UseGlobal, SourceLocation PlacementLParen, MultiExprArg PlacementArgs, SourceLocation PlacementRParen, SourceRange TypeIdParens, Declarator &D, Expr *Initializer) {\n  // If the specified type is an array, unwrap it and save the expression.\n  if (D.getNumTypeObjects() > 0 && D.getTypeObject(0).Kind == DeclaratorChunk::Array) {\n    if (!Chunk.Arr.NumElts && !Initializer)\n      return ExprError(Diag(Chunk.Loc, diag::err_array_new_needs_size) << D.getSourceRange());"}}

[k]={{v,5183,"#include \"clang/AST/TypeLocNodes.def\"\n  CheckPolymorphic(PointerTypeLoc) CheckPolymorphic(ReferenceTypeLoc) CheckPolymorphic(MemberPointerTypeLoc) CheckPolymorphic(BlockPointerTypeLoc) CheckPolymorphic(AtomicTypeLoc)\n    // It matched; do some magic.\n    // FIXME: These should be at most warnings. See P0929R2, CWG1640, CWG1646.\n    if (Sel == Sema::AbstractArrayType) {\n      Info.S.Diag(Ctx->getLocation(), diag::err_array_of_abstract_type) << T << TL.getSourceRange();"},{r,2200,"/// Build an array type.\n///\n/// \\param T The type of each element in the array.\n///\n/// \\param ASM C99 array size modifier (e.g., \'*\', \'static\').\n///\n/// \\param ArraySize Expression describing the size of the array.\n///\n/// \\param Brackets The range from the opening \'[\' to the closing \']\'.\n///\n/// \\param Entity The name of the entity that involves the array\n/// type, if known.\n///\n/// \\returns A suitable array type, if there are no errors. Otherwise,\n/// returns a NULL type.\nQualType Sema::BuildArrayType(QualType T, ArrayType::ArraySizeModifier ASM, Expr *ArraySize, unsigned Quals, SourceRange Brackets, DeclarationName Entity) {\n  if (getLangOpts().CPlusPlus) {\n    if (RequireNonAbstractType(Brackets.getBegin(), T, diag::err_array_of_abstract_type))"}}

[k]={{"clang/lib/Sema/SemaOpenMP.cpp",17457,"class MapBaseChecker final : public StmtVisitor<MapBaseChecker, bool> {\n  bool VisitOMPArraySectionExpr(OMPArraySectionExpr *OASE) {\n    if (AllowWholeSizeArraySection) {\n    } else if (DKind == OMPD_target_update && SemaRef.getLangOpts().OpenMP >= 50) {\n    } else if (AllowUnitySizeArraySection && NotUnity) {\n      SemaRef.Diag(ELoc, diag::err_array_section_does_not_specify_contiguous_storage) << OASE->getSourceRange();"}}

[k]={{"clang/lib/Sema/SemaOpenMP.cpp",17568,"/// Return the expression of the base of the mappable expression or null if it\n/// cannot be determined and do all the necessary checks to see if the\n/// expression is valid as a standalone mappable expression. In the process,\n/// record all the components of the expression.\nstatic const Expr *checkMapClauseExpressionBase(Sema &SemaRef, Expr *E, OMPClauseMappableExprCommon::MappableExprComponentList &CurComponents, OpenMPClauseKind CKind, OpenMPDirectiveKind DKind, bool NoDiagnose) {\n  if (Checker.Visit(E->IgnoreParens())) {\n    // Check if the highest dimension array section has length specified\n    if (SemaRef.getLangOpts().OpenMP >= 50 && !CurComponents.empty() && (CKind == OMPC_to || CKind == OMPC_from)) {\n      for (; CI != CE; ++CI) {\n        SemaRef.Diag(ELoc, diag::err_array_section_does_not_specify_length) << ERange;"}}

[k]={{x,1862,"ExprResult Sema::BuildCXXNew(SourceRange Range, bool UseGlobal, SourceLocation PlacementLParen, MultiExprArg PlacementArgs, SourceLocation PlacementRParen, SourceRange TypeIdParens, QualType AllocType, TypeSourceInfo *AllocTypeInfo, std::optional<Expr *> ArraySize, SourceRange DirectInitRange, Expr *Initializer) {\n  if (ArraySize && *ArraySize && !(*ArraySize)->isTypeDependent()) {\n    if (getLangOpts().CPlusPlus14) {\n    } else {\n      class SizeConvertDiagnoser : public ICEConvertDiagnoser {\n        SemaDiagnosticBuilder diagnoseAmbiguous(Sema &S, SourceLocation Loc, QualType T) override { return S.Diag(Loc, diag::err_array_size_ambiguous_conversion) << T; }"}}

[k]={{x,1858,"ExprResult Sema::BuildCXXNew(SourceRange Range, bool UseGlobal, SourceLocation PlacementLParen, MultiExprArg PlacementArgs, SourceLocation PlacementRParen, SourceRange TypeIdParens, QualType AllocType, TypeSourceInfo *AllocTypeInfo, std::optional<Expr *> ArraySize, SourceRange DirectInitRange, Expr *Initializer) {\n  if (ArraySize && *ArraySize && !(*ArraySize)->isTypeDependent()) {\n    if (getLangOpts().CPlusPlus14) {\n    } else {\n      class SizeConvertDiagnoser : public ICEConvertDiagnoser {\n        SemaDiagnosticBuilder diagnoseExplicitConv(Sema &S, SourceLocation Loc, QualType T, QualType ConvTy) override { return S.Diag(Loc, diag::err_array_size_explicit_conversion) << T << ConvTy; }"}}

[k]={{x,1856,"ExprResult Sema::BuildCXXNew(SourceRange Range, bool UseGlobal, SourceLocation PlacementLParen, MultiExprArg PlacementArgs, SourceLocation PlacementRParen, SourceRange TypeIdParens, QualType AllocType, TypeSourceInfo *AllocTypeInfo, std::optional<Expr *> ArraySize, SourceRange DirectInitRange, Expr *Initializer) {\n  if (ArraySize && *ArraySize && !(*ArraySize)->isTypeDependent()) {\n    if (getLangOpts().CPlusPlus14) {\n    } else {\n      class SizeConvertDiagnoser : public ICEConvertDiagnoser {\n        SemaDiagnosticBuilder diagnoseIncomplete(Sema &S, SourceLocation Loc, QualType T) override { return S.Diag(Loc, diag::err_array_size_incomplete_type) << T << ArraySize->getSourceRange(); }"}}

[k]={{r,2129,"/// Check whether the specified array bound can be evaluated using the relevant\n/// language rules. If so, returns the possibly-converted expression and sets\n/// SizeVal to the size. If not, but the expression might be a VLA bound,\n/// returns ExprResult(). Otherwise, produces a diagnostic and returns\n/// ExprError().\nstatic ExprResult checkArraySize(Sema &S, Expr *&ArraySize, llvm::APSInt &SizeVal, unsigned VLADiag, bool VLAIsError) {\n  // If the size is an ICE, it certainly isn\'t a VLA. If we\'re in a GNU mode\n  // (like gnu99, but not c99) accept any evaluatable value as an extension.\n  class VLADiagnoser : public Sema::VerifyICEDiagnoser {\n    Sema::SemaDiagnosticBuilder diagnoseNotICEType(Sema &S, SourceLocation Loc, QualType T) override { return S.Diag(Loc, diag::err_array_size_non_int) << T; }"},{r,2269,"/// Build an array type.\n///\n/// \\param T The type of each element in the array.\n///\n/// \\param ASM C99 array size modifier (e.g., \'*\', \'static\').\n///\n/// \\param ArraySize Expression describing the size of the array.\n///\n/// \\param Brackets The range from the opening \'[\' to the closing \']\'.\n///\n/// \\param Entity The name of the entity that involves the array\n/// type, if known.\n///\n/// \\returns A suitable array type, if there are no errors. Otherwise,\n/// returns a NULL type.\nQualType Sema::BuildArrayType(QualType T, ArrayType::ArraySizeModifier ASM, Expr *ArraySize, unsigned Quals, SourceRange Brackets, DeclarationName Entity) {\n  // C99 6.7.5.2p1: The size expression shall have integer type.\n  // C++11 allows contextual conversions to such types.\n  if (!getLangOpts().CPlusPlus11 && ArraySize && !ArraySize->isTypeDependent() && !ArraySize->getType()->isIntegralOrUnscopedEnumerationType()) {\n    Diag(ArraySize->getBeginLoc(), diag::err_array_size_non_int) << ArraySize->getType() << ArraySize->getSourceRange();"}}

[k]={{x,1854,"ExprResult Sema::BuildCXXNew(SourceRange Range, bool UseGlobal, SourceLocation PlacementLParen, MultiExprArg PlacementArgs, SourceLocation PlacementRParen, SourceRange TypeIdParens, QualType AllocType, TypeSourceInfo *AllocTypeInfo, std::optional<Expr *> ArraySize, SourceRange DirectInitRange, Expr *Initializer) {\n  if (ArraySize && *ArraySize && !(*ArraySize)->isTypeDependent()) {\n    if (getLangOpts().CPlusPlus14) {\n    } else {\n      class SizeConvertDiagnoser : public ICEConvertDiagnoser {\n        SemaDiagnosticBuilder diagnoseNotInt(Sema &S, SourceLocation Loc, QualType T) override { return S.Diag(Loc, diag::err_array_size_not_integral) << S.getLangOpts().CPlusPlus11 << T; }"}}

[k]={{s,14848,"static void diagnoseArrayStarInParamType(Sema &S, QualType PType, SourceLocation Loc) {\n  S.Diag(Loc, diag::err_array_star_in_function_definition);"}}

[k]={{r,4541,"static TypeSourceInfo *GetFullTypeForDeclarator(TypeProcessingState &state, QualType declSpecType, TypeSourceInfo *TInfo) {\n  for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i) {\n    case DeclaratorChunk::Array: {\n      if (ASM == ArrayType::Star && !D.isPrototypeContext()) {\n        S.Diag(DeclType.Loc, diag::err_array_star_outside_prototype);"}}

[k]={{r,4562,"static TypeSourceInfo *GetFullTypeForDeclarator(TypeProcessingState &state, QualType declSpecType, TypeSourceInfo *TInfo) {\n  for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i) {\n    case DeclaratorChunk::Array: {\n      // C99 6.7.5.2p1: The optional type qualifiers and the keyword static\n      // shall appear only in a declaration of a function parameter with an\n      // array type, ...\n      if (ASM == ArrayType::Static || ATI.TypeQuals) {\n        // C99 6.7.5.2p1: ... and then only in the outermost array type\n        // derivation.\n        if (hasOuterPointerLikeChunk(D, chunkIndex)) {\n          S.Diag(DeclType.Loc, diag::err_array_static_not_outermost) << (ASM == ArrayType::Static ? \"\'static\'\" : \"type qualifier\");"}}

[k]={{r,4551,"static TypeSourceInfo *GetFullTypeForDeclarator(TypeProcessingState &state, QualType declSpecType, TypeSourceInfo *TInfo) {\n  for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i) {\n    case DeclaratorChunk::Array: {\n      // C99 6.7.5.2p1: The optional type qualifiers and the keyword static\n      // shall appear only in a declaration of a function parameter with an\n      // array type, ...\n      if (ASM == ArrayType::Static || ATI.TypeQuals) {\n        if (!(D.isPrototypeContext() || D.getContext() == DeclaratorContext::KNRTypeList)) {\n          S.Diag(DeclType.Loc, diag::err_array_static_outside_prototype) << (ASM == ArrayType::Static ? \"\'static\'\" : \"type qualifier\");"}}

[k]={{q,5869,"/// Attempt to fold a variable-sized type to a constant-sized type, returning\n/// true if we were successful.\nbool Sema::tryToFixVariablyModifiedVarType(TypeSourceInfo *&TInfo, QualType &T, SourceLocation Loc, unsigned FailedFoldDiagID) {\n  if (SizeIsNegative)\n  else if (Oversized.getBoolValue())\n    Diag(Loc, diag::err_array_too_large) << toString(Oversized, 10);"},{q,5972,"void Sema::CheckTypedefForVariablyModifiedType(Scope *S, TypedefNameDecl *NewTD) {\n  if (T->isVariablyModifiedType()) {\n    if (S->getFnParent() == nullptr) {\n      if (FixedTInfo) {\n      } else {\n        if (SizeIsNegative)\n        else if (T->isVariableArrayType())\n        else if (Oversized.getBoolValue())\n          Diag(NewTD->getLocation(), diag::err_array_too_large) << toString(Oversized, 10);"},{x,1901,"ExprResult Sema::BuildCXXNew(SourceRange Range, bool UseGlobal, SourceLocation PlacementLParen, MultiExprArg PlacementArgs, SourceLocation PlacementRParen, SourceRange TypeIdParens, QualType AllocType, TypeSourceInfo *AllocTypeInfo, std::optional<Expr *> ArraySize, SourceRange DirectInitRange, Expr *Initializer) {\n  if (ArraySize && *ArraySize && !(*ArraySize)->isTypeDependent()) {\n    // We\'ve already performed any required implicit conversion to integer or\n    // unscoped enumeration type.\n    // FIXME: Per CWG1464, we are required to check the value prior to\n    // converting to size_t. This will never find a negative array size in\n    // C++14 onwards, because Value is always unsigned here!\n    if (std::optional<llvm::APSInt> Value = (*ArraySize)->getIntegerConstantExpr(Context)) {\n      if (!AllocType->isDependentType()) {\n        if (ActiveSizeBits > ConstantArrayType::getMaxSizeBits(Context))\n          return ExprError(Diag((*ArraySize)->getBeginLoc(), diag::err_array_too_large) << toString(*Value, 10) << (*ArraySize)->getSourceRange());"},{r,2345,"/// Build an array type.\n///\n/// \\param T The type of each element in the array.\n///\n/// \\param ASM C99 array size modifier (e.g., \'*\', \'static\').\n///\n/// \\param ArraySize Expression describing the size of the array.\n///\n/// \\param Brackets The range from the opening \'[\' to the closing \']\'.\n///\n/// \\param Entity The name of the entity that involves the array\n/// type, if known.\n///\n/// \\returns A suitable array type, if there are no errors. Otherwise,\n/// returns a NULL type.\nQualType Sema::BuildArrayType(QualType T, ArrayType::ArraySizeModifier ASM, Expr *ArraySize, unsigned Quals, SourceRange Brackets, DeclarationName Entity) {\n  if (!ArraySize) {\n  } else if (ArraySize->isTypeDependent() || ArraySize->isValueDependent()) {\n  } else {\n    if (!R.isUsable()) {\n    } else if (!T->isDependentType() && !T->isIncompleteType() && !T->isConstantSizeType()) {\n    } else {\n      if (ActiveSizeBits > ConstantArrayType::getMaxSizeBits(Context)) {\n        Diag(ArraySize->getBeginLoc(), diag::err_array_too_large) << toString(ConstVal, 10) << ArraySize->getSourceRange();"}}

[k]={{q,7539,"void Sema::CheckVariableDeclarationType(VarDecl *NewVD) {\n  // Emit an error if an address space was applied to decl with local storage.\n  // This includes arrays of objects with address space qualifiers, but not\n  // automatic variables that point to other address spaces.\n  // ISO/IEC TR 18037 S5.1.2\n  if (!getLangOpts().OpenCL && NewVD->hasLocalStorage() && T.getAddressSpace() != LangAS::Default) {\n    Diag(NewVD->getLocation(), diag::err_as_qualified_auto_decl) << 0;"},{q,7623,"void Sema::CheckVariableDeclarationType(VarDecl *NewVD) {\n  if (getLangOpts().OpenCL) {\n    // FIXME: Adding local AS in C++ for OpenCL might make sense.\n    if (NewVD->isFileVarDecl() || NewVD->isStaticLocal() || NewVD->hasExternalStorage()) {\n    } else {\n      if (T.getAddressSpace() == LangAS::opencl_constant || T.getAddressSpace() == LangAS::opencl_local) {\n      } else if (T.getAddressSpace() != LangAS::opencl_private &&\n        Diag(NewVD->getLocation(), diag::err_as_qualified_auto_decl) << 1;"}}

[k]={{q,7048,"NamedDecl *Sema::ActOnVariableDeclarator(Scope *S, Declarator &D, DeclContext *DC, TypeSourceInfo *TInfo, LookupResult &Previous, MultiTemplateParamsArg TemplateParamLists, bool &AddToScope, ArrayRef<BindingDecl *> Bindings) {\n  // Handle GNU asm-label extension (encoded as an attribute).\n  if (Expr *E = (Expr *)D.getAsmLabel()) {\n    if (S->getFnParent() != nullptr) {\n    } else if (SC == SC_Register) {\n      if (!R->isIntegralType(Context) && !R->isPointerType()) {\n        Diag(D.getBeginLoc(), diag::err_asm_bad_register_type);"}}

[k]={{"clang/lib/Parse/ParseStmtAsm.cpp",623,"/// parseGNUAsmQualifierListOpt - Parse a GNU extended asm qualifier list.\n///      asm-qualifier:\n///        volatile\n///        inline\n///        goto\n///\n///      asm-qualifier-list:\n///        asm-qualifier\n///        asm-qualifier-list asm-qualifier\nbool Parser::parseGNUAsmQualifierListOpt(GNUAsmQualifiers &AQ) {\n  while (true) {\n    if (AQ.setAsmQualifier(A))\n      Diag(Tok.getLocation(), diag::err_asm_duplicate_qual) << GNUAsmQualifiers::getQualifierName(A);"}}

[k]={{"clang/lib/Parse/ParseStmtAsm.cpp",287,"/// Turn a sequence of our tokens back into a string that we can hand\n/// to the MC asm parser.\nstatic bool buildMSAsmString(Preprocessor &PP, SourceLocation AsmLoc, ArrayRef<Token> AsmToks, SmallVectorImpl<unsigned> &TokOffsets, SmallString<512> &Asm) {\n  for (unsigned i = 0, e = AsmToks.size(); i < e; ++i) {\n    // Don\'t actually write \'__asm\' into the assembly stream.\n    if (Tok.is(tok::kw_asm)) {\n      // Complain about __asm at the end of the stream.\n      if (i + 1 == e) {\n        PP.Diag(AsmLoc, diag::err_asm_empty);"}}

[k]={{ob,670,"/// AnalyzeAsmString - Analyze the asm string of the current asm, decomposing\n/// it into pieces.  If the asm string is erroneous, emit errors and return\n/// true, otherwise return false.\nunsigned GCCAsmStmt::AnalyzeAsmString(SmallVectorImpl<AsmStringPiece> &Pieces, const ASTContext &C, unsigned &DiagOffs) const {\n  while (true) {\n    // Handle operands that have asmSymbolicName (e.g., %x[foo]).\n    if (EscapedChar == \'[\') {\n      if (NameEnd == CurPtr)\n        return diag::err_asm_empty_symbolic_operand_name;"}}

[k]={{F,696,"ExprResult Sema::LookupInlineAsmIdentifier(CXXScopeSpec &SS, SourceLocation TemplateKWLoc, UnqualifiedId &Id, bool IsUnevaluatedContext) {\n  if (RequireCompleteExprType(Result.get(), diag::err_asm_incomplete_type)) {"},{F,741,"bool Sema::LookupInlineAsmField(StringRef Base, StringRef Member, unsigned &Offset, SourceLocation AsmLoc) {\n  for (StringRef NextMember : Members) {\n    if (RequireCompleteType(AsmLoc, QualType(RT, 0), diag::err_asm_incomplete_type))"}}

[k]={{F,514,"StmtResult Sema::ActOnGCCAsmStmt(SourceLocation AsmLoc, bool IsSimple, bool IsVolatile, unsigned NumOutputs, unsigned NumInputs, IdentifierInfo **Names, MultiExprArg constraints, MultiExprArg Exprs, Expr *asmString, MultiExprArg clobbers, unsigned NumLabels, SourceLocation RParenLoc) {\n  for (unsigned i = 0, e = InputConstraintInfos.size(); i != e; ++i) {\n    if (InputMatchedToOutput[TiedTo] != ~0U) {\n      targetDiag(NS->getInputExpr(i)->getBeginLoc(), diag::err_asm_input_duplicate_match) << TiedTo;"}}

[k]={{ob,588,"/// AnalyzeAsmString - Analyze the asm string of the current asm, decomposing\n/// it into pieces.  If the asm string is erroneous, emit errors and return\n/// true, otherwise return false.\nunsigned GCCAsmStmt::AnalyzeAsmString(SmallVectorImpl<AsmStringPiece> &Pieces, const ASTContext &C, unsigned &DiagOffs) const {\n  while (true) {\n    // Escaped \"%\" character in asm string.\n    if (CurPtr == StrEnd) {\n      return diag::err_asm_invalid_escape;"},{ob,626,"/// AnalyzeAsmString - Analyze the asm string of the current asm, decomposing\n/// it into pieces.  If the asm string is erroneous, emit errors and return\n/// true, otherwise return false.\nunsigned GCCAsmStmt::AnalyzeAsmString(SmallVectorImpl<AsmStringPiece> &Pieces, const ASTContext &C, unsigned &DiagOffs) const {\n  while (true) {\n    if (isLetter(EscapedChar)) {\n      if (CurPtr == StrEnd) { // Premature end.\n        return diag::err_asm_invalid_escape;"},{ob,696,"/// AnalyzeAsmString - Analyze the asm string of the current asm, decomposing\n/// it into pieces.  If the asm string is erroneous, emit errors and return\n/// true, otherwise return false.\nunsigned GCCAsmStmt::AnalyzeAsmString(SmallVectorImpl<AsmStringPiece> &Pieces, const ASTContext &C, unsigned &DiagOffs) const {\n  while (true) {\n    return diag::err_asm_invalid_escape;"}}

[k]={{q,7042,"NamedDecl *Sema::ActOnVariableDeclarator(Scope *S, Declarator &D, DeclContext *DC, TypeSourceInfo *TInfo, LookupResult &Previous, MultiTemplateParamsArg TemplateParamLists, bool &AddToScope, ArrayRef<BindingDecl *> Bindings) {\n  // Handle GNU asm-label extension (encoded as an attribute).\n  if (Expr *E = (Expr *)D.getAsmLabel()) {\n    if (S->getFnParent() != nullptr) {\n    } else if (SC == SC_Register) {\n      // Global Named register\n      if (DeclAttrsMatchCUDAMode(getLangOpts(), NewVD)) {\n        if (!TI.isValidGCCRegisterName(Label))\n        else if (!TI.validateGlobalRegisterVariable(Label, Context.getTypeSize(R), HasSizeMismatch))\n          Diag(E->getExprLoc(), diag::err_asm_invalid_global_var_reg) << Label;"}}

[k]={{F,321,"StmtResult Sema::ActOnGCCAsmStmt(SourceLocation AsmLoc, bool IsSimple, bool IsVolatile, unsigned NumOutputs, unsigned NumInputs, IdentifierInfo **Names, MultiExprArg constraints, MultiExprArg Exprs, Expr *asmString, MultiExprArg clobbers, unsigned NumLabels, SourceLocation RParenLoc) {\n  for (unsigned i = NumOutputs, e = NumOutputs + NumInputs; i != e; i++) {\n    if (!Context.getTargetInfo().validateInputConstraint(OutputConstraintInfos, Info)) {\n      targetDiag(Literal->getBeginLoc(), diag::err_asm_invalid_input_constraint) << Info.getConstraintStr();"}}

[k]={{F,391,"StmtResult Sema::ActOnGCCAsmStmt(SourceLocation AsmLoc, bool IsSimple, bool IsVolatile, unsigned NumOutputs, unsigned NumInputs, IdentifierInfo **Names, MultiExprArg constraints, MultiExprArg Exprs, Expr *asmString, MultiExprArg clobbers, unsigned NumLabels, SourceLocation RParenLoc) {\n  for (unsigned i = NumOutputs, e = NumOutputs + NumInputs; i != e; i++) {\n    if (!Context.getTargetInfo().validateInputSize(FeatureMap, Literal->getString(), Size))\n      return targetDiag(InputExpr->getBeginLoc(), diag::err_asm_invalid_input_size) << Info.getConstraintStr();"}}

[k]={{F,346,"StmtResult Sema::ActOnGCCAsmStmt(SourceLocation AsmLoc, bool IsSimple, bool IsVolatile, unsigned NumOutputs, unsigned NumInputs, IdentifierInfo **Names, MultiExprArg constraints, MultiExprArg Exprs, Expr *asmString, MultiExprArg clobbers, unsigned NumLabels, SourceLocation RParenLoc) {\n  for (unsigned i = NumOutputs, e = NumOutputs + NumInputs; i != e; i++) {\n    // Only allow void types for memory constraints.\n    if (Info.allowsMemory() && !Info.allowsRegister()) {\n      if (CheckAsmLValue(InputExpr, *this))\n        return StmtError(Diag(InputExpr->getBeginLoc(), diag::err_asm_invalid_lvalue_in_input) << Info.getConstraintStr() << InputExpr->getSourceRange());"}}

[k]={{F,299,"StmtResult Sema::ActOnGCCAsmStmt(SourceLocation AsmLoc, bool IsSimple, bool IsVolatile, unsigned NumOutputs, unsigned NumInputs, IdentifierInfo **Names, MultiExprArg constraints, MultiExprArg Exprs, Expr *asmString, MultiExprArg clobbers, unsigned NumLabels, SourceLocation RParenLoc) {\n  for (unsigned i = 0; i != NumOutputs; i++) {\n    default:\n      return StmtError(Diag(OutputExpr->getBeginLoc(), diag::err_asm_invalid_lvalue_in_output) << OutputExpr->getSourceRange());"}}

[k]={{ob,646,"/// AnalyzeAsmString - Analyze the asm string of the current asm, decomposing\n/// it into pieces.  If the asm string is erroneous, emit errors and return\n/// true, otherwise return false.\nunsigned GCCAsmStmt::AnalyzeAsmString(SmallVectorImpl<AsmStringPiece> &Pieces, const ASTContext &C, unsigned &DiagOffs) const {\n  while (true) {\n    // Handle operands that don\'t have asmSymbolicName (e.g., %x4).\n    if (isDigit(EscapedChar)) {\n      if (N >= NumOperands) {\n        return diag::err_asm_invalid_operand_number;"}}

[k]={{F,247,"StmtResult Sema::ActOnGCCAsmStmt(SourceLocation AsmLoc, bool IsSimple, bool IsVolatile, unsigned NumOutputs, unsigned NumInputs, IdentifierInfo **Names, MultiExprArg constraints, MultiExprArg Exprs, Expr *asmString, MultiExprArg clobbers, unsigned NumLabels, SourceLocation RParenLoc) {\n  for (unsigned i = 0; i != NumOutputs; i++) {\n    if (!Context.getTargetInfo().validateOutputConstraint(Info)) {\n      targetDiag(Literal->getBeginLoc(), diag::err_asm_invalid_output_constraint) << Info.getConstraintStr();"}}