Module:ClangDiags/DiagsLongData7: Difference between revisions

[j]={{w,10362,"StmtResult Sema::ActOnOpenMPAtomicDirective(ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, SourceLocation EndLoc) {\n  // OpenMP [2.12.6, atomic Construct]\n  // In the next expressions:\n  // * x and v (as applicable) are both l-value expressions with scalar type.\n  // * During the execution of an atomic region, multiple syntactic\n  // occurrences of x must designate the same storage location.\n  // * Neither of v and expr (as applicable) may access the storage location\n  // designated by x.\n  // * Neither of x and expr (as applicable) may access the storage location\n  // designated by v.\n  // * expr is an expression with scalar type.\n  // * binop is one of +, *, -, /, &, ^, |, <<, or >>.\n  // * binop, binop=, ++, and -- are not overloaded operators.\n  // * The expression x binop expr must be numerically equivalent to x binop\n  // (expr). This requirement is satisfied if the operators in expr have\n  // precedence greater than binop, or by using parentheses around expr or\n  // subexpressions of expr.\n  // * The expression expr binop x must be numerically equivalent to (expr)\n  // binop x. This requirement is satisfied if the operators in expr have\n  // precedence equal to or greater than binop, or by using parentheses around\n  // expr or subexpressions of expr.\n  // * For forms that allow multiple occurrences of x, the number of times\n  // that x is evaluated is unspecified.\n  if (AtomicKind == OMPC_read) {\n  } else if (AtomicKind == OMPC_write) {\n  } else if (AtomicKind == OMPC_update || AtomicKind == OMPC_unknown) {\n  } else if (AtomicKind == OMPC_capture) {\n    if (const auto *AtomicBody = dyn_cast<Expr>(Body)) {\n      if (ErrorFound != NoError) {\n        Diag(NoteLoc, diag::note_omp_atomic_capture) << ErrorFound << NoteRange;"},{w,10511,"StmtResult Sema::ActOnOpenMPAtomicDirective(ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, SourceLocation EndLoc) {\n  // OpenMP [2.12.6, atomic Construct]\n  // In the next expressions:\n  // * x and v (as applicable) are both l-value expressions with scalar type.\n  // * During the execution of an atomic region, multiple syntactic\n  // occurrences of x must designate the same storage location.\n  // * Neither of v and expr (as applicable) may access the storage location\n  // designated by x.\n  // * Neither of x and expr (as applicable) may access the storage location\n  // designated by v.\n  // * expr is an expression with scalar type.\n  // * binop is one of +, *, -, /, &, ^, |, <<, or >>.\n  // * binop, binop=, ++, and -- are not overloaded operators.\n  // * The expression x binop expr must be numerically equivalent to x binop\n  // (expr). This requirement is satisfied if the operators in expr have\n  // precedence greater than binop, or by using parentheses around expr or\n  // subexpressions of expr.\n  // * The expression expr binop x must be numerically equivalent to (expr)\n  // binop x. This requirement is satisfied if the operators in expr have\n  // precedence equal to or greater than binop, or by using parentheses around\n  // expr or subexpressions of expr.\n  // * For forms that allow multiple occurrences of x, the number of times\n  // that x is evaluated is unspecified.\n  if (AtomicKind == OMPC_read) {\n  } else if (AtomicKind == OMPC_write) {\n  } else if (AtomicKind == OMPC_update || AtomicKind == OMPC_unknown) {\n  } else if (AtomicKind == OMPC_capture) {\n    if (ErrorFound != NoError) {\n      Diag(NoteLoc, diag::note_omp_atomic_capture) << ErrorFound << NoteRange;"}}

[j]={{w,10522,"StmtResult Sema::ActOnOpenMPAtomicDirective(ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, SourceLocation EndLoc) {\n  // OpenMP [2.12.6, atomic Construct]\n  // In the next expressions:\n  // * x and v (as applicable) are both l-value expressions with scalar type.\n  // * During the execution of an atomic region, multiple syntactic\n  // occurrences of x must designate the same storage location.\n  // * Neither of v and expr (as applicable) may access the storage location\n  // designated by x.\n  // * Neither of x and expr (as applicable) may access the storage location\n  // designated by v.\n  // * expr is an expression with scalar type.\n  // * binop is one of +, *, -, /, &, ^, |, <<, or >>.\n  // * binop, binop=, ++, and -- are not overloaded operators.\n  // * The expression x binop expr must be numerically equivalent to x binop\n  // (expr). This requirement is satisfied if the operators in expr have\n  // precedence greater than binop, or by using parentheses around expr or\n  // subexpressions of expr.\n  // * The expression expr binop x must be numerically equivalent to (expr)\n  // binop x. This requirement is satisfied if the operators in expr have\n  // precedence equal to or greater than binop, or by using parentheses around\n  // expr or subexpressions of expr.\n  // * For forms that allow multiple occurrences of x, the number of times\n  // that x is evaluated is unspecified.\n  if (AtomicKind == OMPC_read) {\n  } else if (AtomicKind == OMPC_write) {\n  } else if (AtomicKind == OMPC_update || AtomicKind == OMPC_unknown) {\n  } else if (AtomicKind == OMPC_capture) {\n  } else if (AtomicKind == OMPC_compare) {\n    if (IsCompareCapture) {\n      if (!Checker.checkStmt(Body, ErrorInfo)) {\n        Diag(ErrorInfo.NoteLoc, diag::note_omp_atomic_compare) << ErrorInfo.Error << ErrorInfo.NoteRange;"},{w,10540,"StmtResult Sema::ActOnOpenMPAtomicDirective(ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, SourceLocation EndLoc) {\n  // OpenMP [2.12.6, atomic Construct]\n  // In the next expressions:\n  // * x and v (as applicable) are both l-value expressions with scalar type.\n  // * During the execution of an atomic region, multiple syntactic\n  // occurrences of x must designate the same storage location.\n  // * Neither of v and expr (as applicable) may access the storage location\n  // designated by x.\n  // * Neither of x and expr (as applicable) may access the storage location\n  // designated by v.\n  // * expr is an expression with scalar type.\n  // * binop is one of +, *, -, /, &, ^, |, <<, or >>.\n  // * binop, binop=, ++, and -- are not overloaded operators.\n  // * The expression x binop expr must be numerically equivalent to x binop\n  // (expr). This requirement is satisfied if the operators in expr have\n  // precedence greater than binop, or by using parentheses around expr or\n  // subexpressions of expr.\n  // * The expression expr binop x must be numerically equivalent to (expr)\n  // binop x. This requirement is satisfied if the operators in expr have\n  // precedence equal to or greater than binop, or by using parentheses around\n  // expr or subexpressions of expr.\n  // * For forms that allow multiple occurrences of x, the number of times\n  // that x is evaluated is unspecified.\n  if (AtomicKind == OMPC_read) {\n  } else if (AtomicKind == OMPC_write) {\n  } else if (AtomicKind == OMPC_update || AtomicKind == OMPC_unknown) {\n  } else if (AtomicKind == OMPC_capture) {\n  } else if (AtomicKind == OMPC_compare) {\n    if (IsCompareCapture) {\n    } else {\n      if (!Checker.checkStmt(Body, ErrorInfo)) {\n        Diag(ErrorInfo.NoteLoc, diag::note_omp_atomic_compare) << ErrorInfo.Error << ErrorInfo.NoteRange;"}}

[j]={{w,10259,"StmtResult Sema::ActOnOpenMPAtomicDirective(ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, SourceLocation EndLoc) {\n  // OpenMP [2.12.6, atomic Construct]\n  // In the next expressions:\n  // * x and v (as applicable) are both l-value expressions with scalar type.\n  // * During the execution of an atomic region, multiple syntactic\n  // occurrences of x must designate the same storage location.\n  // * Neither of v and expr (as applicable) may access the storage location\n  // designated by x.\n  // * Neither of x and expr (as applicable) may access the storage location\n  // designated by v.\n  // * expr is an expression with scalar type.\n  // * binop is one of +, *, -, /, &, ^, |, <<, or >>.\n  // * binop, binop=, ++, and -- are not overloaded operators.\n  // * The expression x binop expr must be numerically equivalent to x binop\n  // (expr). This requirement is satisfied if the operators in expr have\n  // precedence greater than binop, or by using parentheses around expr or\n  // subexpressions of expr.\n  // * The expression expr binop x must be numerically equivalent to (expr)\n  // binop x. This requirement is satisfied if the operators in expr have\n  // precedence equal to or greater than binop, or by using parentheses around\n  // expr or subexpressions of expr.\n  // * For forms that allow multiple occurrences of x, the number of times\n  // that x is evaluated is unspecified.\n  if (AtomicKind == OMPC_read) {\n    if (ErrorFound != NoError) {\n      Diag(NoteLoc, diag::note_omp_atomic_read_write) << ErrorFound << NoteRange;"},{w,10305,"StmtResult Sema::ActOnOpenMPAtomicDirective(ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, SourceLocation EndLoc) {\n  // OpenMP [2.12.6, atomic Construct]\n  // In the next expressions:\n  // * x and v (as applicable) are both l-value expressions with scalar type.\n  // * During the execution of an atomic region, multiple syntactic\n  // occurrences of x must designate the same storage location.\n  // * Neither of v and expr (as applicable) may access the storage location\n  // designated by x.\n  // * Neither of x and expr (as applicable) may access the storage location\n  // designated by v.\n  // * expr is an expression with scalar type.\n  // * binop is one of +, *, -, /, &, ^, |, <<, or >>.\n  // * binop, binop=, ++, and -- are not overloaded operators.\n  // * The expression x binop expr must be numerically equivalent to x binop\n  // (expr). This requirement is satisfied if the operators in expr have\n  // precedence greater than binop, or by using parentheses around expr or\n  // subexpressions of expr.\n  // * The expression expr binop x must be numerically equivalent to (expr)\n  // binop x. This requirement is satisfied if the operators in expr have\n  // precedence equal to or greater than binop, or by using parentheses around\n  // expr or subexpressions of expr.\n  // * For forms that allow multiple occurrences of x, the number of times\n  // that x is evaluated is unspecified.\n  if (AtomicKind == OMPC_read) {\n  } else if (AtomicKind == OMPC_write) {\n    if (ErrorFound != NoError) {\n      Diag(NoteLoc, diag::note_omp_atomic_read_write) << ErrorFound << NoteRange;"}}

[j]={{w,10320,"StmtResult Sema::ActOnOpenMPAtomicDirective(ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, SourceLocation EndLoc) {\n  // OpenMP [2.12.6, atomic Construct]\n  // In the next expressions:\n  // * x and v (as applicable) are both l-value expressions with scalar type.\n  // * During the execution of an atomic region, multiple syntactic\n  // occurrences of x must designate the same storage location.\n  // * Neither of v and expr (as applicable) may access the storage location\n  // designated by x.\n  // * Neither of x and expr (as applicable) may access the storage location\n  // designated by v.\n  // * expr is an expression with scalar type.\n  // * binop is one of +, *, -, /, &, ^, |, <<, or >>.\n  // * binop, binop=, ++, and -- are not overloaded operators.\n  // * The expression x binop expr must be numerically equivalent to x binop\n  // (expr). This requirement is satisfied if the operators in expr have\n  // precedence greater than binop, or by using parentheses around expr or\n  // subexpressions of expr.\n  // * The expression expr binop x must be numerically equivalent to (expr)\n  // binop x. This requirement is satisfied if the operators in expr have\n  // precedence equal to or greater than binop, or by using parentheses around\n  // expr or subexpressions of expr.\n  // * For forms that allow multiple occurrences of x, the number of times\n  // that x is evaluated is unspecified.\n  if (AtomicKind == OMPC_read) {\n  } else if (AtomicKind == OMPC_write) {\n  } else if (AtomicKind == OMPC_update || AtomicKind == OMPC_unknown) {\n    if (Checker.checkStatement(Body, (AtomicKind == OMPC_update) ? diag::err_omp_atomic_update_not_expression_statement : diag::err_omp_atomic_not_expression_statement, diag::note_omp_atomic_update))"},{w,10346,"StmtResult Sema::ActOnOpenMPAtomicDirective(ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, SourceLocation EndLoc) {\n  // OpenMP [2.12.6, atomic Construct]\n  // In the next expressions:\n  // * x and v (as applicable) are both l-value expressions with scalar type.\n  // * During the execution of an atomic region, multiple syntactic\n  // occurrences of x must designate the same storage location.\n  // * Neither of v and expr (as applicable) may access the storage location\n  // designated by x.\n  // * Neither of x and expr (as applicable) may access the storage location\n  // designated by v.\n  // * expr is an expression with scalar type.\n  // * binop is one of +, *, -, /, &, ^, |, <<, or >>.\n  // * binop, binop=, ++, and -- are not overloaded operators.\n  // * The expression x binop expr must be numerically equivalent to x binop\n  // (expr). This requirement is satisfied if the operators in expr have\n  // precedence greater than binop, or by using parentheses around expr or\n  // subexpressions of expr.\n  // * The expression expr binop x must be numerically equivalent to (expr)\n  // binop x. This requirement is satisfied if the operators in expr have\n  // precedence equal to or greater than binop, or by using parentheses around\n  // expr or subexpressions of expr.\n  // * For forms that allow multiple occurrences of x, the number of times\n  // that x is evaluated is unspecified.\n  if (AtomicKind == OMPC_read) {\n  } else if (AtomicKind == OMPC_write) {\n  } else if (AtomicKind == OMPC_update || AtomicKind == OMPC_unknown) {\n  } else if (AtomicKind == OMPC_capture) {\n    if (const auto *AtomicBody = dyn_cast<Expr>(Body)) {\n      if (AtomicBinOp && AtomicBinOp->getOpcode() == BO_Assign) {\n        if (Checker.checkStatement(Body, diag::err_omp_atomic_capture_not_expression_statement, diag::note_omp_atomic_update))"}}

[j]={{w,7355,"/// Called on a for stmt to check and extract its iteration space\n/// for further processing (such as collapsing).\nstatic bool checkOpenMPIterationSpace(OpenMPDirectiveKind DKind, Stmt *S, Sema &SemaRef, DSAStackTy &DSA, unsigned CurrentNestedLoopCount, unsigned NestedLoopCount, unsigned TotalNestedLoopCount, Expr *CollapseLoopCountExpr, Expr *OrderedLoopCountExpr, Sema::VarsWithInheritedDSAType &VarsWithImplicitDSA, llvm::MutableArrayRef<LoopIterationSpace> ResultIterSpaces, llvm::MapVector<const Expr *, DeclRefExpr *> &Captures) {\n  // Ranged for is supported only in OpenMP 5.0.\n  if (!For && (SemaRef.LangOpts.OpenMP <= 45 || !CXXFor)) {\n    if (TotalNestedLoopCount > 1) {\n      if (CollapseLoopCountExpr && OrderedLoopCountExpr)\n        SemaRef.Diag(DSA.getConstructLoc(), diag::note_omp_collapse_ordered_expr) << 2 << CollapseLoopCountExpr->getSourceRange() << OrderedLoopCountExpr->getSourceRange();"},{w,7357,"/// Called on a for stmt to check and extract its iteration space\n/// for further processing (such as collapsing).\nstatic bool checkOpenMPIterationSpace(OpenMPDirectiveKind DKind, Stmt *S, Sema &SemaRef, DSAStackTy &DSA, unsigned CurrentNestedLoopCount, unsigned NestedLoopCount, unsigned TotalNestedLoopCount, Expr *CollapseLoopCountExpr, Expr *OrderedLoopCountExpr, Sema::VarsWithInheritedDSAType &VarsWithImplicitDSA, llvm::MutableArrayRef<LoopIterationSpace> ResultIterSpaces, llvm::MapVector<const Expr *, DeclRefExpr *> &Captures) {\n  // Ranged for is supported only in OpenMP 5.0.\n  if (!For && (SemaRef.LangOpts.OpenMP <= 45 || !CXXFor)) {\n    if (TotalNestedLoopCount > 1) {\n      if (CollapseLoopCountExpr && OrderedLoopCountExpr)\n      else if (CollapseLoopCountExpr)\n        SemaRef.Diag(CollapseLoopCountExpr->getExprLoc(), diag::note_omp_collapse_ordered_expr) << 0 << CollapseLoopCountExpr->getSourceRange();"},{w,7359,"/// Called on a for stmt to check and extract its iteration space\n/// for further processing (such as collapsing).\nstatic bool checkOpenMPIterationSpace(OpenMPDirectiveKind DKind, Stmt *S, Sema &SemaRef, DSAStackTy &DSA, unsigned CurrentNestedLoopCount, unsigned NestedLoopCount, unsigned TotalNestedLoopCount, Expr *CollapseLoopCountExpr, Expr *OrderedLoopCountExpr, Sema::VarsWithInheritedDSAType &VarsWithImplicitDSA, llvm::MutableArrayRef<LoopIterationSpace> ResultIterSpaces, llvm::MapVector<const Expr *, DeclRefExpr *> &Captures) {\n  // Ranged for is supported only in OpenMP 5.0.\n  if (!For && (SemaRef.LangOpts.OpenMP <= 45 || !CXXFor)) {\n    if (TotalNestedLoopCount > 1) {\n      if (CollapseLoopCountExpr && OrderedLoopCountExpr)\n      else if (CollapseLoopCountExpr)\n      else\n        SemaRef.Diag(OrderedLoopCountExpr->getExprLoc(), diag::note_omp_collapse_ordered_expr) << 1 << OrderedLoopCountExpr->getSourceRange();"}}

[j]={{w,13496,"ExprResult Sema::PerformOpenMPImplicitIntegerConversion(SourceLocation Loc, Expr *Op) {\n  class IntConvertDiagnoser : public ICEConvertDiagnoser {\n    SemaDiagnosticBuilder noteExplicitConv(Sema &S, CXXConversionDecl *Conv, QualType ConvTy) override { return S.Diag(Conv->getLocation(), diag::note_omp_conversion_here) << ConvTy->isEnumeralType() << ConvTy; }"},{w,13498,"ExprResult Sema::PerformOpenMPImplicitIntegerConversion(SourceLocation Loc, Expr *Op) {\n  class IntConvertDiagnoser : public ICEConvertDiagnoser {\n    SemaDiagnosticBuilder noteAmbiguous(Sema &S, CXXConversionDecl *Conv, QualType ConvTy) override { return S.Diag(Conv->getLocation(), diag::note_omp_conversion_here) << ConvTy->isEnumeralType() << ConvTy; }"}}

[j]={{w,8676,"StmtResult Sema::ActOnOpenMPCriticalDirective(const DeclarationNameInfo &DirName, ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, SourceLocation EndLoc) {\n  if (Pair.first && DirName.getName() && !DependentHint) {\n    if (llvm::APSInt::compareValues(Hint, Pair.second) != 0) {\n      if (HintLoc.isValid())\n        Diag(HintLoc, diag::note_omp_critical_hint_here) << 0 << toString(Hint, /*Radix=*/10, /*Signed=*/false);"},{w,8680,"StmtResult Sema::ActOnOpenMPCriticalDirective(const DeclarationNameInfo &DirName, ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, SourceLocation EndLoc) {\n  if (Pair.first && DirName.getName() && !DependentHint) {\n    if (llvm::APSInt::compareValues(Hint, Pair.second) != 0) {\n      if (const auto *C = Pair.first->getSingleClause<OMPHintClause>()) {\n        Diag(C->getBeginLoc(), diag::note_omp_critical_hint_here) << 1"}}

[j]={{w,8678,"StmtResult Sema::ActOnOpenMPCriticalDirective(const DeclarationNameInfo &DirName, ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, SourceLocation EndLoc) {\n  if (Pair.first && DirName.getName() && !DependentHint) {\n    if (llvm::APSInt::compareValues(Hint, Pair.second) != 0) {\n      if (HintLoc.isValid())\n      else\n        Diag(StartLoc, diag::note_omp_critical_no_hint) << 0;"},{w,8684,"StmtResult Sema::ActOnOpenMPCriticalDirective(const DeclarationNameInfo &DirName, ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, SourceLocation EndLoc) {\n  if (Pair.first && DirName.getName() && !DependentHint) {\n    if (llvm::APSInt::compareValues(Hint, Pair.second) != 0) {\n      if (const auto *C = Pair.first->getSingleClause<OMPHintClause>()) {\n      } else {\n        Diag(Pair.first->getBeginLoc(), diag::note_omp_critical_no_hint) << 1;"}}

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

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

[j]={{P,795,"void Parser::parseOMPContextProperty(OMPTraitSelector &TISelector, llvm::omp::TraitSet Set, llvm::StringMap<SourceLocation> &Seen) {\n  // If we have an invalid property here we already issued a warning.\n  if (TIProperty.Kind == TraitProperty::invalid) {\n    if (PropertyLoc != Tok.getLocation())\n      Diag(Tok.getLocation(), diag::note_omp_declare_variant_ctx_continue_here) << CONTEXT_TRAIT_LVL;"},{P,809,"void Parser::parseOMPContextProperty(OMPTraitSelector &TISelector, llvm::omp::TraitSet Set, llvm::StringMap<SourceLocation> &Seen) {\n  Diag(Tok.getLocation(), diag::note_omp_declare_variant_ctx_continue_here) << CONTEXT_TRAIT_LVL;"},{P,895,"/// Parses an OpenMP context selector.\n///\n/// <trait-selector-name> [\'(\'[<trait-score>] <trait-property> [, <t-p>]* \')\']\nvoid Parser::parseOMPContextSelector(OMPTraitSelector &TISelector, llvm::omp::TraitSet Set, llvm::StringMap<SourceLocation> &SeenSelectors) {\n  // If anything went wrong we issue an error or warning and then skip the rest\n  // of the selector. However, commas are ambiguous so we look for the nesting\n  // of parentheses here as well.\n  auto FinishSelector = [OuterPC, this]() -> void {\n    Diag(Tok.getLocation(), diag::note_omp_declare_variant_ctx_continue_here) << CONTEXT_SELECTOR_LVL;"},{P,1025,"/// Parses an OpenMP context selector set.\n///\n/// <trait-set-selector-name> \'=\' \'{\' <trait-selector> [, <trait-selector>]* \'}\'\nvoid Parser::parseOMPContextSelectorSet(OMPTraitSet &TISet, llvm::StringMap<SourceLocation> &SeenSets) {\n  // If anything went wrong we issue an error or warning and then skip the rest\n  // of the set. However, commas are ambiguous so we look for the nesting\n  // of braces here as well.\n  auto FinishSelectorSet = [this, OuterBC]() -> void {\n    Diag(Tok.getLocation(), diag::note_omp_declare_variant_ctx_continue_here) << CONTEXT_SELECTOR_SET_LVL;"}}

[j]={{P,725,"void Parser::parseOMPTraitPropertyKind(OMPTraitProperty &TIProperty, llvm::omp::TraitSet Set, llvm::omp::TraitSelector Selector, llvm::StringMap<SourceLocation> &Seen) {\n  if (SetForName != TraitSet::invalid) {\n    Diag(NameLoc, diag::note_omp_declare_variant_ctx_is_a) << Name << CONTEXT_SELECTOR_SET_LVL << CONTEXT_TRAIT_LVL;"},{P,732,"void Parser::parseOMPTraitPropertyKind(OMPTraitProperty &TIProperty, llvm::omp::TraitSet Set, llvm::omp::TraitSelector Selector, llvm::StringMap<SourceLocation> &Seen) {\n  if (SelectorForName != TraitSelector::invalid) {\n    Diag(NameLoc, diag::note_omp_declare_variant_ctx_is_a) << Name << CONTEXT_SELECTOR_LVL << CONTEXT_TRAIT_LVL;"},{P,834,"void Parser::parseOMPTraitSelectorKind(OMPTraitSelector &TISelector, llvm::omp::TraitSet Set, llvm::StringMap<SourceLocation> &Seen) {\n  if (SetForName != TraitSet::invalid) {\n    Diag(NameLoc, diag::note_omp_declare_variant_ctx_is_a) << Name << CONTEXT_SELECTOR_SET_LVL << CONTEXT_SELECTOR_LVL;"},{P,843,"void Parser::parseOMPTraitSelectorKind(OMPTraitSelector &TISelector, llvm::omp::TraitSet Set, llvm::StringMap<SourceLocation> &Seen) {\n  for (const auto &PotentialSet : {TraitSet::construct, TraitSet::user, TraitSet::implementation, TraitSet::device}) {\n    Diag(NameLoc, diag::note_omp_declare_variant_ctx_is_a) << Name << CONTEXT_TRAIT_LVL << CONTEXT_SELECTOR_LVL;"},{P,981,"void Parser::parseOMPTraitSetKind(OMPTraitSet &TISet, llvm::StringMap<SourceLocation> &Seen) {\n  if (SelectorForName != TraitSelector::invalid) {\n    Diag(NameLoc, diag::note_omp_declare_variant_ctx_is_a) << Name << CONTEXT_SELECTOR_LVL << CONTEXT_SELECTOR_SET_LVL;"},{P,992,"void Parser::parseOMPTraitSetKind(OMPTraitSet &TISet, llvm::StringMap<SourceLocation> &Seen) {\n  for (const auto &PotentialSet : {TraitSet::construct, TraitSet::user, TraitSet::implementation, TraitSet::device}) {\n    Diag(NameLoc, diag::note_omp_declare_variant_ctx_is_a) << Name << CONTEXT_TRAIT_LVL << CONTEXT_SELECTOR_SET_LVL;"}}

[j]={{P,707,"void Parser::parseOMPTraitPropertyKind(OMPTraitProperty &TIProperty, llvm::omp::TraitSet Set, llvm::omp::TraitSelector Selector, llvm::StringMap<SourceLocation> &Seen) {\n  if (Name.empty()) {\n    Diag(Tok.getLocation(), diag::note_omp_declare_variant_ctx_options) << CONTEXT_TRAIT_LVL << listOpenMPContextTraitProperties(Set, Selector);"},{P,746,"void Parser::parseOMPTraitPropertyKind(OMPTraitProperty &TIProperty, llvm::omp::TraitSet Set, llvm::omp::TraitSelector Selector, llvm::StringMap<SourceLocation> &Seen) {\n  Diag(NameLoc, diag::note_omp_declare_variant_ctx_options) << CONTEXT_TRAIT_LVL << listOpenMPContextTraitProperties(Set, Selector);"},{P,818,"void Parser::parseOMPTraitSelectorKind(OMPTraitSelector &TISelector, llvm::omp::TraitSet Set, llvm::StringMap<SourceLocation> &Seen) {\n  if (Name.empty()) {\n    Diag(Tok.getLocation(), diag::note_omp_declare_variant_ctx_options) << CONTEXT_SELECTOR_LVL << listOpenMPContextTraitSelectors(Set);"},{P,847,"void Parser::parseOMPTraitSelectorKind(OMPTraitSelector &TISelector, llvm::omp::TraitSet Set, llvm::StringMap<SourceLocation> &Seen) {\n  Diag(NameLoc, diag::note_omp_declare_variant_ctx_options) << CONTEXT_SELECTOR_LVL << listOpenMPContextTraitSelectors(Set);"},{P,965,"void Parser::parseOMPTraitSetKind(OMPTraitSet &TISet, llvm::StringMap<SourceLocation> &Seen) {\n  if (Name.empty()) {\n    Diag(Tok.getLocation(), diag::note_omp_declare_variant_ctx_options) << CONTEXT_SELECTOR_SET_LVL << listOpenMPContextTraitSets();"},{P,996,"void Parser::parseOMPTraitSetKind(OMPTraitSet &TISet, llvm::StringMap<SourceLocation> &Seen) {\n  Diag(NameLoc, diag::note_omp_declare_variant_ctx_options) << CONTEXT_SELECTOR_SET_LVL << listOpenMPContextTraitSets();"}}

[j]={{P,726,"void Parser::parseOMPTraitPropertyKind(OMPTraitProperty &TIProperty, llvm::omp::TraitSet Set, llvm::omp::TraitSelector Selector, llvm::StringMap<SourceLocation> &Seen) {\n  if (SetForName != TraitSet::invalid) {\n    Diag(NameLoc, diag::note_omp_declare_variant_ctx_try) << Name << \"<selector-name>\""},{P,736,"void Parser::parseOMPTraitPropertyKind(OMPTraitProperty &TIProperty, llvm::omp::TraitSet Set, llvm::omp::TraitSelector Selector, llvm::StringMap<SourceLocation> &Seen) {\n  if (SelectorForName != TraitSelector::invalid) {\n    Diag(NameLoc, diag::note_omp_declare_variant_ctx_try) << getOpenMPContextTraitSetName(getOpenMPContextTraitSetForSelector(SelectorForName)) << Name << (RequiresProperty ? \"(<property-name>)\" : \"\");"},{P,743,"void Parser::parseOMPTraitPropertyKind(OMPTraitProperty &TIProperty, llvm::omp::TraitSet Set, llvm::omp::TraitSelector Selector, llvm::StringMap<SourceLocation> &Seen) {\n  for (const auto &PotentialSet : {TraitSet::construct, TraitSet::user, TraitSet::implementation, TraitSet::device}) {\n    Diag(NameLoc, diag::note_omp_declare_variant_ctx_try) << getOpenMPContextTraitSetName(getOpenMPContextTraitSetForProperty(PropertyForName)) << getOpenMPContextTraitSelectorName(getOpenMPContextTraitSelectorForProperty(PropertyForName)) << (\"(\" + Name + \")\").str();"},{P,835,"void Parser::parseOMPTraitSelectorKind(OMPTraitSelector &TISelector, llvm::omp::TraitSet Set, llvm::StringMap<SourceLocation> &Seen) {\n  if (SetForName != TraitSet::invalid) {\n    Diag(NameLoc, diag::note_omp_declare_variant_ctx_try) << Name << \"<selector-name>\""},{P,844,"void Parser::parseOMPTraitSelectorKind(OMPTraitSelector &TISelector, llvm::omp::TraitSet Set, llvm::StringMap<SourceLocation> &Seen) {\n  for (const auto &PotentialSet : {TraitSet::construct, TraitSet::user, TraitSet::implementation, TraitSet::device}) {\n    Diag(NameLoc, diag::note_omp_declare_variant_ctx_try) << getOpenMPContextTraitSetName(getOpenMPContextTraitSetForProperty(PropertyForName)) << getOpenMPContextTraitSelectorName(getOpenMPContextTraitSelectorForProperty(PropertyForName)) << (\"(\" + Name + \")\").str();"},{P,985,"void Parser::parseOMPTraitSetKind(OMPTraitSet &TISet, llvm::StringMap<SourceLocation> &Seen) {\n  if (SelectorForName != TraitSelector::invalid) {\n    Diag(NameLoc, diag::note_omp_declare_variant_ctx_try) << getOpenMPContextTraitSetName(getOpenMPContextTraitSetForSelector(SelectorForName)) << Name << (RequiresProperty ? \"(<property-name>)\" : \"\");"},{P,993,"void Parser::parseOMPTraitSetKind(OMPTraitSet &TISet, llvm::StringMap<SourceLocation> &Seen) {\n  for (const auto &PotentialSet : {TraitSet::construct, TraitSet::user, TraitSet::implementation, TraitSet::device}) {\n    Diag(NameLoc, diag::note_omp_declare_variant_ctx_try) << getOpenMPContextTraitSetName(getOpenMPContextTraitSetForProperty(PropertyForName)) << getOpenMPContextTraitSelectorName(getOpenMPContextTraitSelectorForProperty(PropertyForName)) << (\"(\" + Name + \")\").str();"}}

[j]={{P,696,"static bool checkForDuplicates(Parser &P, StringRef Name, SourceLocation NameLoc, llvm::StringMap<SourceLocation> &Seen, OMPContextLvl Lvl) {\n  P.Diag(Res.first->getValue(), diag::note_omp_declare_variant_ctx_used_here) << Lvl << Name;"},{P,772,"static bool checkExtensionProperty(Parser &P, SourceLocation Loc, OMPTraitProperty &TIProperty, OMPTraitSelector &TISelector, llvm::StringMap<SourceLocation> &Seen) {\n  if (IsMatchExtension(TIProperty)) {\n    for (OMPTraitProperty &SeenProp : TISelector.Properties)\n      if (IsMatchExtension(SeenProp)) {\n        P.Diag(SeenLoc, diag::note_omp_declare_variant_ctx_used_here) << CONTEXT_TRAIT_LVL << SeenName;"}}

[j]={{w,5376,"StmtResult Sema::ActOnOpenMPExecutableDirective(OpenMPDirectiveKind Kind, const DeclarationNameInfo &DirName, OpenMPDirectiveKind CancelRegion, ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, SourceLocation EndLoc) {\n  for (const auto &P : VarsWithInheritedDSA) {\n    if (DSAStack->getDefaultDSA() == DSA_none || DSAStack->getDefaultDSA() == DSA_private || DSAStack->getDefaultDSA() == DSA_firstprivate) {\n      Diag(DSAStack->getDefaultDSALocation(), diag::note_omp_default_dsa_none);"}}

[j]={{w,5379,"StmtResult Sema::ActOnOpenMPExecutableDirective(OpenMPDirectiveKind Kind, const DeclarationNameInfo &DirName, OpenMPDirectiveKind CancelRegion, ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, SourceLocation EndLoc) {\n  for (const auto &P : VarsWithInheritedDSA) {\n    if (DSAStack->getDefaultDSA() == DSA_none || DSAStack->getDefaultDSA() == DSA_private || DSAStack->getDefaultDSA() == DSA_firstprivate) {\n    } else if (getLangOpts().OpenMP >= 50) {\n      Diag(DSAStack->getDefaultDSALocation(), diag::note_omp_defaultmap_attr_none);"}}

[j]={{w,12171,"StmtResult Sema::ActOnOpenMPUnrollDirective(ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, SourceLocation EndLoc) {\n  if (FullClause) {\n    if (!VerifyPositiveIntegerConstantInClause(LoopHelper.NumIterations, OMPC_full, /*StrictlyPositive=*/false,\n      Diag(FullClause->getBeginLoc(), diag::note_omp_directive_here) << \"#pragma omp unroll full\";"}}

[j]={{N,552,"/// BuildScopeInformation - The statements from CI to CE are known to form a\n/// coherent VLA scope with a specified parent node.  Walk through the\n/// statements, adding any labels or gotos to LabelAndGotoScopes and recursively\n/// walking the AST as needed.\nvoid JumpScopeChecker::BuildScopeInformation(Stmt *S, unsigned &origParentScope) {\n  default:\n    if (auto *ED = dyn_cast<OMPExecutableDirective>(S)) {\n      if (!ED->isStandaloneDirective()) {\n        Scopes.emplace_back(ParentScope, diag::note_omp_protected_structured_block, diag::note_omp_exits_structured_block, ED->getStructuredBlock()->getBeginLoc());"},{N,860,"/// CheckJump - Validate that the specified jump statement is valid: that it is\n/// jumping within or out of its current scope, not into a deeper one.\nvoid JumpScopeChecker::CheckJump(Stmt *From, Stmt *To, SourceLocation DiagLoc, unsigned JumpDiagError, unsigned JumpDiagWarning, unsigned JumpDiagCXX98Compat) {\n  // Warn on gotos out of __finally blocks.\n  if (isa<GotoStmt>(From) || isa<IndirectGotoStmt>(From)) {\n    // If FromScope > ToScope, FromScope is more nested and the jump goes to a\n    // less nested scope.  Check if it crosses a __finally along the way.\n    for (unsigned I = FromScope; I > ToScope; I = Scopes[I].ParentScope) {\n      if (Scopes[I].InDiag == diag::note_omp_protected_structured_block) {\n        S.Diag(To->getBeginLoc(), diag::note_omp_exits_structured_block);"}}

[j]={{w,2859,"static void reportOriginalDsa(Sema &SemaRef, const DSAStackTy *Stack, const ValueDecl *D, const DSAStackTy::DSAVarData &DVar, bool IsLoopIterVar) {\n  if (DVar.RefExpr) {\n    SemaRef.Diag(DVar.RefExpr->getExprLoc(), diag::note_omp_explicit_dsa) << getOpenMPClauseName(DVar.CKind);"},{w,5467,"Sema::DeclGroupPtrTy Sema::ActOnOpenMPDeclareSimdDirective(DeclGroupPtrTy DG, OMPDeclareSimdDeclAttr::BranchStateTy BS, Expr *Simdlen, ArrayRef<Expr *> Uniforms, ArrayRef<Expr *> Aligneds, ArrayRef<Expr *> Alignments, ArrayRef<Expr *> Linears, ArrayRef<unsigned> LinModifiers, ArrayRef<Expr *> Steps, SourceRange SR) {\n  for (const Expr *E : Aligneds) {\n    if (const auto *DRE = dyn_cast<DeclRefExpr>(E))\n      if (const auto *PVD = dyn_cast<ParmVarDecl>(DRE->getDecl())) {\n        if (FD->getNumParams() > PVD->getFunctionScopeIndex() && FD->getParamDecl(PVD->getFunctionScopeIndex())->getCanonicalDecl() == CanonPVD) {\n          // OpenMP  [2.8.1, simd construct, Restrictions]\n          // A list-item cannot appear in more than one aligned clause.\n          if (AlignedArgs.count(CanonPVD) > 0) {\n            Diag(AlignedArgs[CanonPVD]->getExprLoc(), diag::note_omp_explicit_dsa) << getOpenMPClauseName(OMPC_aligned);"},{w,5483,"Sema::DeclGroupPtrTy Sema::ActOnOpenMPDeclareSimdDirective(DeclGroupPtrTy DG, OMPDeclareSimdDeclAttr::BranchStateTy BS, Expr *Simdlen, ArrayRef<Expr *> Uniforms, ArrayRef<Expr *> Aligneds, ArrayRef<Expr *> Alignments, ArrayRef<Expr *> Linears, ArrayRef<unsigned> LinModifiers, ArrayRef<Expr *> Steps, SourceRange SR) {\n  for (const Expr *E : Aligneds) {\n    if (isa<CXXThisExpr>(E)) {\n      if (AlignedThis) {\n        Diag(AlignedThis->getExprLoc(), diag::note_omp_explicit_dsa) << getOpenMPClauseName(OMPC_aligned);"},{w,5525,"Sema::DeclGroupPtrTy Sema::ActOnOpenMPDeclareSimdDirective(DeclGroupPtrTy DG, OMPDeclareSimdDeclAttr::BranchStateTy BS, Expr *Simdlen, ArrayRef<Expr *> Uniforms, ArrayRef<Expr *> Aligneds, ArrayRef<Expr *> Alignments, ArrayRef<Expr *> Linears, ArrayRef<unsigned> LinModifiers, ArrayRef<Expr *> Steps, SourceRange SR) {\n  for (const Expr *E : Linears) {\n    if (const auto *DRE = dyn_cast<DeclRefExpr>(E))\n      if (const auto *PVD = dyn_cast<ParmVarDecl>(DRE->getDecl())) {\n        if (FD->getNumParams() > PVD->getFunctionScopeIndex() && FD->getParamDecl(PVD->getFunctionScopeIndex())->getCanonicalDecl() == CanonPVD) {\n          // OpenMP  [2.15.3.7, linear Clause, Restrictions]\n          // A list-item cannot appear in more than one linear clause.\n          if (LinearArgs.count(CanonPVD) > 0) {\n            Diag(LinearArgs[CanonPVD]->getExprLoc(), diag::note_omp_explicit_dsa) << getOpenMPClauseName(OMPC_linear);"},{w,5531,"Sema::DeclGroupPtrTy Sema::ActOnOpenMPDeclareSimdDirective(DeclGroupPtrTy DG, OMPDeclareSimdDeclAttr::BranchStateTy BS, Expr *Simdlen, ArrayRef<Expr *> Uniforms, ArrayRef<Expr *> Aligneds, ArrayRef<Expr *> Alignments, ArrayRef<Expr *> Linears, ArrayRef<unsigned> LinModifiers, ArrayRef<Expr *> Steps, SourceRange SR) {\n  for (const Expr *E : Linears) {\n    if (const auto *DRE = dyn_cast<DeclRefExpr>(E))\n      if (const auto *PVD = dyn_cast<ParmVarDecl>(DRE->getDecl())) {\n        if (FD->getNumParams() > PVD->getFunctionScopeIndex() && FD->getParamDecl(PVD->getFunctionScopeIndex())->getCanonicalDecl() == CanonPVD) {\n          // Each argument can appear in at most one uniform or linear clause.\n          if (UniformedArgs.count(CanonPVD) > 0) {\n            Diag(UniformedArgs[CanonPVD]->getExprLoc(), diag::note_omp_explicit_dsa) << getOpenMPClauseName(OMPC_uniform);"},{w,5545,"Sema::DeclGroupPtrTy Sema::ActOnOpenMPDeclareSimdDirective(DeclGroupPtrTy DG, OMPDeclareSimdDeclAttr::BranchStateTy BS, Expr *Simdlen, ArrayRef<Expr *> Uniforms, ArrayRef<Expr *> Aligneds, ArrayRef<Expr *> Alignments, ArrayRef<Expr *> Linears, ArrayRef<unsigned> LinModifiers, ArrayRef<Expr *> Steps, SourceRange SR) {\n  for (const Expr *E : Linears) {\n    if (isa<CXXThisExpr>(E)) {\n      if (UniformedLinearThis) {\n        Diag(UniformedLinearThis->getExprLoc(), diag::note_omp_explicit_dsa) << getOpenMPClauseName(IsUniformedThis ? OMPC_uniform : OMPC_linear);"},{w,16627,"OMPClause *Sema::ActOnOpenMPAlignedClause(ArrayRef<Expr *> VarList, Expr *Alignment, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation ColonLoc, SourceLocation EndLoc) {\n  for (Expr *RefExpr : VarList) {\n    // OpenMP  [2.8.1, simd construct, Restrictions]\n    // A list-item cannot appear in more than one aligned clause.\n    if (const Expr *PrevRef = DSAStack->addUniqueAligned(D, SimpleRefExpr)) {\n      Diag(PrevRef->getExprLoc(), diag::note_omp_explicit_dsa) << getOpenMPClauseName(OMPC_aligned);"},{w,19425,"OMPClause *Sema::ActOnOpenMPNontemporalClause(ArrayRef<Expr *> VarList, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc) {\n  for (Expr *RefExpr : VarList) {\n    // OpenMP 5.0, 2.9.3.1 simd Construct, Restrictions.\n    // A list-item cannot appear in more than one nontemporal clause.\n    if (const Expr *PrevRef = DSAStack->addUniqueNontemporal(D, SimpleRefExpr)) {\n      Diag(PrevRef->getExprLoc(), diag::note_omp_explicit_dsa) << getOpenMPClauseName(OMPC_nontemporal);"}}

[j]={{w,8948,"StmtResult Sema::ActOnOpenMPFlushDirective(ArrayRef<OMPClause *> Clauses, SourceLocation StartLoc, SourceLocation EndLoc) {\n  if (FC && OrderClause) {\n    Diag(OrderClause->getBeginLoc(), diag::note_omp_flush_order_clause_here) << getOpenMPClauseName(OrderClause->getClauseKind());"}}

[j]={{w,2891,"static void reportOriginalDsa(Sema &SemaRef, const DSAStackTy *Stack, const ValueDecl *D, const DSAStackTy::DSAVarData &DVar, bool IsLoopIterVar) {\n  if (Reason != PDSA_Implicit) {\n  } else if (DVar.ImplicitDSALoc.isValid()) {\n    SemaRef.Diag(DVar.ImplicitDSALoc, diag::note_omp_implicit_dsa) << getOpenMPClauseName(DVar.CKind);"}}

[j]={{w,17469,"class MapBaseChecker final : public StmtVisitor<MapBaseChecker, bool> {\n  bool VisitOMPArraySectionExpr(OMPArraySectionExpr *OASE) {\n    if (const auto *TE = dyn_cast<CXXThisExpr>(E)) {\n      if (!OASE->getLength()->isValueDependent() && OASE->getLength()->EvaluateAsInt(ResultR, SemaRef.getASTContext()) && !ResultR.Val.getInt().isOne()) {\n        SemaRef.Diag(OASE->getLength()->getExprLoc(), diag::note_omp_invalid_length_on_this_ptr_mapping);"}}

[j]={{w,17473,"class MapBaseChecker final : public StmtVisitor<MapBaseChecker, bool> {\n  bool VisitOMPArraySectionExpr(OMPArraySectionExpr *OASE) {\n    if (const auto *TE = dyn_cast<CXXThisExpr>(E)) {\n      if (OASE->getLowerBound() && !OASE->getLowerBound()->isValueDependent() && OASE->getLowerBound()->EvaluateAsInt(ResultL, SemaRef.getASTContext()) && !ResultL.Val.getInt().isZero()) {\n        SemaRef.Diag(OASE->getLowerBound()->getExprLoc(), diag::note_omp_invalid_lower_bound_on_this_ptr_mapping);"}}

[j]={{w,17403,"class MapBaseChecker final : public StmtVisitor<MapBaseChecker, bool> {\n  bool VisitArraySubscriptExpr(ArraySubscriptExpr *AE) {\n    if (const auto *TE = dyn_cast<CXXThisExpr>(E->IgnoreParenCasts())) {\n      if (!AE->getIdx()->isValueDependent() && AE->getIdx()->EvaluateAsInt(Result, SemaRef.getASTContext()) && !Result.Val.getInt().isZero()) {\n        SemaRef.Diag(AE->getIdx()->getExprLoc(), diag::note_omp_invalid_subscript_on_this_ptr_map);"}}

[j]={{w,6388,"bool OpenMPIterationSpaceChecker::setStep(Expr *NewStep, bool Subtract) {\n  if (!NewStep->isValueDependent()) {\n    if (UB && (IsConstZero || (*TestIsLessOp ? (IsConstNeg || (IsUnsigned && Subtract)) : (IsConstPos || (IsUnsigned && !Subtract))))) {\n      SemaRef.Diag(ConditionLoc, diag::note_omp_loop_cond_requres_compatible_incr) << *TestIsLessOp << ConditionSrcRange;"}}

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

[j]={{w,2198,"void Sema::finalizeOpenMPDelayedAnalysis(const FunctionDecl *Caller, const FunctionDecl *Callee, SourceLocation Loc) {\n  if (LangOpts.OpenMPIsTargetDevice && DevTy && *DevTy == OMPDeclareTargetDeclAttr::DT_Host) {\n    Diag(*OMPDeclareTargetDeclAttr::getLocation(FD), diag::note_omp_marked_device_type_here) << HostDevTy;"},{w,2219,"void Sema::finalizeOpenMPDelayedAnalysis(const FunctionDecl *Caller, const FunctionDecl *Callee, SourceLocation Loc) {\n  if (!LangOpts.OpenMPIsTargetDevice && !LangOpts.OpenMPOffloadMandatory && DevTy && *DevTy == OMPDeclareTargetDeclAttr::DT_NoHost) {\n    Diag(*OMPDeclareTargetDeclAttr::getLocation(FD), diag::note_omp_marked_device_type_here) << NoHostDevTy;"}}

[j]={{w,10605,"StmtResult Sema::ActOnOpenMPTargetDirective(ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, SourceLocation EndLoc) {\n  // OpenMP [2.16, Nesting of Regions]\n  // If specified, a teams construct must be contained within a target\n  // construct. That target construct must contain no statements or directives\n  // outside of the teams construct.\n  if (DSAStack->hasInnerTeamsRegion()) {\n    if (!OMPTeamsFound) {\n      Diag(S->getBeginLoc(), diag::note_omp_nested_statement_here) << isa<OMPExecutableDirective>(S);"}}

[j]={{w,10604,"StmtResult Sema::ActOnOpenMPTargetDirective(ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, SourceLocation EndLoc) {\n  // OpenMP [2.16, Nesting of Regions]\n  // If specified, a teams construct must be contained within a target\n  // construct. That target construct must contain no statements or directives\n  // outside of the teams construct.\n  if (DSAStack->hasInnerTeamsRegion()) {\n    if (!OMPTeamsFound) {\n      Diag(DSAStack->getInnerTeamsRegionLoc(), diag::note_omp_nested_teams_construct_here);"}}

[j]={{w,8620,"StmtResult Sema::ActOnOpenMPSingleDirective(ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, SourceLocation EndLoc) {\n  for (const OMPClause *Clause : Clauses) {\n    if (Copyprivate && Nowait) {\n      Diag(Nowait->getBeginLoc(), diag::note_omp_nowait_clause_here);"}}

[j]={{w,3738,"static bool checkOrderedOrderSpecified(Sema &S, const ArrayRef<OMPClause *> Clauses) {\n  if (Ordered && Order) {\n    S.Diag(Ordered->getBeginLoc(), diag::note_omp_ordered_param) << 0 << SourceRange(Ordered->getBeginLoc(), Ordered->getEndLoc());"},{w,9061,"StmtResult Sema::ActOnOpenMPOrderedDirective(ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, SourceLocation EndLoc) {\n  if (!ErrorFound && !SC && isOpenMPSimdDirective(DSAStack->getParentDirective())) {\n  } else if ((DependFound || DoacrossFound) && (TC || SC)) {\n  } else if ((DependFound || DoacrossFound) && !DSAStack->getParentOrderedRegionParam().first) {\n  } else if (TC || Clauses.empty()) {\n    if (const Expr *Param = DSAStack->getParentOrderedRegionParam().first) {\n      Diag(Param->getBeginLoc(), diag::note_omp_ordered_param) << 1;"}}

[j]={{w,19574,"OMPClause *Sema::ActOnOpenMPUsesAllocatorClause(SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc, ArrayRef<UsesAllocatorsData> Data) {\n  for (const UsesAllocatorsData &D : Data) {\n    // Check allocator expression.\n    if (D.Allocator->isTypeDependent()) {\n    } else {\n      // OpenMP [2.12.5, target Construct]\n      // Predefined allocators appearing in a uses_allocators clause cannot have\n      // traits specified.\n      if (IsPredefinedAllocator && D.AllocatorTraits) {\n        Diag(D.Allocator->getExprLoc(), diag::note_omp_predefined_allocator) << cast<NamedDecl>(DRE->getDecl())->getName() << D.Allocator->getSourceRange();"}}

[j]={{w,2889,"static void reportOriginalDsa(Sema &SemaRef, const DSAStackTy *Stack, const ValueDecl *D, const DSAStackTy::DSAVarData &DVar, bool IsLoopIterVar) {\n  if (Reason != PDSA_Implicit) {\n    SemaRef.Diag(ReportLoc, diag::note_omp_predetermined_dsa) << Reason << ReportHint << getOpenMPDirectiveName(Stack->getCurrentDirective());"}}

[j]={{w,2685,"static bool checkPreviousOMPAllocateAttribute(Sema &S, DSAStackTy *Stack, Expr *RefExpr, VarDecl *VD, OMPAllocateDeclAttr::AllocatorTypeTy AllocatorKind, Expr *Allocator) {\n  if (!AllocatorsMatch) {\n    S.Diag(PrevAllocatorLoc, diag::note_omp_previous_allocator) << PrevAllocatorRange;"}}

[j]={{w,8844,"/// Find and diagnose mutually exclusive clause kinds.\nstatic bool checkMutuallyExclusiveClauses(Sema &S, ArrayRef<OMPClause *> Clauses, ArrayRef<OpenMPClauseKind> MutuallyExclusiveClauses) {\n  for (const OMPClause *C : Clauses) {\n    if (llvm::is_contained(MutuallyExclusiveClauses, C->getClauseKind())) {\n      if (!PrevClause) {\n      } else if (PrevClause->getClauseKind() != C->getClauseKind()) {\n        S.Diag(PrevClause->getBeginLoc(), diag::note_omp_previous_clause) << getOpenMPClauseName(PrevClause->getClauseKind());"}}

[j]={{w,3992,"static bool checkNestingOfRegions(Sema &SemaRef, const DSAStackTy *Stack, OpenMPDirectiveKind CurrentRegion, const DeclarationNameInfo &CurrentName, OpenMPDirectiveKind CancelRegion, OpenMPBindClauseKind BindKind, SourceLocation StartLoc) {\n  if (Stack->getCurScope()) {\n    if (CurrentRegion == OMPD_cancellation_point || CurrentRegion == OMPD_cancel) {\n    } else if (CurrentRegion == OMPD_master || CurrentRegion == OMPD_masked) {\n    } else if (CurrentRegion == OMPD_critical && CurrentName.getName()) {\n      if (DeadLock) {\n        if (PreviousCriticalLoc.isValid())\n          SemaRef.Diag(PreviousCriticalLoc, diag::note_omp_previous_critical_region);"}}

[j]={{w,8989,"StmtResult Sema::ActOnOpenMPScanDirective(ArrayRef<OMPClause *> Clauses, SourceLocation StartLoc, SourceLocation EndLoc) {\n  // Check that only one instance of scan directives is used in the same outer\n  // region.\n  if (DSAStack->doesParentHasScanDirective()) {\n    Diag(DSAStack->getParentScanDirectiveLoc(), diag::note_omp_previous_directive) << \"scan\";"},{w,9076,"StmtResult Sema::ActOnOpenMPOrderedDirective(ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, SourceLocation EndLoc) {\n  // OpenMP 5.0, 2.17.9, ordered Construct, Restrictions.\n  // During execution of an iteration of a worksharing-loop or a loop nest\n  // within a worksharing-loop, simd, or worksharing-loop SIMD region, a thread\n  // must not execute more than one ordered region corresponding to an ordered\n  // construct without a depend clause.\n  if (!DependFound && !DoacrossFound) {\n    if (DSAStack->doesParentHasOrderedDirective()) {\n      Diag(DSAStack->getParentOrderedDirectiveLoc(), diag::note_omp_previous_directive) << \"ordered\";"}}

[j]={{w,2273,"/// Check consistency of the reduction clauses.\nstatic void checkReductionClauses(Sema &S, DSAStackTy *Stack, ArrayRef<OMPClause *> Clauses) {\n  if (InscanFound) {\n    for (OMPClause *C : Clauses) {\n      if (RC->getModifier() != OMPC_REDUCTION_inscan) {\n        S.Diag(InscanLoc, diag::note_omp_previous_inscan_reduction);"}}

[j]={{w,8939,"StmtResult Sema::ActOnOpenMPFlushDirective(ArrayRef<OMPClause *> Clauses, SourceLocation StartLoc, SourceLocation EndLoc) {\n  for (const OMPClause *C : Clauses) {\n    if (C->getClauseKind() == OMPC_acq_rel || C->getClauseKind() == OMPC_acquire || C->getClauseKind() == OMPC_release) {\n      if (MemOrderKind != OMPC_unknown) {\n        Diag(MemOrderLoc, diag::note_omp_previous_mem_order_clause) << getOpenMPClauseName(MemOrderKind);"},{w,10129,"StmtResult Sema::ActOnOpenMPAtomicDirective(ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, SourceLocation EndLoc) {\n  for (const OMPClause *C : Clauses) {\n    case OMPC_compare: {\n      if (AtomicKind != OMPC_unknown && MutexClauseEncountered) {\n        Diag(AtomicKindLoc, diag::note_omp_previous_mem_order_clause) << getOpenMPClauseName(AtomicKind);"},{w,10135,"StmtResult Sema::ActOnOpenMPAtomicDirective(ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, SourceLocation EndLoc) {\n  for (const OMPClause *C : Clauses) {\n    case OMPC_compare: {\n      if (AtomicKind != OMPC_unknown && MutexClauseEncountered) {\n      } else {\n        if (!EncounteredAtomicKinds.insert(C->getClauseKind()).second) {\n          Diag(AtomicKindLoc, diag::note_omp_previous_mem_order_clause) << getOpenMPClauseName(AtomicKind);"},{w,10147,"StmtResult Sema::ActOnOpenMPAtomicDirective(ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, SourceLocation EndLoc) {\n  for (const OMPClause *C : Clauses) {\n    case OMPC_relaxed: {\n      if (MemOrderKind != OMPC_unknown) {\n        Diag(MemOrderLoc, diag::note_omp_previous_mem_order_clause) << getOpenMPClauseName(MemOrderKind);"},{w,10178,"StmtResult Sema::ActOnOpenMPAtomicDirective(ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, SourceLocation EndLoc) {\n  // OpenMP 5.0, 2.17.7 atomic Construct, Restrictions\n  // If atomic-clause is read then memory-order-clause must not be acq_rel or\n  // release.\n  // If atomic-clause is write then memory-order-clause must not be acq_rel or\n  // acquire.\n  // If atomic-clause is update or not present then memory-order-clause must not\n  // be acq_rel or acquire.\n  if ((AtomicKind == OMPC_read && (MemOrderKind == OMPC_acq_rel || MemOrderKind == OMPC_release)) || ((AtomicKind == OMPC_write || AtomicKind == OMPC_update || AtomicKind == OMPC_unknown) && (MemOrderKind == OMPC_acq_rel || MemOrderKind == OMPC_acquire))) {\n    Diag(MemOrderLoc, diag::note_omp_previous_mem_order_clause) << getOpenMPClauseName(MemOrderKind);"}}

[j]={{w,4150,"static bool checkIfClauses(Sema &S, OpenMPDirectiveKind Kind, ArrayRef<OMPClause *> Clauses, ArrayRef<OpenMPDirectiveKind> AllowedNameModifiers) {\n  // If any if clause on the directive includes a directive-name-modifier then\n  // all if clauses on the directive must include a directive-name-modifier.\n  if (FoundNameModifiers[OMPD_unknown] && NamedModifiersNumber > 0) {\n    for (SourceLocation Loc : NameModifierLoc) {\n      S.Diag(Loc, diag::note_omp_previous_named_if_clause);"}}

[j]={{w,16253,"static bool actOnOMPReductionKindClause(Sema &S, DSAStackTy *Stack, OpenMPClauseKind ClauseKind, ArrayRef<Expr *> VarList, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation ColonLoc, SourceLocation EndLoc, CXXScopeSpec &ReductionIdScopeSpec, const DeclarationNameInfo &ReductionId, ArrayRef<Expr *> UnresolvedReductions, ReductionData &RD) {\n  for (Expr *RefExpr : VarList) {\n    // OpenMP [2.15.4.6, Restrictions, p.2]\n    // A list item that appears in an in_reduction clause of a task construct\n    // must appear in a task_reduction clause of a construct associated with a\n    // taskgroup region that includes the participating task in its taskgroup\n    // set. The construct associated with the innermost region that meets this\n    // condition must specify the same reduction-identifier as the in_reduction\n    // clause.\n    if (ClauseKind == OMPC_in_reduction) {\n      if ((DeclareReductionRef.isUnset() && IsParentReductionOp) || (DeclareReductionRef.isUsable() && IsParentBOK) || (IsParentBOK && BOK != ParentBOK) || IsParentReductionOp) {\n        if (EmitError) {\n          S.Diag(ParentSR.getBegin(), diag::note_omp_previous_reduction_identifier) << ParentSR << (IsParentBOK ? ParentBOKDSA.RefExpr : ParentReductionOpDSA.RefExpr)->getSourceRange();"}}

[j]={{N,552,"/// BuildScopeInformation - The statements from CI to CE are known to form a\n/// coherent VLA scope with a specified parent node.  Walk through the\n/// statements, adding any labels or gotos to LabelAndGotoScopes and recursively\n/// walking the AST as needed.\nvoid JumpScopeChecker::BuildScopeInformation(Stmt *S, unsigned &origParentScope) {\n  default:\n    if (auto *ED = dyn_cast<OMPExecutableDirective>(S)) {\n      if (!ED->isStandaloneDirective()) {\n        Scopes.emplace_back(ParentScope, diag::note_omp_protected_structured_block, diag::note_omp_exits_structured_block, ED->getStructuredBlock()->getBeginLoc());"},{N,858,"/// CheckJump - Validate that the specified jump statement is valid: that it is\n/// jumping within or out of its current scope, not into a deeper one.\nvoid JumpScopeChecker::CheckJump(Stmt *From, Stmt *To, SourceLocation DiagLoc, unsigned JumpDiagError, unsigned JumpDiagWarning, unsigned JumpDiagCXX98Compat) {\n  // Warn on gotos out of __finally blocks.\n  if (isa<GotoStmt>(From) || isa<IndirectGotoStmt>(From)) {\n    // If FromScope > ToScope, FromScope is more nested and the jump goes to a\n    // less nested scope.  Check if it crosses a __finally along the way.\n    for (unsigned I = FromScope; I > ToScope; I = Scopes[I].ParentScope) {\n      if (Scopes[I].InDiag == diag::note_omp_protected_structured_block) {"}}

[j]={{w,15905,"static bool actOnOMPReductionKindClause(Sema &S, DSAStackTy *Stack, OpenMPClauseKind ClauseKind, ArrayRef<Expr *> VarList, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation ColonLoc, SourceLocation EndLoc, CXXScopeSpec &ReductionIdScopeSpec, const DeclarationNameInfo &ReductionId, ArrayRef<Expr *> UnresolvedReductions, ReductionData &RD) {\n  for (Expr *RefExpr : VarList) {\n    // OpenMP [2.9.3.6, Restrictions, C/C++, p.4]\n    //  If a list-item is a reference type then it must bind to the same object\n    //  for all threads of the team.\n    if (!ASE && !OASE) {\n      if (DVar.CKind == OMPC_reduction) {\n        if (DVar.RefExpr)\n          S.Diag(DVar.RefExpr->getExprLoc(), diag::note_omp_referenced);"}}

[j]={{w,2843,"OMPRequiresDecl *Sema::CheckOMPRequiresDecl(SourceLocation Loc, ArrayRef<OMPClause *> ClauseList) {\n  if (!TargetLocations.empty() || !AtomicLoc.isInvalid()) {\n    for (const OMPClause *CNew : ClauseList) {\n      // Check if any of the requires clauses affect target regions.\n      if (isa<OMPUnifiedSharedMemoryClause>(CNew) || isa<OMPUnifiedAddressClause>(CNew) || isa<OMPReverseOffloadClause>(CNew) || isa<OMPDynamicAllocatorsClause>(CNew)) {\n        for (SourceLocation TargetLoc : TargetLocations) {\n          Diag(TargetLoc, diag::note_omp_requires_encountered_directive) << \"target\";"},{w,2847,"OMPRequiresDecl *Sema::CheckOMPRequiresDecl(SourceLocation Loc, ArrayRef<OMPClause *> ClauseList) {\n  if (!TargetLocations.empty() || !AtomicLoc.isInvalid()) {\n    for (const OMPClause *CNew : ClauseList) {\n      // Check if any of the requires clauses affect target regions.\n      if (isa<OMPUnifiedSharedMemoryClause>(CNew) || isa<OMPUnifiedAddressClause>(CNew) || isa<OMPReverseOffloadClause>(CNew) || isa<OMPDynamicAllocatorsClause>(CNew)) {\n      } else if (!AtomicLoc.isInvalid() && isa<OMPAtomicDefaultMemOrderClause>(CNew)) {\n        Diag(AtomicLoc, diag::note_omp_requires_encountered_directive) << \"atomic\";"}}

[j]={{w,558,"/// Stack for tracking declarations used in OpenMP directives and\n/// clauses and their data-sharing attributes.\nclass DSAStackTy {\n  /// Checks for a duplicate clause amongst previously declared requires\n  /// directives\n  bool hasDuplicateRequiresClause(ArrayRef<OMPClause *> ClauseList) const {\n    for (OMPClause *CNew : ClauseList) {\n      for (const OMPRequiresDecl *D : RequiresDecls) {\n        for (const OMPClause *CPrev : D->clauselists()) {\n          if (CNew->getClauseKind() == CPrev->getClauseKind()) {\n            SemaRef.Diag(CPrev->getBeginLoc(), diag::note_omp_requires_previous_clause) << getOpenMPClauseName(CPrev->getClauseKind());"}}

[j]={{w,15085,"OMPClause *Sema::ActOnOpenMPFirstprivateClause(ArrayRef<Expr *> VarList, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc) {\n  for (Expr *RefExpr : VarList) {\n    if (VDPrivate->isInvalidDecl()) {\n      if (IsImplicitClause) {\n        Diag(RefExpr->getExprLoc(), diag::note_omp_task_predetermined_firstprivate_here);"}}

[j]={{hb,7463,"#include \"clang/Basic/OpenCLImageTypes.def\"\n    S.Diag(TypedefTy->getDecl()->getBeginLoc(), diag::note_opencl_typedef_access_qualifier) << PrevAccessQual;"}}

[j]={{Ub,6582,"ExprResult Sema::ActOnStartCXXMemberReference(Scope *S, Expr *Base, SourceLocation OpLoc, tok::TokenKind OpKind, ParsedType &ObjectType, bool &MayBePseudoDestructor) {\n  // C++ [over.match.oper]p8:\n  //  [...] When operator->returns, the operator-> is applied  to the value\n  //  returned, with the original second operand.\n  if (OpKind == tok::arrow) {\n    while (BaseType->isRecordType()) {\n      if (OperatorArrows.size() >= getLangOpts().ArrowDepth) {\n        Diag(OpLoc, diag::note_operator_arrow_depth) << getLangOpts().ArrowDepth;"}}

[j]={{Ub,6532,"/// Note a set of \'operator->\' functions that were used for a member access.\nstatic void noteOperatorArrows(Sema &S, ArrayRef<FunctionDecl *> OperatorArrows) {\n  for (unsigned I = 0; I < OperatorArrows.size(); /**/) {\n    if (I == SkipStart) {\n    } else {\n      S.Diag(OperatorArrows[I]->getLocation(), diag::note_operator_arrow_here) << OperatorArrows[I]->getCallResultType();"}}

[j]={{Ub,6529,"/// Note a set of \'operator->\' functions that were used for a member access.\nstatic void noteOperatorArrows(Sema &S, ArrayRef<FunctionDecl *> OperatorArrows) {\n  for (unsigned I = 0; I < OperatorArrows.size(); /**/) {\n    if (I == SkipStart) {\n      S.Diag(OperatorArrows[I]->getLocation(), diag::note_operator_arrows_suppressed) << SkipCount;"}}

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

[j]={{u,2270,"AvailabilityAttr *Sema::mergeAvailabilityAttr(NamedDecl *D, const AttributeCommonInfo &CI, IdentifierInfo *Platform, bool Implicit, VersionTuple Introduced, VersionTuple Deprecated, VersionTuple Obsoleted, bool IsUnavailable, StringRef Message, bool IsStrict, StringRef Replacement, AvailabilityMergeKind AMK, int Priority) {\n  if (D->hasAttrs()) {\n    for (unsigned i = 0, e = Attrs.size(); i != e;) {\n      if (!versionsMatch(OldIntroduced, Introduced, OverrideOrImpl) || !versionsMatch(Deprecated, OldDeprecated, OverrideOrImpl) || !versionsMatch(Obsoleted, OldObsoleted, OverrideOrImpl) || !(OldIsUnavailable == IsUnavailable || (OverrideOrImpl && !OldIsUnavailable && IsUnavailable))) {\n        if (OverrideOrImpl) {\n          if (AMK == AMK_Override)\n            Diag(CI.getLoc(), diag::note_overridden_method);"}}

[j]={{v,16631,"void Sema::ActOnFields(Scope *S, SourceLocation RecLoc, Decl *EnclosingDecl, ArrayRef<Decl *> Fields, SourceLocation LBrac, SourceLocation RBrac, const ParsedAttributesView &Attrs) {\n  // Okay, we successfully defined \'Record\'.\n  if (Record) {\n    if (CXXRecord) {\n      if (!CXXRecord->isDependentType()) {\n        if (!CXXRecord->isInvalidDecl()) {\n          // If we have virtual base classes, we may end up finding multiple\n          // final overriders for a given virtual function. Check for this\n          // problem now.\n          if (CXXRecord->getNumVBases()) {\n            for (CXXFinalOverriderMap::iterator M = FinalOverriders.begin(), MEnd = FinalOverriders.end(); M != MEnd; ++M) {\n              for (OverridingMethods::iterator SO = M->second.begin(), SOEnd = M->second.end(); SO != SOEnd; ++SO) {\n                Diag(M->first->getLocation(), diag::note_overridden_virtual_function);"},{y,1558,"// Check whether a function declaration satisfies the requirements of a\n// constexpr function definition or a constexpr constructor definition. If so,\n// return true. If not, produce appropriate diagnostics (unless asked not to by\n// Kind) and return false.\n//\n// This implements C++11 [dcl.constexpr]p3,4, as amended by DR1360.\nbool Sema::CheckConstexprFunctionDefinition(const FunctionDecl *NewFD, CheckConstexprKind Kind) {\n  if (!isa<CXXConstructorDecl>(NewFD)) {\n    if (Method && Method->isVirtual()) {\n      if (getLangOpts().CPlusPlus20) {\n      } else {\n        if (WrittenVirtual != Method)\n          Diag(WrittenVirtual->getLocation(), diag::note_overridden_virtual_function);"},{y,2816,"void Sema::DiagnoseAbsenceOfOverrideControl(NamedDecl *D, bool Inconsistent) {\n  if (MD->size_overridden_methods() > 0) {\n    auto EmitDiag = [&](unsigned DiagInconsistent, unsigned DiagSuggest) {\n      Diag(OMD->getLocation(), diag::note_overridden_virtual_function);"},{y,2834,"/// CheckIfOverriddenFunctionIsMarkedFinal - Checks whether a virtual member\n/// function overrides a virtual member function marked \'final\', according to\n/// C++11 [class.virtual]p4.\nbool Sema::CheckIfOverriddenFunctionIsMarkedFinal(const CXXMethodDecl *New, const CXXMethodDecl *Old) {\n  Diag(Old->getLocation(), diag::note_overridden_virtual_function);"},{y,5887,"/// Report an error regarding overriding, along with any relevant\n/// overridden methods.\n///\n/// \\param DiagID the primary error to report.\n/// \\param MD the overriding method.\nstatic bool ReportOverrides(Sema &S, unsigned DiagID, const CXXMethodDecl *MD, llvm::function_ref<bool(const CXXMethodDecl *)> Report) {\n  for (const CXXMethodDecl *O : MD->overridden_methods()) {\n    if (Report(O)) {\n      S.Diag(O->getLocation(), diag::note_overridden_virtual_function);"},{y,15397,"bool Sema::CheckOverridingFunctionAttributes(const CXXMethodDecl *New, const CXXMethodDecl *Old) {\n  Diag(Old->getLocation(), diag::note_overridden_virtual_function);"},{y,15429,"bool Sema::CheckOverridingFunctionReturnType(const CXXMethodDecl *New, const CXXMethodDecl *Old) {\n  // The return types aren\'t either both pointers or references to a class type.\n  if (NewClassTy.isNull()) {\n    Diag(Old->getLocation(), diag::note_overridden_virtual_function) << Old->getReturnTypeSourceRange();"},{y,15448,"bool Sema::CheckOverridingFunctionReturnType(const CXXMethodDecl *New, const CXXMethodDecl *Old) {\n  if (!Context.hasSameUnqualifiedType(NewClassTy, OldClassTy)) {\n    // Check if the new class derives from the old class.\n    if (!IsDerivedFrom(New->getLocation(), NewClassTy, OldClassTy)) {\n      Diag(Old->getLocation(), diag::note_overridden_virtual_function) << Old->getReturnTypeSourceRange();"},{y,15458,"bool Sema::CheckOverridingFunctionReturnType(const CXXMethodDecl *New, const CXXMethodDecl *Old) {\n  if (!Context.hasSameUnqualifiedType(NewClassTy, OldClassTy)) {\n    // Check if we the conversion from derived to base is valid.\n    if (CheckDerivedToBaseConversion(NewClassTy, OldClassTy, diag::err_covariant_return_inaccessible_base, diag::err_covariant_return_ambiguous_derived_to_base_conv, New->getLocation(), New->getReturnTypeSourceRange(), New->getDeclName(), nullptr)) {\n      Diag(Old->getLocation(), diag::note_overridden_virtual_function) << Old->getReturnTypeSourceRange();"},{y,15466,"bool Sema::CheckOverridingFunctionReturnType(const CXXMethodDecl *New, const CXXMethodDecl *Old) {\n  // The qualifiers of the return types must be the same.\n  if (NewTy.getLocalCVRQualifiers() != OldTy.getLocalCVRQualifiers()) {\n    Diag(Old->getLocation(), diag::note_overridden_virtual_function) << Old->getReturnTypeSourceRange();"},{y,15473,"bool Sema::CheckOverridingFunctionReturnType(const CXXMethodDecl *New, const CXXMethodDecl *Old) {\n  // The new class type must have the same or less qualifiers as the old type.\n  if (NewClassTy.isMoreQualifiedThan(OldClassTy)) {\n    Diag(Old->getLocation(), diag::note_overridden_virtual_function) << Old->getReturnTypeSourceRange();"},{vc,879,"bool Sema::CheckOverridingFunctionExceptionSpec(const CXXMethodDecl *New, const CXXMethodDecl *Old) {\n  return CheckExceptionSpecSubset(PDiag(DiagID), PDiag(diag::err_deep_exception_specs_differ), PDiag(diag::note_overridden_virtual_function), PDiag(diag::ext_override_exception_spec), Old->getType()->castAs<FunctionProtoType>(), Old->getLocation(), New->getType()->castAs<FunctionProtoType>(), New->getLocation());"}}

[j]={{D,11923,"/// Create a binary operation that may resolve to an overloaded\n/// operator.\n///\n/// \\param OpLoc The location of the operator itself (e.g., \'+\').\n///\n/// \\param Opc The BinaryOperatorKind that describes this operator.\n///\n/// \\param Fns The set of non-member functions that will be\n/// considered by overload resolution. The caller needs to build this\n/// set based on the context using, e.g.,\n/// LookupOverloadedOperatorName() and ArgumentDependentLookup(). This\n/// set should not contain any member functions; those will be added\n/// by CreateOverloadedBinOp().\n///\n/// \\param LHS Left-hand argument.\n/// \\param RHS Right-hand argument.\n/// \\param PerformADL Whether to consider operator candidates found by ADL.\n/// \\param AllowRewrittenCandidates Whether to consider candidates found by\n///        C++20 operator rewrites.\n/// \\param DefaultedFn If we are synthesizing a defaulted operator function,\n///        the function in question. Such a function is never a candidate in\n///        our overload resolution. This also enables synthesizing a three-way\n///        comparison from < and == as described in C++20 [class.spaceship]p1.\nExprResult Sema::CreateOverloadedBinOp(SourceLocation OpLoc, BinaryOperatorKind Opc, const UnresolvedSetImpl &Fns, Expr *LHS, Expr *RHS, bool PerformADL, bool AllowRewrittenCandidates, FunctionDecl *DefaultedFn) {\n  case OR_Success: {\n    if (FnDecl) {\n      if (AllowRewrittenCandidates && !IsReversed && CandidateSet.getRewriteInfo().isReversible()) {\n        if (!AmbiguousWith.empty()) {\n          if (AmbiguousWithSelf) {\n            // Mark member== const or provide matching != to disallow reversed\n            // args. Eg.\n            // struct S { bool operator==(const S&); };\n            // S()==S();\n            if (auto *MD = dyn_cast<CXXMethodDecl>(FnDecl))\n              if (Op == OverloadedOperatorKind::OO_EqualEqual && !MD->isConst() && Context.hasSameUnqualifiedType(MD->getThisObjectType(), MD->getParamDecl(0)->getType().getNonReferenceType()) && Context.hasSameUnqualifiedType(MD->getThisObjectType(), Args[0]->getType()) && Context.hasSameUnqualifiedType(MD->getThisObjectType(), Args[1]->getType()))\n                Diag(FnDecl->getLocation(), diag::note_ovl_ambiguous_eqeq_reversed_self_non_const);"}}

[j]={{D,11927,"/// Create a binary operation that may resolve to an overloaded\n/// operator.\n///\n/// \\param OpLoc The location of the operator itself (e.g., \'+\').\n///\n/// \\param Opc The BinaryOperatorKind that describes this operator.\n///\n/// \\param Fns The set of non-member functions that will be\n/// considered by overload resolution. The caller needs to build this\n/// set based on the context using, e.g.,\n/// LookupOverloadedOperatorName() and ArgumentDependentLookup(). This\n/// set should not contain any member functions; those will be added\n/// by CreateOverloadedBinOp().\n///\n/// \\param LHS Left-hand argument.\n/// \\param RHS Right-hand argument.\n/// \\param PerformADL Whether to consider operator candidates found by ADL.\n/// \\param AllowRewrittenCandidates Whether to consider candidates found by\n///        C++20 operator rewrites.\n/// \\param DefaultedFn If we are synthesizing a defaulted operator function,\n///        the function in question. Such a function is never a candidate in\n///        our overload resolution. This also enables synthesizing a three-way\n///        comparison from < and == as described in C++20 [class.spaceship]p1.\nExprResult Sema::CreateOverloadedBinOp(SourceLocation OpLoc, BinaryOperatorKind Opc, const UnresolvedSetImpl &Fns, Expr *LHS, Expr *RHS, bool PerformADL, bool AllowRewrittenCandidates, FunctionDecl *DefaultedFn) {\n  case OR_Success: {\n    if (FnDecl) {\n      if (AllowRewrittenCandidates && !IsReversed && CandidateSet.getRewriteInfo().isReversible()) {\n        if (!AmbiguousWith.empty()) {\n          if (AmbiguousWithSelf) {\n          } else {\n            for (auto *F : AmbiguousWith)\n              Diag(F->getLocation(), diag::note_ovl_ambiguous_oper_binary_reversed_candidate);"}}

[j]={{D,11916,"/// Create a binary operation that may resolve to an overloaded\n/// operator.\n///\n/// \\param OpLoc The location of the operator itself (e.g., \'+\').\n///\n/// \\param Opc The BinaryOperatorKind that describes this operator.\n///\n/// \\param Fns The set of non-member functions that will be\n/// considered by overload resolution. The caller needs to build this\n/// set based on the context using, e.g.,\n/// LookupOverloadedOperatorName() and ArgumentDependentLookup(). This\n/// set should not contain any member functions; those will be added\n/// by CreateOverloadedBinOp().\n///\n/// \\param LHS Left-hand argument.\n/// \\param RHS Right-hand argument.\n/// \\param PerformADL Whether to consider operator candidates found by ADL.\n/// \\param AllowRewrittenCandidates Whether to consider candidates found by\n///        C++20 operator rewrites.\n/// \\param DefaultedFn If we are synthesizing a defaulted operator function,\n///        the function in question. Such a function is never a candidate in\n///        our overload resolution. This also enables synthesizing a three-way\n///        comparison from < and == as described in C++20 [class.spaceship]p1.\nExprResult Sema::CreateOverloadedBinOp(SourceLocation OpLoc, BinaryOperatorKind Opc, const UnresolvedSetImpl &Fns, Expr *LHS, Expr *RHS, bool PerformADL, bool AllowRewrittenCandidates, FunctionDecl *DefaultedFn) {\n  case OR_Success: {\n    if (FnDecl) {\n      if (AllowRewrittenCandidates && !IsReversed && CandidateSet.getRewriteInfo().isReversible()) {\n        if (!AmbiguousWith.empty()) {\n          if (AmbiguousWithSelf) {\n            Diag(FnDecl->getLocation(), diag::note_ovl_ambiguous_oper_binary_reversed_self);"}}

[j]={{D,11925,"/// Create a binary operation that may resolve to an overloaded\n/// operator.\n///\n/// \\param OpLoc The location of the operator itself (e.g., \'+\').\n///\n/// \\param Opc The BinaryOperatorKind that describes this operator.\n///\n/// \\param Fns The set of non-member functions that will be\n/// considered by overload resolution. The caller needs to build this\n/// set based on the context using, e.g.,\n/// LookupOverloadedOperatorName() and ArgumentDependentLookup(). This\n/// set should not contain any member functions; those will be added\n/// by CreateOverloadedBinOp().\n///\n/// \\param LHS Left-hand argument.\n/// \\param RHS Right-hand argument.\n/// \\param PerformADL Whether to consider operator candidates found by ADL.\n/// \\param AllowRewrittenCandidates Whether to consider candidates found by\n///        C++20 operator rewrites.\n/// \\param DefaultedFn If we are synthesizing a defaulted operator function,\n///        the function in question. Such a function is never a candidate in\n///        our overload resolution. This also enables synthesizing a three-way\n///        comparison from < and == as described in C++20 [class.spaceship]p1.\nExprResult Sema::CreateOverloadedBinOp(SourceLocation OpLoc, BinaryOperatorKind Opc, const UnresolvedSetImpl &Fns, Expr *LHS, Expr *RHS, bool PerformADL, bool AllowRewrittenCandidates, FunctionDecl *DefaultedFn) {\n  case OR_Success: {\n    if (FnDecl) {\n      if (AllowRewrittenCandidates && !IsReversed && CandidateSet.getRewriteInfo().isReversible()) {\n        if (!AmbiguousWith.empty()) {\n          if (AmbiguousWithSelf) {\n          } else {\n            Diag(FnDecl->getLocation(), diag::note_ovl_ambiguous_oper_binary_selected_candidate);"}}

[j]={{D,9921,"static void NoteBuiltinOperatorCandidate(Sema &S, StringRef Opc, SourceLocation OpLoc, OverloadCandidate *Cand) {\n  if (Cand->Conversions.size() == 1) {\n    S.Diag(OpLoc, diag::note_ovl_builtin_candidate) << TypeStr;"},{D,9926,"static void NoteBuiltinOperatorCandidate(Sema &S, StringRef Opc, SourceLocation OpLoc, OverloadCandidate *Cand) {\n  if (Cand->Conversions.size() == 1) {\n  } else {\n    S.Diag(OpLoc, diag::note_ovl_builtin_candidate) << TypeStr;"}}

[j]={{D,9093,"// Notes the location of an overload candidate.\nvoid Sema::NoteOverloadCandidate(const NamedDecl *Found, const FunctionDecl *Fn, OverloadCandidateRewriteKind RewriteKind, QualType DestType, bool TakingAddress) {\n  PartialDiagnostic PD = PDiag(diag::note_ovl_candidate) << (unsigned)KSPair.first << (unsigned)KSPair.second << Fn << FnDesc;"},{D,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);"}}

[j]={{D,9411,"/// General arity mismatch diagnosis over a candidate in a candidate set.\nstatic void DiagnoseArityMismatch(Sema &S, NamedDecl *Found, Decl *D, unsigned NumFormalArgs) {\n  if (modeCount == 1 && Fn->getParamDecl(0)->getDeclName())\n  else\n    S.Diag(Fn->getLocation(), diag::note_ovl_candidate_arity) << (unsigned)FnKindPair.first << (unsigned)FnKindPair.second << Description << mode << modeCount << NumFormalArgs << Fn->getParametersSourceRange();"}}

[j]={{D,9409,"/// General arity mismatch diagnosis over a candidate in a candidate set.\nstatic void DiagnoseArityMismatch(Sema &S, NamedDecl *Found, Decl *D, unsigned NumFormalArgs) {\n  if (modeCount == 1 && Fn->getParamDecl(0)->getDeclName())\n    S.Diag(Fn->getLocation(), diag::note_ovl_candidate_arity_one) << (unsigned)FnKindPair.first << (unsigned)FnKindPair.second << Description << mode << Fn->getParamDecl(0) << NumFormalArgs << Fn->getParametersSourceRange();"}}

[j]={{D,9242,"static void DiagnoseBadConversion(Sema &S, OverloadCandidate *Cand, unsigned I, bool TakingCandidateAddress) {\n  if (CToTy.getUnqualifiedType() == CFromTy.getUnqualifiedType() && !CToTy.isAtLeastAsQualifiedAs(CFromTy)) {\n    if (FromQs.getAddressSpace() != ToQs.getAddressSpace()) {\n      if (isObjectArgument)\n      else\n        S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_addrspace) << (unsigned)FnKindPair.first << (unsigned)FnKindPair.second << FnDesc << ToParamRange << FromQs.getAddressSpace() << ToQs.getAddressSpace() << ToTy->isReferenceType() << I + 1;"}}

[j]={{D,9240,"static void DiagnoseBadConversion(Sema &S, OverloadCandidate *Cand, unsigned I, bool TakingCandidateAddress) {\n  if (CToTy.getUnqualifiedType() == CFromTy.getUnqualifiedType() && !CToTy.isAtLeastAsQualifiedAs(CFromTy)) {\n    if (FromQs.getAddressSpace() != ToQs.getAddressSpace()) {\n      if (isObjectArgument)\n        S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_addrspace_this) << (unsigned)FnKindPair.first << (unsigned)FnKindPair.second << FnDesc << FromQs.getAddressSpace() << ToQs.getAddressSpace();"}}

[j]={{D,9328,"static void DiagnoseBadConversion(Sema &S, OverloadCandidate *Cand, unsigned I, bool TakingCandidateAddress) {\n  if (isa<ObjCObjectPointerType>(CFromTy) && isa<PointerType>(CToTy)) {\n    if (FromQs.getObjCLifetime() != ToQs.getObjCLifetime()) {\n      S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_arc_conv) << (unsigned)FnKindPair.first << (unsigned)FnKindPair.second << FnDesc << ToParamRange << FromTy << ToTy << (unsigned)isObjectArgument << I + 1;"}}

[j]={{D,9319,"static void DiagnoseBadConversion(Sema &S, OverloadCandidate *Cand, unsigned I, bool TakingCandidateAddress) {\n  if (BaseToDerivedConversion) {\n    S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_base_to_derived_conv) << (unsigned)FnKindPair.first << (unsigned)FnKindPair.second << FnDesc << ToParamRange << (BaseToDerivedConversion - 1) << FromTy << ToTy << I + 1;"}}

[j]={{D,9338,"static void DiagnoseBadConversion(Sema &S, OverloadCandidate *Cand, unsigned I, bool TakingCandidateAddress) {\n  PartialDiagnostic FDiag = S.PDiag(diag::note_ovl_candidate_bad_conv);"}}

[j]={{D,9293,"static void DiagnoseBadConversion(Sema &S, OverloadCandidate *Cand, unsigned I, bool TakingCandidateAddress) {\n  if (TempFromTy->isIncompleteType()) {\n    S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_conv_incomplete) << (unsigned)FnKindPair.first << (unsigned)FnKindPair.second << FnDesc << ToParamRange << FromTy << ToTy << (unsigned)isObjectArgument << I + 1 << (unsigned)(Cand->Fix.Kind);"}}

[j]={{D,9265,"static void DiagnoseBadConversion(Sema &S, OverloadCandidate *Cand, unsigned I, bool TakingCandidateAddress) {\n  if (CToTy.getUnqualifiedType() == CFromTy.getUnqualifiedType() && !CToTy.isAtLeastAsQualifiedAs(CFromTy)) {\n    if (isObjectArgument) {\n    } else {\n      S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_cvr) << (unsigned)FnKindPair.first << (unsigned)FnKindPair.second << FnDesc << ToParamRange << FromTy << (CVR - 1) << I + 1;"}}

[j]={{D,9263,"static void DiagnoseBadConversion(Sema &S, OverloadCandidate *Cand, unsigned I, bool TakingCandidateAddress) {\n  if (CToTy.getUnqualifiedType() == CFromTy.getUnqualifiedType() && !CToTy.isAtLeastAsQualifiedAs(CFromTy)) {\n    if (isObjectArgument) {\n      S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_cvr_this) << (unsigned)FnKindPair.first << (unsigned)FnKindPair.second << FnDesc << FromTy << (CVR - 1);"}}

[j]={{D,9640,"/// Diagnose a failed template-argument deduction.\nstatic void DiagnoseBadDeduction(Sema &S, NamedDecl *Found, Decl *Templated, DeductionFailureInfo &DeductionFailure, unsigned NumArgs, bool TakingCandidateAddress) {\n  // TODO: diagnose these individually, then kill off\n  // note_ovl_candidate_bad_deduction, which is uselessly vague.\n  case Sema::TDK_MiscellaneousDeductionFailure:\n    S.Diag(Templated->getLocation(), diag::note_ovl_candidate_bad_deduction);"}}

[j]={{D,9254,"static void DiagnoseBadConversion(Sema &S, OverloadCandidate *Cand, unsigned I, bool TakingCandidateAddress) {\n  if (CToTy.getUnqualifiedType() == CFromTy.getUnqualifiedType() && !CToTy.isAtLeastAsQualifiedAs(CFromTy)) {\n    if (FromQs.getObjCGCAttr() != ToQs.getObjCGCAttr()) {\n      S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_gc) << (unsigned)FnKindPair.first << (unsigned)FnKindPair.second << FnDesc << ToParamRange << FromTy << FromQs.getObjCGCAttr() << ToQs.getObjCGCAttr() << (unsigned)isObjectArgument << I + 1;"}}

[j]={{D,9280,"static void DiagnoseBadConversion(Sema &S, OverloadCandidate *Cand, unsigned I, bool TakingCandidateAddress) {\n  // Special diagnostic for failure to convert an initializer list, since\n  // telling the user that it has type void is not useful.\n  if (FromExpr && isa<InitListExpr>(FromExpr)) {\n    S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_list_argument) << (unsigned)FnKindPair.first << (unsigned)FnKindPair.second << FnDesc << ToParamRange << FromTy << ToTy << (unsigned)isObjectArgument << I + 1 << (Conv.Bad.Kind == BadConversionSequence::too_few_initializers ? 1 : Conv.Bad.Kind == BadConversionSequence::too_many_initializers ? 2 : 0);"}}

[j]={{D,9214,"static void DiagnoseBadConversion(Sema &S, OverloadCandidate *Cand, unsigned I, bool TakingCandidateAddress) {\n  if (FromTy == S.Context.OverloadTy) {\n    S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_overload) << (unsigned)FnKindPair.first << (unsigned)FnKindPair.second << FnDesc << ToParamRange << ToTy << Name << I + 1;"}}

[j]={{D,9248,"static void DiagnoseBadConversion(Sema &S, OverloadCandidate *Cand, unsigned I, bool TakingCandidateAddress) {\n  if (CToTy.getUnqualifiedType() == CFromTy.getUnqualifiedType() && !CToTy.isAtLeastAsQualifiedAs(CFromTy)) {\n    if (FromQs.getObjCLifetime() != ToQs.getObjCLifetime()) {\n      S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_ownership) << (unsigned)FnKindPair.first << (unsigned)FnKindPair.second << FnDesc << ToParamRange << FromTy << FromQs.getObjCLifetime() << ToQs.getObjCLifetime() << (unsigned)isObjectArgument << I + 1;"}}

[j]={{D,9670,"/// CUDA: diagnose an invalid call across targets.\nstatic void DiagnoseBadTarget(Sema &S, OverloadCandidate *Cand) {\n  S.Diag(Callee->getLocation(), diag::note_ovl_candidate_bad_target) << (unsigned)FnKindPair.first << (unsigned)ocs_non_template << FnDesc /* Ignored */"}}

[j]={{D,9272,"static void DiagnoseBadConversion(Sema &S, OverloadCandidate *Cand, unsigned I, bool TakingCandidateAddress) {\n  if (Conv.Bad.Kind == BadConversionSequence::lvalue_ref_to_rvalue || Conv.Bad.Kind == BadConversionSequence::rvalue_ref_to_lvalue) {\n    S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_value_category) << (unsigned)FnKindPair.first << (unsigned)FnKindPair.second << FnDesc << (unsigned)isObjectArgument << I + 1 << (Conv.Bad.Kind == BadConversionSequence::rvalue_ref_to_lvalue) << ToParamRange;"}}

[j]={{D,9862,"/// Generates a \'note\' diagnostic for an overload candidate.  We\'ve\n/// already generated a primary error at the call site.\n///\n/// It really does need to be a single diagnostic with its caret\n/// pointed at the candidate declaration.  Yes, this creates some\n/// major challenges of technical writing.  Yes, this makes pointing\n/// out problems with specific arguments quite awkward.  It\'s still\n/// better than generating twenty screens of text for every failed\n/// overload.\n///\n/// It would be great to be able to express per-candidate problems\n/// more richly for those diagnostic clients that cared, but we\'d\n/// still have to be just as careful with the default diagnostics.\n/// \\param CtorDestAS Addr space of object being constructed (for ctor\n/// candidates only).\nstatic void NoteFunctionCandidate(Sema &S, OverloadCandidate *Cand, unsigned NumArgs, bool TakingCandidateAddress, LangAS CtorDestAS = LangAS::Default) {\n  case ovl_fail_constraints_not_satisfied: {\n    S.Diag(Fn->getLocation(), diag::note_ovl_candidate_constraints_not_satisfied) << (unsigned)FnKindPair.first << (unsigned)ocs_non_template << FnDesc /* Ignored */;"}}

[j]={{D,9602,"/// Diagnose a failed template-argument deduction.\nstatic void DiagnoseBadDeduction(Sema &S, NamedDecl *Found, Decl *Templated, DeductionFailureInfo &DeductionFailure, unsigned NumArgs, bool TakingCandidateAddress) {\n  case Sema::TDK_DeducedMismatchNested: {\n    S.Diag(Templated->getLocation(), diag::note_ovl_candidate_deduced_mismatch) << (*DeductionFailure.getCallArgIndex() + 1) << *DeductionFailure.getFirstArg() << *DeductionFailure.getSecondArg() << TemplateArgString << (DeductionFailure.Result == Sema::TDK_DeducedMismatchNested);"}}

[j]={{D,9782,"/// Generates a \'note\' diagnostic for an overload candidate.  We\'ve\n/// already generated a primary error at the call site.\n///\n/// It really does need to be a single diagnostic with its caret\n/// pointed at the candidate declaration.  Yes, this creates some\n/// major challenges of technical writing.  Yes, this makes pointing\n/// out problems with specific arguments quite awkward.  It\'s still\n/// better than generating twenty screens of text for every failed\n/// overload.\n///\n/// It would be great to be able to express per-candidate problems\n/// more richly for those diagnostic clients that cared, but we\'d\n/// still have to be just as careful with the default diagnostics.\n/// \\param CtorDestAS Addr space of object being constructed (for ctor\n/// candidates only).\nstatic void NoteFunctionCandidate(Sema &S, OverloadCandidate *Cand, unsigned NumArgs, bool TakingCandidateAddress, LangAS CtorDestAS = LangAS::Default) {\n  // Note deleted candidates, but only if they\'re viable.\n  if (Cand->Viable) {\n    if (Fn->isDeleted()) {\n      S.Diag(Fn->getLocation(), diag::note_ovl_candidate_deleted) << (unsigned)FnKindPair.first << (unsigned)FnKindPair.second << FnDesc << (Fn->isDeleted() ? (Fn->isDeletedAsWritten() ? 1 : 2) : 0);"}}

[j]={{D,9565,"/// Diagnose a failed template-argument deduction.\nstatic void DiagnoseBadDeduction(Sema &S, NamedDecl *Found, Decl *Templated, DeductionFailureInfo &DeductionFailure, unsigned NumArgs, bool TakingCandidateAddress) {\n  case Sema::TDK_SubstitutionFailure: {\n    if (PDiag && PDiag->second.getDiagID() == diag::err_typename_nested_not_found_enable_if) {\n      S.Diag(PDiag->first, diag::note_ovl_candidate_disabled_by_enable_if) << \"\'enable_if\'\" << TemplateArgString;"}}

[j]={{C,5963,"static void checkDirectCallValidity(Sema &S, const Expr *Fn, FunctionDecl *Callee, MultiExprArg ArgExprs) {\n  if (const EnableIfAttr *Attr = S.CheckEnableIf(Callee, Fn->getBeginLoc(), ArgExprs, true)) {\n    S.Diag(Callee->getLocation(), diag::note_ovl_candidate_disabled_by_function_cond_attr) << Attr->getCond()->getSourceRange() << Attr->getMessage();"},{D,9717,"static void DiagnoseFailedEnableIfAttr(Sema &S, OverloadCandidate *Cand) {\n  S.Diag(Callee->getLocation(), diag::note_ovl_candidate_disabled_by_function_cond_attr) << Attr->getCond()->getSourceRange() << Attr->getMessage();"},{D,12584,"/// BuildCallToMemberFunction - Build a call to a member\n/// function. MemExpr is the expression that refers to the member\n/// function (and includes the object parameter), Args/NumArgs are the\n/// arguments to the function call (not including the object\n/// parameter). The caller needs to validate that the member\n/// expression refers to a non-static member function or an overloaded\n/// member function.\nExprResult Sema::BuildCallToMemberFunction(Scope *S, Expr *MemExprE, SourceLocation LParenLoc, MultiExprArg Args, SourceLocation RParenLoc, Expr *ExecConfig, bool IsExecConfig, bool AllowRecovery) {\n  // In the case the method to call was not selected by the overloading\n  // resolution process, we still need to handle the enable_if attribute. Do\n  // that here, so it will not hide previous -- and more relevant -- errors.\n  if (auto *MemE = dyn_cast<MemberExpr>(NakedMemExpr)) {\n    if (const EnableIfAttr *Attr = CheckEnableIf(Method, LParenLoc, Args, true)) {\n      Diag(Method->getLocation(), diag::note_ovl_candidate_disabled_by_function_cond_attr) << Attr->getCond()->getSourceRange() << Attr->getMessage();"}}

[j]={{D,9571,"/// Diagnose a failed template-argument deduction.\nstatic void DiagnoseBadDeduction(Sema &S, NamedDecl *Found, Decl *Templated, DeductionFailureInfo &DeductionFailure, unsigned NumArgs, bool TakingCandidateAddress) {\n  case Sema::TDK_SubstitutionFailure: {\n    // We found a specific requirement that disabled the enable_if.\n    if (PDiag && PDiag->second.getDiagID() == diag::err_typename_nested_not_found_requirement) {\n      S.Diag(Templated->getLocation(), diag::note_ovl_candidate_disabled_by_requirement) << PDiag->second.getStringArg(0) << TemplateArgString;"}}

[j]={{D,9747,"static void DiagnoseFailedExplicitSpec(Sema &S, OverloadCandidate *Cand) {\n  S.Diag(First->getLocation(), diag::note_ovl_candidate_explicit) << Kind << (ES.getExpr() ? 1 : 0) << (ES.getExpr() ? ES.getExpr()->getSourceRange() : SourceRange());"}}

[j]={{D,9513,"/// Diagnose a failed template-argument deduction.\nstatic void DiagnoseBadDeduction(Sema &S, NamedDecl *Found, Decl *Templated, DeductionFailureInfo &DeductionFailure, unsigned NumArgs, bool TakingCandidateAddress) {\n  case Sema::TDK_InvalidExplicitArguments:\n    if (ParamD->getDeclName())\n      S.Diag(Templated->getLocation(), diag::note_ovl_candidate_explicit_arg_mismatch_named) << ParamD->getDeclName();"}}

[j]={{D,9522,"/// Diagnose a failed template-argument deduction.\nstatic void DiagnoseBadDeduction(Sema &S, NamedDecl *Found, Decl *Templated, DeductionFailureInfo &DeductionFailure, unsigned NumArgs, bool TakingCandidateAddress) {\n  case Sema::TDK_InvalidExplicitArguments:\n    if (ParamD->getDeclName())\n    else {\n      S.Diag(Templated->getLocation(), diag::note_ovl_candidate_explicit_arg_mismatch_unnamed) << (index + 1);"}}

[j]={{D,9043,"/// 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      S.Diag(FD->getLocation(), diag::note_ovl_candidate_has_pass_object_size_params) << ParamNo;"}}

[j]={{D,9801,"/// Generates a \'note\' diagnostic for an overload candidate.  We\'ve\n/// already generated a primary error at the call site.\n///\n/// It really does need to be a single diagnostic with its caret\n/// pointed at the candidate declaration.  Yes, this creates some\n/// major challenges of technical writing.  Yes, this makes pointing\n/// out problems with specific arguments quite awkward.  It\'s still\n/// better than generating twenty screens of text for every failed\n/// overload.\n///\n/// It would be great to be able to express per-candidate problems\n/// more richly for those diagnostic clients that cared, but we\'d\n/// still have to be just as careful with the default diagnostics.\n/// \\param CtorDestAS Addr space of object being constructed (for ctor\n/// candidates only).\nstatic void NoteFunctionCandidate(Sema &S, OverloadCandidate *Cand, unsigned NumArgs, bool TakingCandidateAddress, LangAS CtorDestAS = LangAS::Default) {\n  case ovl_fail_illegal_constructor: {\n    S.Diag(Fn->getLocation(), diag::note_ovl_candidate_illegal_constructor) << (Fn->getPrimaryTemplate() ? 1 : 0);"}}

[j]={{D,9809,"/// Generates a \'note\' diagnostic for an overload candidate.  We\'ve\n/// already generated a primary error at the call site.\n///\n/// It really does need to be a single diagnostic with its caret\n/// pointed at the candidate declaration.  Yes, this creates some\n/// major challenges of technical writing.  Yes, this makes pointing\n/// out problems with specific arguments quite awkward.  It\'s still\n/// better than generating twenty screens of text for every failed\n/// overload.\n///\n/// It would be great to be able to express per-candidate problems\n/// more richly for those diagnostic clients that cared, but we\'d\n/// still have to be just as careful with the default diagnostics.\n/// \\param CtorDestAS Addr space of object being constructed (for ctor\n/// candidates only).\nstatic void NoteFunctionCandidate(Sema &S, OverloadCandidate *Cand, unsigned NumArgs, bool TakingCandidateAddress, LangAS CtorDestAS = LangAS::Default) {\n  case ovl_fail_object_addrspace_mismatch: {\n    S.Diag(Fn->getLocation(), diag::note_ovl_candidate_illegal_constructor_adrspace_mismatch) << QualsForPrinting;"}}

[j]={{D,9440,"/// Diagnose a failed template-argument deduction.\nstatic void DiagnoseBadDeduction(Sema &S, NamedDecl *Found, Decl *Templated, DeductionFailureInfo &DeductionFailure, unsigned NumArgs, bool TakingCandidateAddress) {\n  case Sema::TDK_Incomplete: {\n    S.Diag(Templated->getLocation(), diag::note_ovl_candidate_incomplete_deduction) << ParamD->getDeclName();"}}

[j]={{D,9447,"/// Diagnose a failed template-argument deduction.\nstatic void DiagnoseBadDeduction(Sema &S, NamedDecl *Found, Decl *Templated, DeductionFailureInfo &DeductionFailure, unsigned NumArgs, bool TakingCandidateAddress) {\n  case Sema::TDK_IncompletePack: {\n    S.Diag(Templated->getLocation(), diag::note_ovl_candidate_incomplete_deduction_pack) << ParamD->getDeclName() << (DeductionFailure.getFirstArg()->pack_size() + 1) << *DeductionFailure.getFirstArg();"}}

[j]={{D,9505,"/// Diagnose a failed template-argument deduction.\nstatic void DiagnoseBadDeduction(Sema &S, NamedDecl *Found, Decl *Templated, DeductionFailureInfo &DeductionFailure, unsigned NumArgs, bool TakingCandidateAddress) {\n  case Sema::TDK_Inconsistent: {\n    S.Diag(Templated->getLocation(), diag::note_ovl_candidate_inconsistent_deduction) << which << ParamD->getDeclName() << *DeductionFailure.getFirstArg() << *DeductionFailure.getSecondArg();"}}

[j]={{D,9488,"/// Diagnose a failed template-argument deduction.\nstatic void DiagnoseBadDeduction(Sema &S, NamedDecl *Found, Decl *Templated, DeductionFailureInfo &DeductionFailure, unsigned NumArgs, bool TakingCandidateAddress) {\n  case Sema::TDK_Inconsistent: {\n    if (isa<TemplateTypeParmDecl>(ParamD))\n    else if (isa<NonTypeTemplateParmDecl>(ParamD)) {\n      if (!T1.isNull() && !T2.isNull() && !S.Context.hasSameType(T1, T2)) {\n        S.Diag(Templated->getLocation(), diag::note_ovl_candidate_inconsistent_deduction_types) << ParamD->getDeclName() << *DeductionFailure.getFirstArg() << T1 << *DeductionFailure.getSecondArg() << T2;"}}

[j]={{D,8979,"void MaybeEmitInheritedConstructorNote(Sema &S, const Decl *FoundDecl) {\n  // FIXME: It\'d be nice to only emit a note once per using-decl per overload\n  // set.\n  if (const auto *Shadow = dyn_cast<ConstructorUsingShadowDecl>(FoundDecl))\n    S.Diag(FoundDecl->getLocation(), diag::note_ovl_candidate_inherited_constructor) << Shadow->getNominatedBaseClass();"}}

[j]={{D,9844,"/// Generates a \'note\' diagnostic for an overload candidate.  We\'ve\n/// already generated a primary error at the call site.\n///\n/// It really does need to be a single diagnostic with its caret\n/// pointed at the candidate declaration.  Yes, this creates some\n/// major challenges of technical writing.  Yes, this makes pointing\n/// out problems with specific arguments quite awkward.  It\'s still\n/// better than generating twenty screens of text for every failed\n/// overload.\n///\n/// It would be great to be able to express per-candidate problems\n/// more richly for those diagnostic clients that cared, but we\'d\n/// still have to be just as careful with the default diagnostics.\n/// \\param CtorDestAS Addr space of object being constructed (for ctor\n/// candidates only).\nstatic void NoteFunctionCandidate(Sema &S, OverloadCandidate *Cand, unsigned NumArgs, bool TakingCandidateAddress, LangAS CtorDestAS = LangAS::Default) {\n  case ovl_fail_inhctor_slice:\n    S.Diag(Fn->getLocation(), diag::note_ovl_candidate_inherited_constructor_slice) << (Fn->getPrimaryTemplate() ? 1 : 0) << Fn->getParamDecl(0)->getType()->isRValueReferenceType();"}}

[j]={{D,9546,"/// Diagnose a failed template-argument deduction.\nstatic void DiagnoseBadDeduction(Sema &S, NamedDecl *Found, Decl *Templated, DeductionFailureInfo &DeductionFailure, unsigned NumArgs, bool TakingCandidateAddress) {\n  case Sema::TDK_InstantiationDepth:\n    S.Diag(Templated->getLocation(), diag::note_ovl_candidate_instantiation_depth);"}}

[j]={{D,9634,"/// Diagnose a failed template-argument deduction.\nstatic void DiagnoseBadDeduction(Sema &S, NamedDecl *Found, Decl *Templated, DeductionFailureInfo &DeductionFailure, unsigned NumArgs, bool TakingCandidateAddress) {\n  case Sema::TDK_NonDeducedMismatch: {\n    S.Diag(Templated->getLocation(), diag::note_ovl_candidate_non_deduced_mismatch) << FirstTA << SecondTA;"}}

[j]={{D,9621,"/// Diagnose a failed template-argument deduction.\nstatic void DiagnoseBadDeduction(Sema &S, NamedDecl *Found, Decl *Templated, DeductionFailureInfo &DeductionFailure, unsigned NumArgs, bool TakingCandidateAddress) {\n  case Sema::TDK_NonDeducedMismatch: {\n    if (FirstTA.getKind() == TemplateArgument::Template && SecondTA.getKind() == TemplateArgument::Template) {\n      if (FirstTN.getKind() == TemplateName::Template && SecondTN.getKind() == TemplateName::Template) {\n        if (FirstTN.getAsTemplateDecl()->getName() == SecondTN.getAsTemplateDecl()->getName()) {\n          S.Diag(Templated->getLocation(), diag::note_ovl_candidate_non_deduced_mismatch_qualified) << FirstTN.getAsTemplateDecl() << SecondTN.getAsTemplateDecl();"}}

[j]={{D,9586,"/// Diagnose a failed template-argument deduction.\nstatic void DiagnoseBadDeduction(Sema &S, NamedDecl *Found, Decl *Templated, DeductionFailureInfo &DeductionFailure, unsigned NumArgs, bool TakingCandidateAddress) {\n  case Sema::TDK_SubstitutionFailure: {\n    S.Diag(Templated->getLocation(), diag::note_ovl_candidate_substitution_failure) << TemplateArgString << SFINAEArgString << R;"}}

[j]={{D,9471,"/// Diagnose a failed template-argument deduction.\nstatic void DiagnoseBadDeduction(Sema &S, NamedDecl *Found, Decl *Templated, DeductionFailureInfo &DeductionFailure, unsigned NumArgs, bool TakingCandidateAddress) {\n  case Sema::TDK_Underqualified: {\n    S.Diag(Templated->getLocation(), diag::note_ovl_candidate_underqualified) << ParamD->getDeclName() << Arg << NonCanonParam;"}}

[j]={{D,9026,"/// 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          S.Diag(FD->getBeginLoc(), diag::note_ovl_candidate_unsatisfied_constraints) << TemplateArgString;"},{D,9535,"/// Diagnose a failed template-argument deduction.\nstatic void DiagnoseBadDeduction(Sema &S, NamedDecl *Found, Decl *Templated, DeductionFailureInfo &DeductionFailure, unsigned NumArgs, bool TakingCandidateAddress) {\n  case Sema::TDK_ConstraintsNotSatisfied: {\n    S.Diag(Templated->getLocation(), diag::note_ovl_candidate_unsatisfied_constraints) << TemplateArgString;"}}

[j]={{D,9909,"static void NoteSurrogateCandidate(Sema &S, OverloadCandidate *Cand) {\n  if (!Cand->Viable && Cand->FailureKind == ovl_fail_constraints_not_satisfied) {\n  } else {\n    S.Diag(Cand->Surrogate->getLocation(), diag::note_ovl_surrogate_cand) << FnType;"}}

[j]={{D,9904,"static void NoteSurrogateCandidate(Sema &S, OverloadCandidate *Cand) {\n  if (!Cand->Viable && Cand->FailureKind == ovl_fail_constraints_not_satisfied) {\n    S.Diag(Cand->Surrogate->getLocation(), diag::note_ovl_surrogate_constraints_not_satisfied) << Cand->Surrogate;"}}

[j]={{yc,2302,"/// Give notes for a set of overloads.\n///\n/// A companion to tryExprAsCall. In cases when the name that the programmer\n/// wrote was an overloaded function, we may be able to make some guesses about\n/// plausible overloads based on their return types; such guesses can be handed\n/// off to this method to be emitted as notes.\n///\n/// \\param Overloads - The overloads to note.\n/// \\param FinalNoteLoc - If we\'ve suppressed printing some overloads due to\n///  -fshow-overloads=best, this is the location to attach to the note about too\n///  many candidates. Typically this will be the location of the original\n///  ill-formed expression.\nstatic void noteOverloads(Sema &S, const UnresolvedSetImpl &Overloads, const SourceLocation FinalNoteLoc) {\n  if (SuppressedOverloads)\n    S.Diag(FinalNoteLoc, diag::note_ovl_too_many_candidates) << SuppressedOverloads;"},{D,9179,"/// Diagnoses an ambiguous conversion.  The partial diagnostic is the\n/// \"lead\" diagnostic; it will be given two arguments, the source and\n/// target types of the conversion.\nvoid ImplicitConversionSequence::DiagnoseAmbiguousConversion(Sema &S, SourceLocation CaretLoc, const PartialDiagnostic &PDiag) const {\n  if (I != E)\n    S.Diag(SourceLocation(), diag::note_ovl_too_many_candidates) << int(E - I);"},{D,10325,"void OverloadCandidateSet::NoteCandidates(Sema &S, ArrayRef<Expr *> Args, ArrayRef<OverloadCandidate *> Cands, StringRef Opc, SourceLocation OpLoc) {\n  if (I != E)\n    S.Diag(OpLoc, diag::note_ovl_too_many_candidates, shouldDeferDiags(S, Args, OpLoc)) << int(E - I);"},{D,10421,"/// NoteCandidates - When no template specialization match is found, prints\n/// diagnostic messages containing the non-matching specializations that form\n/// the candidate set.\n/// This is analoguous to OverloadCandidateSet::NoteCandidates() with\n/// OCD == OCD_AllCandidates and Cand->Viable == false.\nvoid TemplateSpecCandidateSet::NoteCandidates(Sema &S, SourceLocation Loc) {\n  if (I != E)\n    S.Diag(Loc, diag::note_ovl_too_many_candidates) << int(E - I);"}}

[j]={{u,1690,"static void handleOwnershipAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n  for (unsigned i = 1; i < AL.getNumArgs(); ++i) {\n    // Check we don\'t have a conflict with another ownership attribute.\n    for (const auto *I : D->specific_attrs<OwnershipAttr>()) {\n      // Cannot have two ownership attributes of different kinds for the same\n      // index.\n      if (I->getOwnKind() != K && llvm::is_contained(I->args(), Idx)) {\n      } else if (K == OwnershipAttr::Returns && I->getOwnKind() == OwnershipAttr::Returns) {\n        // A returns attribute conflicts with any other returns attribute using\n        // a different index.\n        if (!llvm::is_contained(I->args(), Idx)) {\n          if (I->args_size())\n            S.Diag(AL.getLoc(), diag::note_ownership_returns_index_mismatch) << Idx.getSourceIndex() << Ex->getSourceRange();"}}

[j]={{U,5929,"void InitializationSequence::PrintInitLocationNote(Sema &S, const InitializedEntity &Entity) {\n  if (Entity.isParamOrTemplateParamKind() && Entity.getDecl()) {\n    if (Entity.getDecl()->getDeclName())\n    else\n      S.Diag(Entity.getDecl()->getLocation(), diag::note_parameter_here);"}}

[j]={{gb,730,"/// Prints the current instantiation stack through a series of\n/// notes.\nvoid Sema::PrintInstantiationStack() {\n  for (SmallVectorImpl<CodeSynthesisContext>::reverse_iterator Active = CodeSynthesisContexts.rbegin(), ActiveEnd = CodeSynthesisContexts.rend(); Active != ActiveEnd; ++Active, ++InstantiationIdx) {\n    case CodeSynthesisContext::ParameterMappingSubstitution:\n      Diags.Report(Active->PointOfInstantiation, diag::note_parameter_mapping_substitution_here) << Active->InstantiationRange;"}}

[j]={{U,5927,"void InitializationSequence::PrintInitLocationNote(Sema &S, const InitializedEntity &Entity) {\n  if (Entity.isParamOrTemplateParamKind() && Entity.getDecl()) {\n    if (Entity.getDecl()->getDeclName())\n      S.Diag(Entity.getDecl()->getLocation(), diag::note_parameter_named_here) << Entity.getDecl()->getDeclName();"}}

[j]={{"clang/lib/Sema/SemaTemplateVariadic.cpp",916,"/// Called when an expression computing the size of a parameter pack\n/// is parsed.\n///\n/// \\code\n/// template<typename ...Types> struct count {\n///  static const unsigned value = sizeof...(Types);\n/// };\n/// \\endcode\n///\n//\n/// \\param OpLoc The location of the \"sizeof\" keyword.\n/// \\param Name The name of the parameter pack whose size will be determined.\n/// \\param NameLoc The source location of the name of the parameter pack.\n/// \\param RParenLoc The location of the closing parentheses.\nExprResult Sema::ActOnSizeofParameterPackExpr(Scope *S, SourceLocation OpLoc, IdentifierInfo &Name, SourceLocation NameLoc, SourceLocation RParenLoc) {\n  case LookupResult::NotFoundInCurrentInstantiation: {\n    if (TypoCorrection Corrected = CorrectTypo(R.getLookupNameInfo(), R.getLookupKind(), S, nullptr, CCC, CTK_ErrorRecovery)) {\n      diagnoseTypo(Corrected, PDiag(diag::err_sizeof_pack_no_pack_name_suggest) << &Name, PDiag(diag::note_parameter_pack_here));"}}

[j]={{F,7683,"/// Check the arguments to \'__builtin_va_start\' or \'__builtin_ms_va_start\'\n/// for validity.  Emit an error and return true on failure; return false\n/// on success.\nbool Sema::SemaBuiltinVAStart(unsigned BuiltinID, CallExpr *TheCall) {\n  if (!SecondArgIsLastNamedArgument)\n  else if (IsCRegister || Type->isReferenceType() || Type->isSpecificBuiltinType(BuiltinType::Float) || [=] {\n    Diag(ParamLoc, diag::note_parameter_type) << Type;"},{Db,1016,"bool ObjCSubscriptOpBuilder::findAtIndexGetter() {\n  if (AtIndexGetter) {\n    if ((arrayRef && !T->isIntegralOrEnumerationType()) || (!arrayRef && !T->isObjCObjectPointerType())) {\n      S.Diag(AtIndexGetter->parameters()[0]->getLocation(), diag::note_parameter_type) << T;"},{Db,1095,"bool ObjCSubscriptOpBuilder::findAtIndexSetter() {\n  if (AtIndexSetter && arrayRef) {\n    if (!T->isIntegralOrEnumerationType()) {\n      S.Diag(AtIndexSetter->parameters()[1]->getLocation(), diag::note_parameter_type) << T;"},{Db,1101,"bool ObjCSubscriptOpBuilder::findAtIndexSetter() {\n  if (AtIndexSetter && arrayRef) {\n    if (!T->isObjCObjectPointerType()) {\n      S.Diag(AtIndexSetter->parameters()[0]->getLocation(), diag::note_parameter_type) << T;"},{Db,1112,"bool ObjCSubscriptOpBuilder::findAtIndexSetter() {\n  if (AtIndexSetter && arrayRef) {\n  } else if (AtIndexSetter && !arrayRef)\n    for (unsigned i = 0; i < 2; i++) {\n      if (!T->isObjCObjectPointerType()) {\n        S.Diag(AtIndexSetter->parameters()[i]->getLocation(), diag::note_parameter_type) << T;"}}

[j]={{Kb,348,"/// Actually emit an availability diagnostic for a reference to an unavailable\n/// decl.\n///\n/// \\param Ctx The context that the reference occurred in\n/// \\param ReferringDecl The exact declaration that was referenced.\n/// \\param OffendingDecl A related decl to \\c ReferringDecl that has an\n/// availability attribute corresponding to \\c K attached to it. Note that this\n/// may not be the same as ReferringDecl, i.e. if an EnumDecl is annotated and\n/// we refer to a member EnumConstantDecl, ReferringDecl is the EnumConstantDecl\n/// and OffendingDecl is the EnumDecl.\nstatic void DoEmitAvailabilityWarning(Sema &S, AvailabilityResult K, Decl *Ctx, const NamedDecl *ReferringDecl, const NamedDecl *OffendingDecl, StringRef Message, ArrayRef<SourceLocation> Locs, const ObjCInterfaceDecl *UnknownObjCClass, const ObjCPropertyDecl *ObjCProperty, bool ObjCPropertyAccess) {\n  case AR_NotYetIntroduced: {\n    S.Diag(OffendingDecl->getLocation(), diag::note_partial_availability_specified_here) << OffendingDecl << PlatformName << Introduced.getAsString() << S.Context.getTargetInfo().getPlatformMinVersion().getAsString();"},{Kb,665,"void DiagnoseUnguardedAvailability::DiagnoseDeclAvailability(NamedDecl *D, SourceRange Range, ObjCInterfaceDecl *ReceiverClass) {\n  if (Result != AR_Available) {\n    SemaRef.Diag(OffendingDecl->getLocation(), diag::note_partial_availability_specified_here) << OffendingDecl << PlatformName << Introduced.getAsString() << SemaRef.Context.getTargetInfo().getPlatformMinVersion().getAsString();"}}

[j]={{x,4053,"DeclResult Sema::CheckVarTemplateId(VarTemplateDecl *Template, SourceLocation TemplateLoc, SourceLocation TemplateNameLoc, const TemplateArgumentListInfo &TemplateArgs) {\n  if (AmbiguousPartialSpec) {\n    // Print the matching partial specializations.\n    for (MatchResult P : Matched)\n      Diag(P.Partial->getLocation(), diag::note_partial_spec_match) << getTemplateArgumentBindingsText(P.Partial->getTemplateParameters(), *P.Args);"},{gb,2851,"/// Get the instantiation pattern to use to instantiate the definition of a\n/// given ClassTemplateSpecializationDecl (either the pattern of the primary\n/// template or of a partial specialization).\nstatic ActionResult<CXXRecordDecl *> getPatternForClassTemplateSpecialization(Sema &S, SourceLocation PointOfInstantiation, ClassTemplateSpecializationDecl *ClassTemplateSpec, TemplateSpecializationKind TSK) {\n  if (!Specialized.is<ClassTemplatePartialSpecializationDecl *>()) {\n    if (Matched.size() >= 1) {\n      if (Matched.size() == 1) {\n      } else {\n        if (Ambiguous) {\n          // Print the matching partial specializations.\n          for (SmallVectorImpl<MatchResult>::iterator P = Matched.begin(), PEnd = Matched.end(); P != PEnd; ++P)\n            S.Diag(P->Partial->getLocation(), diag::note_partial_spec_match) << S.getTemplateArgumentBindingsText(P->Partial->getTemplateParameters(), *P->Args);"}}

[j]={{Qb,2222,"InputFile ASTReader::getInputFile(ModuleFile &F, unsigned ID, bool Complain) {\n  // For an overridden file, there is nothing to validate.\n  if (!Overridden && FileChange.Kind != Change::None) {\n    if (Complain && !Diags.isDiagnosticInFlight()) {\n      Diag(diag::note_pch_rebuild_required) << TopLevelPCHName;"}}

[j]={{Qb,2217,"InputFile ASTReader::getInputFile(ModuleFile &F, unsigned ID, bool Complain) {\n  // For an overridden file, there is nothing to validate.\n  if (!Overridden && FileChange.Kind != Change::None) {\n    if (Complain && !Diags.isDiagnosticInFlight()) {\n      // Print the import stack.\n      if (ImportStack.size() > 1) {\n        Diag(diag::note_pch_required_by) << Filename << ImportStack[0]->FileName;"},{Qb,2219,"InputFile ASTReader::getInputFile(ModuleFile &F, unsigned ID, bool Complain) {\n  // For an overridden file, there is nothing to validate.\n  if (!Overridden && FileChange.Kind != Change::None) {\n    if (Complain && !Diags.isDiagnosticInFlight()) {\n      // Print the import stack.\n      if (ImportStack.size() > 1) {\n        for (unsigned I = 1; I < ImportStack.size(); ++I)\n          Diag(diag::note_pch_required_by) << ImportStack[I - 1]->FileName << ImportStack[I]->FileName;"}}

[j]={{Kb,415,"/// Actually emit an availability diagnostic for a reference to an unavailable\n/// decl.\n///\n/// \\param Ctx The context that the reference occurred in\n/// \\param ReferringDecl The exact declaration that was referenced.\n/// \\param OffendingDecl A related decl to \\c ReferringDecl that has an\n/// availability attribute corresponding to \\c K attached to it. Note that this\n/// may not be the same as ReferringDecl, i.e. if an EnumDecl is annotated and\n/// we refer to a member EnumConstantDecl, ReferringDecl is the EnumConstantDecl\n/// and OffendingDecl is the EnumDecl.\nstatic void DoEmitAvailabilityWarning(Sema &S, AvailabilityResult K, Decl *Ctx, const NamedDecl *ReferringDecl, const NamedDecl *OffendingDecl, StringRef Message, ArrayRef<SourceLocation> Locs, const ObjCInterfaceDecl *UnknownObjCClass, const ObjCPropertyDecl *ObjCProperty, bool ObjCPropertyAccess) {\n  case AR_Unavailable:\n    if (auto AL = OffendingDecl->getAttr<UnavailableAttr>()) {\n      if (AL->isImplicit() && AL->getImplicitReason()) {\n        case UnavailableAttr::IR_ARCForbiddenConversion:\n          diag_available_here = diag::note_performs_forbidden_arc_conversion;"}}

[j]={{C,9783,"static void DiagnoseDivisionSizeofPointerOrArray(Sema &S, Expr *LHS, Expr *RHS, SourceLocation Loc) {\n  if (LHSTy->isPointerType() && !RHSTy->isPointerType()) {\n    if (const auto *DRE = dyn_cast<DeclRefExpr>(LHSArg)) {\n      if (const ValueDecl *LHSArgDecl = DRE->getDecl())\n        S.Diag(LHSArgDecl->getLocation(), diag::note_pointer_declared_here) << LHSArgDecl;"}}

[j]={{B,2979,"void Sema::DiagnoseMultipleMethodInGlobalPool(SmallVectorImpl<ObjCMethodDecl *> &Methods, Selector Sel, SourceRange R, bool receiverIdOrClass) {\n  if (issueDiagnostic) {\n    Diag(Methods[0]->getBeginLoc(), issueError ? diag::note_possibility : diag::note_using) << Methods[0]->getSourceRange();"}}

[j]={{yc,2295,"/// Give notes for a set of overloads.\n///\n/// A companion to tryExprAsCall. In cases when the name that the programmer\n/// wrote was an overloaded function, we may be able to make some guesses about\n/// plausible overloads based on their return types; such guesses can be handed\n/// off to this method to be emitted as notes.\n///\n/// \\param Overloads - The overloads to note.\n/// \\param FinalNoteLoc - If we\'ve suppressed printing some overloads due to\n///  -fshow-overloads=best, this is the location to attach to the note about too\n///  many candidates. Typically this will be the location of the original\n///  ill-formed expression.\nstatic void noteOverloads(Sema &S, const UnresolvedSetImpl &Overloads, const SourceLocation FinalNoteLoc) {\n  for (UnresolvedSetImpl::iterator It = Overloads.begin(), DeclsEnd = Overloads.end(); It != DeclsEnd; ++It) {\n    S.Diag(Fn->getLocation(), diag::note_possible_target_of_call);"}}

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

[j]={{wc,537,"/// HandleMacroExpandedIdentifier - If an identifier token is read that is to be\n/// expanded as a macro, handle it and return the next token as \'Identifier\'.\nbool Preprocessor::HandleMacroExpandedIdentifier(Token &Identifier, const MacroDefinition &M) {\n  // If the macro definition is ambiguous, complain.\n  if (M.isAmbiguous()) {\n    M.forAllDefinitions([&](const MacroInfo *OtherMI) {\n      if (OtherMI != MI)\n        Diag(OtherMI->getDefinitionLoc(), diag::note_pp_ambiguous_macro_other) << Identifier.getIdentifierInfo();"}}

[j]={{S,1914,"OptionalFileEntryRef Preprocessor::LookupHeaderIncludeOrImport(ConstSearchDirIterator *CurDir, StringRef &Filename, SourceLocation FilenameLoc, CharSourceRange FilenameRange, const Token &FilenameTok, bool &IsFrameworkFound, bool IsImportDecl, bool &IsMapped, ConstSearchDirIterator LookupFrom, const FileEntry *LookupFromFile, StringRef &LookupFilename, SmallVectorImpl<char> &RelativePath, SmallVectorImpl<char> &SearchPath, ModuleMap::KnownHeader &SuggestedModule, bool isAngled) {\n  if (IsFrameworkFound) {\n    Diag(FilenameTok, diag::note_pp_framework_without_header) << OriginalFilename.substr(SlashPos + 1) << FrameworkName << CacheEntry.Directory->getName();"}}

[j]={{"clang/lib/Lex/Preprocessor.cpp",1345,"void Preprocessor::emitMacroDeprecationWarning(const Token &Identifier) const {\n  Diag(Info.Location, diag::note_pp_macro_annotation) << 0;"},{"clang/lib/Lex/Preprocessor.cpp",1356,"void Preprocessor::emitRestrictExpansionWarning(const Token &Identifier) const {\n  Diag(Info.Location, diag::note_pp_macro_annotation) << 1;"},{"clang/lib/Lex/Preprocessor.cpp",1364,"void Preprocessor::emitFinalMacroWarning(const Token &Identifier, bool IsUndef) const {\n  Diag(*A.FinalAnnotationLoc, diag::note_pp_macro_annotation) << 2;"}}

[j]={{Hb,1647,"/// Handle the clang \\#pragma module begin extension. The syntax is:\n/// \\code\n///  #pragma clang module begin some.module.name\n///  ...\n///  #pragma clang module end\n/// \\endcode\nstruct PragmaModuleBeginHandler : public PragmaHandler {\n  void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &Tok) override {\n    // If the module isn\'t available, it doesn\'t make sense to enter it.\n    if (Preprocessor::checkModuleIsAvailable(PP.getLangOpts(), PP.getTargetInfo(), PP.getDiagnostics(), M)) {\n      PP.Diag(BeginLoc, diag::note_pp_module_begin_here) << M->getTopLevelModuleName();"}}

[j]={{sb,949,"void Sema::PrintPragmaAttributeInstantiationPoint() {\n  Diags.Report(PragmaAttributeCurrentTargetDecl->getBeginLoc(), diag::note_pragma_attribute_applied_decl_here);"}}

[j]={{"clang/lib/Parse/ParsePragma.cpp",3375,"/// Handle the #pragma clang attribute directive.\n///\n/// The syntax is:\n/// \\code\n///  #pragma clang attribute push (attribute, subject-set)\n///  #pragma clang attribute push\n///  #pragma clang attribute (attribute, subject-set)\n///  #pragma clang attribute pop\n/// \\endcode\n///\n/// There are also \'namespace\' variants of push and pop directives. The bare\n/// \'#pragma clang attribute (attribute, subject-set)\' version doesn\'t require a\n/// namespace, since it always applies attributes to the most recently pushed\n/// group, regardless of namespace.\n/// \\code\n///  #pragma clang attribute namespace.push (attribute, subject-set)\n///  #pragma clang attribute namespace.push\n///  #pragma clang attribute namespace.pop\n/// \\endcode\n///\n/// The subject-set clause defines the set of declarations which receive the\n/// attribute. Its exact syntax is described in the LanguageExtensions document\n/// in Clang\'s documentation.\n///\n/// This directive instructs the compiler to begin/finish applying the specified\n/// attribute to the set of attribute-specific declarations in the active range\n/// of the pragma.\nvoid PragmaAttributeHandler::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &FirstToken) {\n  // Determine what action this pragma clang attribute represents.\n  if (Tok.is(tok::l_paren)) {\n    if (Info->Namespace) {\n      PP.Diag(Tok.getLocation(), diag::note_pragma_attribute_namespace_on_attribute);"}}

[j]={{sb,904,"void Sema::ActOnPragmaAttributePop(SourceLocation PragmaLoc, const IdentifierInfo *Namespace) {\n  // Dig back through the stack trying to find the most recently pushed group\n  // that in Namespace. Note that this works fine if no namespace is present,\n  // think of push/pops without namespaces as having an implicit \"nullptr\"\n  // namespace.\n  for (size_t Index = PragmaAttributeStack.size(); Index;) {\n    if (PragmaAttributeStack[Index].Namespace == Namespace) {\n      for (const PragmaAttributeEntry &Entry : PragmaAttributeStack[Index].Entries) {\n        if (!Entry.IsUsed) {\n          Diag(PragmaLoc, diag::note_pragma_attribute_region_ends_here);"}}

[j]={{"clang/lib/Parse/ParsePragma.cpp",1645,"void Parser::HandlePragmaAttribute() {\n  if ((Tok.is(tok::l_square) && NextToken().is(tok::l_square)) || Tok.isRegularKeywordAttribute()) {\n  } else if (Tok.is(tok::kw___attribute)) {\n  } else if (Tok.is(tok::kw___declspec)) {\n  } else {\n    if (Tok.getIdentifierInfo()) {\n      // If we suspect that this is an attribute suggest the use of\n      // \'__attribute__\'.\n      if (ParsedAttr::getParsedKind(Tok.getIdentifierInfo(), /*ScopeName=*/nullptr, ParsedAttr::AS_GNU) != ParsedAttr::UnknownAttribute) {\n        Diag(Tok, diag::note_pragma_attribute_use_attribute_kw) << FixItHint::CreateInsertion(InsertStartLoc, \"__attribute__((\") << FixItHint::CreateInsertion(Tok.getEndLoc(), \"))\");"}}

[j]={{S,1952,"/// Handle either a #include-like directive or an import declaration that names\n/// a header file.\n///\n/// \\param HashLoc The location of the \'#\' token for an include, or\n///        SourceLocation() for an import declaration.\n/// \\param IncludeTok The include / include_next / import token.\n/// \\param FilenameTok The header-name token.\n/// \\param EndLoc The location at which any imported macros become visible.\n/// \\param LookupFrom For #include_next, the starting directory for the\n///        directory lookup.\n/// \\param LookupFromFile For #include_next, the starting file for the directory\n///        lookup.\nPreprocessor::ImportAction Preprocessor::HandleHeaderIncludeOrImport(SourceLocation HashLoc, Token &IncludeTok, Token &FilenameTok, SourceLocation EndLoc, ConstSearchDirIterator LookupFrom, const FileEntry *LookupFromFile) {\n  // Complain about attempts to #include files in an audit pragma.\n  if (PragmaARCCFCodeAuditedInfo.second.isValid()) {\n    Diag(PragmaARCCFCodeAuditedInfo.second, diag::note_pragma_entered_here);"},{S,1961,"/// Handle either a #include-like directive or an import declaration that names\n/// a header file.\n///\n/// \\param HashLoc The location of the \'#\' token for an include, or\n///        SourceLocation() for an import declaration.\n/// \\param IncludeTok The include / include_next / import token.\n/// \\param FilenameTok The header-name token.\n/// \\param EndLoc The location at which any imported macros become visible.\n/// \\param LookupFrom For #include_next, the starting directory for the\n///        directory lookup.\n/// \\param LookupFromFile For #include_next, the starting file for the directory\n///        lookup.\nPreprocessor::ImportAction Preprocessor::HandleHeaderIncludeOrImport(SourceLocation HashLoc, Token &IncludeTok, Token &FilenameTok, SourceLocation EndLoc, ConstSearchDirIterator LookupFrom, const FileEntry *LookupFromFile) {\n  // Complain about attempts to #include files in an assume-nonnull pragma.\n  if (PragmaAssumeNonNullLoc.isValid()) {\n    Diag(PragmaAssumeNonNullLoc, diag::note_pragma_entered_here);"},{wc,1533,"/// ExpandBuiltinMacro - If an identifier token is read that is to be expanded\n/// as a builtin macro, handle it and return the next token as \'Tok\'.\nvoid Preprocessor::ExpandBuiltinMacro(Token &Tok) {\n  if (II == Ident__LINE__) {\n  } else if (II == Ident__FILE__ || II == Ident__BASE_FILE__ || II == Ident__FILE_NAME__) {\n  } else if (II == Ident__DATE__) {\n  } else if (II == Ident__TIME__) {\n  } else if (II == Ident__INCLUDE_LEVEL__) {\n  } else if (II == Ident__TIMESTAMP__) {\n  } else if (II == Ident__FLT_EVAL_METHOD__) {\n    if (getLastFPEvalPragmaLocation().isValid()) {\n      Diag(getLastFPEvalPragmaLocation(), diag::note_pragma_entered_here);"},{Hb,1758,"/// PragmaARCCFCodeAuditedHandler -\n///  \\#pragma clang arc_cf_code_audited begin/end\nstruct PragmaARCCFCodeAuditedHandler : public PragmaHandler {\n  void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &NameTok) override {\n    if (IsBegin) {\n      // Complain about attempts to re-enter an audit.\n      if (BeginLoc.isValid()) {\n        PP.Diag(BeginLoc, diag::note_pragma_entered_here);"},{Hb,1813,"/// PragmaAssumeNonNullHandler -\n///  \\#pragma clang assume_nonnull begin/end\nstruct PragmaAssumeNonNullHandler : public PragmaHandler {\n  void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &NameTok) override {\n    if (IsBegin) {\n      // Complain about attempts to re-enter an audit.\n      if (BeginLoc.isValid()) {\n        PP.Diag(BeginLoc, diag::note_pragma_entered_here);"},{sb,591,"bool Sema::UnifySection(StringRef SectionName, int SectionFlags, NamedDecl *Decl) {\n  if (PragmaLocation.isValid())\n    Diag(PragmaLocation, diag::note_pragma_entered_here);"},{sb,593,"bool Sema::UnifySection(StringRef SectionName, int SectionFlags, NamedDecl *Decl) {\n  if (Section.PragmaSectionLocation.isValid())\n    Diag(Section.PragmaSectionLocation, diag::note_pragma_entered_here);"},{sb,608,"bool Sema::UnifySection(StringRef SectionName, int SectionFlags, SourceLocation PragmaSectionLocation) {\n  if (SectionIt != Context.SectionInfos.end()) {\n    if (!(Section.SectionFlags & ASTContext::PSF_Implicit)) {\n      if (Section.PragmaSectionLocation.isValid())\n        Diag(Section.PragmaSectionLocation, diag::note_pragma_entered_here);"}}

[j]={{"clang/lib/Parse/ParsePragma.cpp",1265,"bool Parser::HandlePragmaLoopHint(LoopHint &Hint) {\n  // Validate the argument.\n  if (StateOption) {\n  } else if (OptionInfo && OptionInfo->getName() == \"vectorize_width\") {\n    // Look for vectorize_width(fixed|scalable)\n    if (IsScalableStr == \"scalable\" || IsScalableStr == \"fixed\") {\n    } else {\n      if (R.isInvalid() && !Tok.is(tok::comma))\n        Diag(Toks[0].getLocation(), diag::note_pragma_loop_invalid_vectorize_option);"}}

[j]={{sb,386,"void Sema::DiagnoseNonDefaultPragmaAlignPack(PragmaAlignPackDiagnoseKind Kind, SourceLocation IncludeLoc) {\n  // FIXME: AlignPackStack may contain both #pragma align and #pragma pack\n  // information, diagnostics below might not be accurate if we have mixed\n  // pragmas.\n  if (PrevAlignPackState.ShouldWarnOnInclude) {\n    Diag(PrevAlignPackState.CurrentPragmaLocation, diag::note_pragma_pack_here);"},{sb,391,"void Sema::DiagnoseNonDefaultPragmaAlignPack(PragmaAlignPackDiagnoseKind Kind, SourceLocation IncludeLoc) {\n  // Warn about modified alignment after #includes.\n  if (PrevAlignPackState.CurrentValue != AlignPackStack.CurrentValue) {\n    Diag(AlignPackStack.CurrentPragmaLocation, diag::note_pragma_pack_here);"}}

[j]={{sb,408,"void Sema::DiagnoseUnterminatedPragmaAlignPack() {\n  // FIXME: AlignPackStack may contain both #pragma align and #pragma pack\n  // information, diagnostics below might not be accurate if we have mixed\n  // pragmas.\n  for (const auto &StackSlot : llvm::reverse(AlignPackStack.Stack)) {\n    // The user might have already reset the alignment, so suggest replacing\n    // the reset with a pop.\n    if (IsInnermost && AlignPackStack.CurrentValue == AlignPackStack.DefaultValue) {\n      auto DB = Diag(AlignPackStack.CurrentPragmaLocation, diag::note_pragma_pack_pop_instead_reset);"}}

[j]={{C,13688,"/// DiagnoseBitwisePrecedence - Emit a warning when bitwise and comparison\n/// operators are mixed in a way that suggests that the programmer forgot that\n/// comparison operators have higher precedence. The most typical example of\n/// such code is \"flags & 0x0020 != 0\", which is equivalent to \"flags & 1\".\nstatic void DiagnoseBitwisePrecedence(Sema &Self, BinaryOperatorKind Opc, SourceLocation OpLoc, Expr *LHSExpr, Expr *RHSExpr) {\n  SuggestParentheses(Self, OpLoc, Self.PDiag(diag::note_precedence_bitwise_first) << BinaryOperator::getOpcodeStr(Opc), ParensRange);"}}

[j]={{C,8229,"/// DiagnoseConditionalPrecedence - Emit a warning when a conditional operator\n/// and binary operator are mixed in a way that suggests the programmer assumed\n/// the conditional operator has higher precedence, for example:\n/// \"int x = a + someBinaryCondition ? 1 : 2\".\nstatic void DiagnoseConditionalPrecedence(Sema &Self, SourceLocation OpLoc, Expr *Condition, Expr *LHSExpr, Expr *RHSExpr) {\n  SuggestParentheses(Self, OpLoc, Self.PDiag(diag::note_precedence_conditional_first), SourceRange(CondRHS->getBeginLoc(), RHSExpr->getEndLoc()));"}}

[j]={{C,8227,"/// DiagnoseConditionalPrecedence - Emit a warning when a conditional operator\n/// and binary operator are mixed in a way that suggests the programmer assumed\n/// the conditional operator has higher precedence, for example:\n/// \"int x = a + someBinaryCondition ? 1 : 2\".\nstatic void DiagnoseConditionalPrecedence(Sema &Self, SourceLocation OpLoc, Expr *Condition, Expr *LHSExpr, Expr *RHSExpr) {\n  SuggestParentheses(Self, OpLoc, Self.PDiag(diag::note_precedence_silence) << BinaryOperator::getOpcodeStr(CondOpcode), SourceRange(Condition->getBeginLoc(), Condition->getEndLoc()));"},{C,9795,"static void DiagnoseDivisionSizeofPointerOrArray(Sema &S, Expr *LHS, Expr *RHS, SourceLocation Loc) {\n  if (LHSTy->isPointerType() && !RHSTy->isPointerType()) {\n  } else if (const auto *ArrayTy = S.Context.getAsArrayType(LHSTy)) {\n    S.Diag(Loc, diag::note_precedence_silence) << RHS;"},{C,13687,"/// DiagnoseBitwisePrecedence - Emit a warning when bitwise and comparison\n/// operators are mixed in a way that suggests that the programmer forgot that\n/// comparison operators have higher precedence. The most typical example of\n/// such code is \"flags & 0x0020 != 0\", which is equivalent to \"flags & 1\".\nstatic void DiagnoseBitwisePrecedence(Sema &Self, BinaryOperatorKind Opc, SourceLocation OpLoc, Expr *LHSExpr, Expr *RHSExpr) {\n  SuggestParentheses(Self, OpLoc, Self.PDiag(diag::note_precedence_silence) << OpStr, (isLeftComp ? LHSExpr : RHSExpr)->getSourceRange());"},{C,13697,"/// It accepts a \'&&\' expr that is inside a \'||\' one.\n/// Emit a diagnostic together with a fixit hint that wraps the \'&&\' expression\n/// in parentheses.\nstatic void EmitDiagnosticForLogicalAndInLogicalOr(Sema &Self, SourceLocation OpLoc, BinaryOperator *Bop) {\n  SuggestParentheses(Self, Bop->getOperatorLoc(), Self.PDiag(diag::note_precedence_silence) << Bop->getOpcodeStr(), Bop->getSourceRange());"},{C,13738,"/// Look for bitwise op in the left or right hand of a bitwise op with\n/// lower precedence and emit a diagnostic together with a fixit hint that wraps\n/// the \'&\' expression in parentheses.\nstatic void DiagnoseBitwiseOpInBitwiseOp(Sema &S, BinaryOperatorKind Opc, SourceLocation OpLoc, Expr *SubExpr) {\n  if (BinaryOperator *Bop = dyn_cast<BinaryOperator>(SubExpr)) {\n    if (Bop->isBitwiseOp() && Bop->getOpcode() < Opc) {\n      SuggestParentheses(S, Bop->getOperatorLoc(), S.PDiag(diag::note_precedence_silence) << Bop->getOpcodeStr(), Bop->getSourceRange());"},{C,13748,"static void DiagnoseAdditionInShift(Sema &S, SourceLocation OpLoc, Expr *SubExpr, StringRef Shift) {\n  if (BinaryOperator *Bop = dyn_cast<BinaryOperator>(SubExpr)) {\n    if (Bop->getOpcode() == BO_Add || Bop->getOpcode() == BO_Sub) {\n      SuggestParentheses(S, Bop->getOperatorLoc(), S.PDiag(diag::note_precedence_silence) << Op, Bop->getSourceRange());"},{C,13767,"static void DiagnoseShiftCompare(Sema &S, SourceLocation OpLoc, Expr *LHSExpr, Expr *RHSExpr) {\n  SuggestParentheses(S, OCE->getOperatorLoc(), S.PDiag(diag::note_precedence_silence) << (Kind == OO_LessLess ? \"<<\" : \">>\"), OCE->getSourceRange());"}}

[j]={{jc,217,"Sema::DeclGroupPtrTy Sema::ActOnModuleDecl(SourceLocation StartLoc, SourceLocation ModuleLoc, ModuleDeclKind MDK, ModuleIdPath Path, ModuleIdPath Partition, ModuleImportState &ImportState) {\n  // Only one module-declaration is permitted per source file.\n  if (isCurrentModulePurview()) {\n    Diag(VisibleModules.getImportLoc(ModuleScopes.back().Module), diag::note_prev_module_declaration);"}}

[j]={{jc,280,"Sema::DeclGroupPtrTy Sema::ActOnModuleDecl(SourceLocation StartLoc, SourceLocation ModuleLoc, ModuleDeclKind MDK, ModuleIdPath Path, ModuleIdPath Partition, ModuleImportState &ImportState) {\n  case ModuleDeclKind::PartitionInterface: {\n    // We can\'t have parsed or imported a definition of this module or parsed a\n    // module map defining it already.\n    if (auto *M = Map.findModule(ModuleName)) {\n      if (M->DefinitionLoc.isValid())\n        Diag(M->DefinitionLoc, diag::note_prev_module_definition);"}}

[j]={{jc,282,"Sema::DeclGroupPtrTy Sema::ActOnModuleDecl(SourceLocation StartLoc, SourceLocation ModuleLoc, ModuleDeclKind MDK, ModuleIdPath Path, ModuleIdPath Partition, ModuleImportState &ImportState) {\n  case ModuleDeclKind::PartitionInterface: {\n    // We can\'t have parsed or imported a definition of this module or parsed a\n    // module map defining it already.\n    if (auto *M = Map.findModule(ModuleName)) {\n      if (M->DefinitionLoc.isValid())\n      else if (OptionalFileEntryRef FE = M->getASTFile())\n        Diag(M->DefinitionLoc, diag::note_prev_module_definition_from_ast_file) << FE->getName();"}}

[j]={{"clang/lib/Sema/SemaTemplateInstantiateDecl.cpp",3497,"/// Instantiate the declaration of a class template partial\n/// specialization.\n///\n/// \\param ClassTemplate the (instantiated) class template that is partially\n// specialized by the instantiation of \\p PartialSpec.\n///\n/// \\param PartialSpec the (uninstantiated) class template partial\n/// specialization that we are instantiating.\n///\n/// \\returns The instantiated partial specialization, if successful; otherwise,\n/// NULL to indicate an error.\nClassTemplatePartialSpecializationDecl *TemplateDeclInstantiator::InstantiateClassTemplatePartialSpecialization(ClassTemplateDecl *ClassTemplate, ClassTemplatePartialSpecializationDecl *PartialSpec) {\n  if (PrevDecl) {\n    SemaRef.Diag(PrevDecl->getLocation(), diag::note_prev_partial_spec_here) << SemaRef.Context.getTypeDeclType(PrevDecl);"}}

[j]={{"clang/lib/Sema/SemaAccess.cpp",46,"/// SetMemberAccessSpecifier - Set the access specifier of a member.\n/// Returns true on error (when the previous member decl access specifier\n/// is different from the new member decl access specifier).\nbool Sema::SetMemberAccessSpecifier(NamedDecl *MemberDecl, NamedDecl *PrevMemberDecl, AccessSpecifier LexicalAS) {\n  // C++ [class.access.spec]p3: When a member is redeclared its access\n  // specifier must be same as its initial declaration.\n  if (LexicalAS != AS_none && LexicalAS != PrevMemberDecl->getAccess()) {\n    Diag(PrevMemberDecl->getLocation(), diag::note_previous_access_declaration) << PrevMemberDecl << PrevMemberDecl->getAccess();"},{E,1109,"/// 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    } else if (getLangOpts().ObjCRuntime.isNonFragile() && !declaresSameEntity(ClassDeclared, IDecl)) {\n      Diag(Ivar->getLocation(), diag::note_previous_access_declaration) << Ivar << Ivar->getName();"}}

[j]={{v,6356,"static void checkDLLAttributeRedeclaration(Sema &S, NamedDecl *OldDecl, NamedDecl *NewDecl, bool IsSpecialization, bool IsDefinition) {\n  if (OldImportAttr && !HasNewAttr && (!IsInline || (IsMicrosoftABI && IsTemplate)) && !IsStaticDataMember && !NewDecl->isLocalExternDecl() && !IsQualifiedFriend) {\n    if (IsMicrosoftABI && IsDefinition) {\n    } else if (IsMicrosoftABI && IsSpecialization) {\n    } else {\n      S.Diag(OldImportAttr->getLocation(), diag::note_previous_attribute);"},{u,2275,"AvailabilityAttr *Sema::mergeAvailabilityAttr(NamedDecl *D, const AttributeCommonInfo &CI, IdentifierInfo *Platform, bool Implicit, VersionTuple Introduced, VersionTuple Deprecated, VersionTuple Obsoleted, bool IsUnavailable, StringRef Message, bool IsStrict, StringRef Replacement, AvailabilityMergeKind AMK, int Priority) {\n  if (D->hasAttrs()) {\n    for (unsigned i = 0, e = Attrs.size(); i != e;) {\n      if (!versionsMatch(OldIntroduced, Introduced, OverrideOrImpl) || !versionsMatch(Deprecated, OldDeprecated, OverrideOrImpl) || !versionsMatch(Obsoleted, OldObsoleted, OverrideOrImpl) || !(OldIsUnavailable == IsUnavailable || (OverrideOrImpl && !OldIsUnavailable && IsUnavailable))) {\n        if (OverrideOrImpl) {\n        } else {\n          Diag(CI.getLoc(), diag::note_previous_attribute);"},{u,2523,"template <class T> static T *mergeVisibilityAttr(Sema &S, Decl *D, const AttributeCommonInfo &CI, typename T::VisibilityType value) {\n  if (existingAttr) {\n    S.Diag(CI.getLoc(), diag::note_previous_attribute);"},{u,2890,"SectionAttr *Sema::mergeSectionAttr(Decl *D, const AttributeCommonInfo &CI, StringRef Name) {\n  if (SectionAttr *ExistingAttr = D->getAttr<SectionAttr>()) {\n    Diag(CI.getLoc(), diag::note_previous_attribute);"},{u,2965,"CodeSegAttr *Sema::mergeCodeSegAttr(Decl *D, const AttributeCommonInfo &CI, StringRef Name) {\n  if (const auto *ExistingAttr = D->getAttr<CodeSegAttr>()) {\n    Diag(CI.getLoc(), diag::note_previous_attribute);"},{u,3413,"ErrorAttr *Sema::mergeErrorAttr(Decl *D, const AttributeCommonInfo &CI, StringRef NewUserDiagnostic) {\n  if (const auto *EA = D->getAttr<ErrorAttr>()) {\n    if (EA->getUserDiagnostic() != NewUserDiagnostic) {\n      Diag(EA->getLoc(), diag::note_previous_attribute);"},{u,6773,"WebAssemblyImportModuleAttr *Sema::mergeImportModuleAttr(Decl *D, const WebAssemblyImportModuleAttr &AL) {\n  if (const auto *ExistingAttr = FD->getAttr<WebAssemblyImportModuleAttr>()) {\n    Diag(AL.getLoc(), diag::note_previous_attribute);"},{u,6790,"WebAssemblyImportNameAttr *Sema::mergeImportNameAttr(Decl *D, const WebAssemblyImportNameAttr &AL) {\n  if (const auto *ExistingAttr = FD->getAttr<WebAssemblyImportNameAttr>()) {\n    Diag(AL.getLoc(), diag::note_previous_attribute);"},{y,5518,"/// Check class-level dllimport/dllexport attribute.\nvoid Sema::checkClassLevelDLLAttribute(CXXRecordDecl *Class) {\n  if (Context.getTargetInfo().shouldDLLImportComdatSymbols() && !ClassAttr->isInherited()) {\n    // Diagnose dll attributes on members of class with dll attribute.\n    for (Decl *Member : Class->decls()) {\n      Diag(ClassAttr->getLocation(), diag::note_previous_attribute);"}}

[j]={{v,3131,"// Determine whether the previous declaration was a definition, implicit\n// declaration, or a declaration.\ntemplate <typename T> static std::pair<diag::kind, SourceLocation> getNoteDiagForInvalidRedeclaration(const T *Old, const T *New) {\n  if (Old->isThisDeclarationADefinition())\n  else if (Old->isImplicit()) {\n    if (const auto *FD = dyn_cast<FunctionDecl>(Old)) {\n      if (FD->getBuiltinID())\n        PrevDiag = diag::note_previous_builtin_declaration;"},{v,3308,"/// MergeFunctionDecl - We just parsed a function \'New\' from\n/// declarator D which has the same name and scope as a previous\n/// declaration \'Old\'.  Figure out how to resolve this situation,\n/// merging decls or emitting diagnostics as appropriate.\n///\n/// In C++, New and Old must be declarations that are not\n/// overloaded. Use IsOverload to determine whether New and Old are\n/// overloaded, and to select the Old declaration that New should be\n/// merged with.\n///\n/// Returns true if there was an error, false otherwise.\nbool Sema::MergeFunctionDecl(FunctionDecl *New, NamedDecl *&OldD, Scope *S, bool MergeTypeWithOld, bool NewDeclIsDefn) {\n  // Disallow redeclaration of some builtins.\n  if (!getASTContext().canBuiltinBeRedeclared(Old)) {\n    Diag(Old->getLocation(), diag::note_previous_builtin_declaration) << Old << Old->getType();"},{v,3849,"/// MergeFunctionDecl - We just parsed a function \'New\' from\n/// declarator D which has the same name and scope as a previous\n/// declaration \'Old\'.  Figure out how to resolve this situation,\n/// merging decls or emitting diagnostics as appropriate.\n///\n/// In C++, New and Old must be declarations that are not\n/// overloaded. Use IsOverload to determine whether New and Old are\n/// overloaded, and to select the Old declaration that New should be\n/// merged with.\n///\n/// Returns true if there was an error, false otherwise.\nbool Sema::MergeFunctionDecl(FunctionDecl *New, NamedDecl *&OldD, Scope *S, bool MergeTypeWithOld, bool NewDeclIsDefn) {\n  if (Old->isImplicit() && (BuiltinID = Old->getBuiltinID())) {\n    // If it\'s actually a library-defined builtin function like \'malloc\'\n    // or \'printf\', just warn about the incompatible redeclaration.\n    if (Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID)) {\n      Diag(OldLocation, diag::note_previous_builtin_declaration) << Old << Old->getType();"},{v,3853,"/// MergeFunctionDecl - We just parsed a function \'New\' from\n/// declarator D which has the same name and scope as a previous\n/// declaration \'Old\'.  Figure out how to resolve this situation,\n/// merging decls or emitting diagnostics as appropriate.\n///\n/// In C++, New and Old must be declarations that are not\n/// overloaded. Use IsOverload to determine whether New and Old are\n/// overloaded, and to select the Old declaration that New should be\n/// merged with.\n///\n/// Returns true if there was an error, false otherwise.\nbool Sema::MergeFunctionDecl(FunctionDecl *New, NamedDecl *&OldD, Scope *S, bool MergeTypeWithOld, bool NewDeclIsDefn) {\n  if (Old->isImplicit() && (BuiltinID = Old->getBuiltinID())) {\n    PrevDiag = diag::note_previous_builtin_declaration;"}}

[j]={{v,3103,"static void mergeParamDeclTypes(ParmVarDecl *NewParam, const ParmVarDecl *OldParam, Sema &S) {\n  if (OldParamDT && NewParamDT && OldParamDT->getPointeeType() == NewParamDT->getPointeeType()) {\n    if (!EquivalentArrayTypes(OldParamOT, NewParamOT, S.getASTContext())) {\n      S.Diag(OldParam->getLocation(), diag::note_previous_declaration_as) << OldParamOT;"}}

[j]={{qc,3049,"/// ParseGenericSelectionExpression - Parse a C11 generic-selection\n/// [C11 6.5.1.1].\n///\n/// \\verbatim\n///    generic-selection:\n///          _Generic ( assignment-expression , generic-assoc-list )\n///    generic-assoc-list:\n///          generic-association\n///          generic-assoc-list , generic-association\n///    generic-association:\n///          type-name : assignment-expression\n///          default : assignment-expression\n/// \\endverbatim\n///\n/// As an extension, Clang also accepts:\n/// \\verbatim\n///  generic-selection:\n///          _Generic ( type-name, generic-assoc-list )\n/// \\endverbatim\nExprResult Parser::ParseGenericSelectionExpression() {\n  do {\n    if (Tok.is(tok::kw_default)) {\n      // C11 6.5.1.1p2 \"A generic selection shall have no more than one default\n      // generic association.\"\n      if (!DefaultLoc.isInvalid()) {\n        Diag(DefaultLoc, diag::note_previous_default_assoc);"}}

[j]={{O,3914,"/// ActOnCXXTryBlock - Takes a try compound-statement and a number of\n/// handlers and creates a try statement from them.\nStmtResult Sema::ActOnCXXTryBlock(SourceLocation TryLoc, Stmt *TryBlock, ArrayRef<Stmt *> Handlers) {\n  for (unsigned i = 0; i < NumHandlers; ++i) {\n    if (auto *RD = Underlying->getAsCXXRecordDecl()) {\n      if (RD->lookupInBases(CTPB, Paths)) {\n        if (!Paths.isAmbiguous(CanQualType::CreateUnsafe(CTPB.getFoundHandlerType()))) {\n          Diag(Problem->getExceptionDecl()->getTypeSpecStartLoc(), diag::note_previous_exception_handler) << Problem->getCaughtType();"},{O,3929,"/// ActOnCXXTryBlock - Takes a try compound-statement and a number of\n/// handlers and creates a try statement from them.\nStmtResult Sema::ActOnCXXTryBlock(SourceLocation TryLoc, Stmt *TryBlock, ArrayRef<Stmt *> Handlers) {\n  for (unsigned i = 0; i < NumHandlers; ++i) {\n    if (!R.second) {\n      Diag(Problem->getExceptionDecl()->getTypeSpecStartLoc(), diag::note_previous_exception_handler) << Problem->getCaughtType();"}}

[j]={{x,7643,"/// Diagnose cases where we have an explicit template specialization\n/// before/after an explicit template instantiation, producing diagnostics\n/// for those cases where they are required and determining whether the\n/// new specialization/instantiation will have any effect.\n///\n/// \\param NewLoc the location of the new explicit specialization or\n/// instantiation.\n///\n/// \\param NewTSK the kind of the new explicit specialization or instantiation.\n///\n/// \\param PrevDecl the previous declaration of the entity.\n///\n/// \\param PrevTSK the kind of the old explicit specialization or instantiatin.\n///\n/// \\param PrevPointOfInstantiation if valid, indicates where the previous\n/// declaration was instantiated (either implicitly or explicitly).\n///\n/// \\param HasNoEffect will be set to true to indicate that the new\n/// specialization or instantiation has no effect and should be ignored.\n///\n/// \\returns true if there was an error that should prevent the introduction of\n/// the new declaration into the AST, false otherwise.\nbool Sema::CheckSpecializationInstantiationRedecl(SourceLocation NewLoc, TemplateSpecializationKind NewTSK, NamedDecl *PrevDecl, TemplateSpecializationKind PrevTSK, SourceLocation PrevPointOfInstantiation, bool &HasNoEffect) {\n  case TSK_ExplicitInstantiationDefinition:\n    case TSK_ExplicitInstantiationDefinition:\n      Diag(DiagLocForExplicitInstantiation(PrevDecl, PrevPointOfInstantiation), diag::note_previous_explicit_instantiation);"}}

[j]={{U,2357,"/// 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 (D->isFieldDesignator()) {\n    // C++20 [dcl.init.list]p3:\n    //  The ordered identifiers in the designators of the designated-\n    //  initializer-list shall form a subsequence of the ordered identifiers\n    //  in the direct non-static data members of T.\n    //\n    // Note that this is not a condition on forming the aggregate\n    // initialization, only on actually performing initialization,\n    // so it is not checked in VerifyOnly mode.\n    //\n    // FIXME: This is the only reordering diagnostic we produce, and it only\n    // catches cases where we have a top-level field designator that jumps\n    // backwards. This is the only such case that is reachable in an\n    // otherwise-valid C++20 program, so is the only case that\'s required for\n    // conformance, but for consistency, we should diagnose all the other\n    // cases where a designator takes us backwards too.\n    if (IsFirstDesignator && !VerifyOnly && SemaRef.getLangOpts().CPlusPlus && NextField && (*NextField == RD->field_end() || (*NextField)->getFieldIndex() > Field->getFieldIndex() + 1)) {\n      if (PrevField && PrevField->getFieldIndex() > KnownField->getFieldIndex()) {\n        if (StructuredList && OldIndex <= StructuredList->getNumInits()) {\n          if (Expr *PrevInit = StructuredList->getInit(OldIndex)) {\n            SemaRef.Diag(PrevInit->getBeginLoc(), diag::note_previous_field_init) << PrevField << PrevInit->getSourceRange();"}}

[j]={{v,3128,"// Determine whether the previous declaration was a definition, implicit\n// declaration, or a declaration.\ntemplate <typename T> static std::pair<diag::kind, SourceLocation> getNoteDiagForInvalidRedeclaration(const T *Old, const T *New) {\n  if (Old->isThisDeclarationADefinition())\n  else if (Old->isImplicit()) {\n    PrevDiag = diag::note_previous_implicit_declaration;"},{y,15215,"void Sema::SetDeclDeleted(Decl *Dcl, SourceLocation DelLoc) {\n  if (const FunctionDecl *Prev = Fn->getPreviousDecl()) {\n    // Don\'t consider the implicit declaration we generate for explicit\n    // specializations. FIXME: Do not generate these implicit declarations.\n    if ((Prev->getTemplateSpecializationKind() != TSK_ExplicitSpecialization || Prev->getPreviousDecl()) && !Prev->isDefined()) {\n      Diag(Prev->getLocation().isInvalid() ? DelLoc : Prev->getLocation(), Prev->isImplicit() ? diag::note_previous_implicit_declaration : diag::note_previous_declaration);"}}

[j]={{v,4885,"static void checkDuplicateDefaultInit(Sema &S, CXXRecordDecl *Parent, SourceLocation DefaultInitLoc) {\n  S.Diag(findDefaultInitializer(Parent), diag::note_previous_initializer) << 0;"},{v,11566,"/// 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 (getLangOpts().CPlusPlus) {\n    // C++ [class.static.data]p4\n    //  If a static data member is of const integral or const\n    //  enumeration type, its declaration in the class definition can\n    //  specify a constant-initializer which shall be an integral\n    //  constant expression (5.19). In that case, the member can appear\n    //  in integral constant expressions. The member shall still be\n    //  defined in a namespace scope if it is used in the program and the\n    //  namespace scope definition shall not contain an initializer.\n    //\n    // We already performed a redefinition check above, but for static\n    // data members we also need to check whether there was an in-class\n    // declaration with an initializer.\n    if (VDecl->isStaticDataMember() && VDecl->getCanonicalDecl()->hasInit()) {\n      Diag(VDecl->getCanonicalDecl()->getInit()->getExprLoc(), diag::note_previous_initializer) << 0;"},{y,4781,"bool CheckRedundantInit(Sema &S, CXXCtorInitializer *Init, CXXCtorInitializer *&PrevInit) {\n  S.Diag(PrevInit->getSourceLocation(), diag::note_previous_initializer) << 0 << PrevInit->getSourceRange();"},{y,4799,"bool CheckRedundantUnionInit(Sema &S, CXXCtorInitializer *Init, RedundantUnionMap &Unions) {\n  while (Parent->isAnonymousStructOrUnion() || Parent->isUnion()) {\n    if (Parent->isUnion()) {\n      if (En.first && En.first != Child) {\n        S.Diag(En.second->getSourceLocation(), diag::note_previous_initializer) << 0 << En.second->getSourceRange();"},{U,360,"/// Semantic checking for initializer lists.\n///\n/// The InitListChecker class contains a set of routines that each\n/// handle the initialization of a certain kind of entity, e.g.,\n/// arrays, vectors, struct/union types, scalars, etc. The\n/// InitListChecker itself performs a recursive walk of the subobject\n/// structure of the type to be initialized, while stepping through\n/// the initializer list one element at a time. The IList and Index\n/// parameters to each of the Check* routines contain the active\n/// (syntactic) initializer list and the index into that initializer\n/// list that represents the current initializer. Each routine is\n/// responsible for moving that Index forward as it consumes elements.\n///\n/// Each Check* routine also has a StructuredList/StructuredIndex\n/// arguments, which contains the current \"structured\" (semantic)\n/// initializer list and the index into that initializer list where we\n/// are copying initializers as we map them over to the semantic\n/// list. Once we have completed our recursive walk of the subobject\n/// structure, we will have constructed a full semantic initializer\n/// list.\n///\n/// C99 designators cause changes in the initializer list traversal,\n/// because they make the initialization \"jump\" into a specific\n/// subobject and then continue the initialization from that\n/// point. CheckDesignatedInitializer() recursively steps into the\n/// designated subobject and manages backing out the recursion to\n/// initialize the subobjects after the one designated.\n///\n/// If an initializer list contains any designators, we build a placeholder\n/// structured list even in \'verify only\' mode, so that we can track which\n/// elements need \'empty\' initializtion.\nclass InitListChecker {\n  /// Diagnose that OldInit (or part thereof) has been overridden by NewInit.\n  void diagnoseInitOverride(Expr *OldInit, SourceRange NewInitRange, bool UnionOverride = false, bool FullyOverwritten = true) {\n    if (!VerifyOnly) {\n      SemaRef.Diag(OldInit->getBeginLoc(), diag::note_previous_initializer) << (OldInit->HasSideEffects(SemaRef.Context) && FullyOverwritten) << OldInit->getSourceRange();"}}

[j]={{u,7115,"MSInheritanceAttr *Sema::mergeMSInheritanceAttr(Decl *D, const AttributeCommonInfo &CI, bool BestCase, MSInheritanceModel Model) {\n  if (MSInheritanceAttr *IA = D->getAttr<MSInheritanceAttr>()) {\n    Diag(CI.getLoc(), diag::note_previous_ms_inheritance);"}}

[j]={{y,11546,"Decl *Sema::ActOnNamespaceAliasDef(Scope *S, SourceLocation NamespaceLoc, SourceLocation AliasLoc, IdentifierInfo *Alias, CXXScopeSpec &SS, SourceLocation IdentLoc, IdentifierInfo *Ident) {\n  if (PrevR.isSingleResult()) {\n    if (NamespaceAliasDecl *AD = dyn_cast<NamespaceAliasDecl>(PrevDecl)) {\n      // We already have an alias with the same name that points to the same\n      // namespace; check that it matches.\n      if (AD->getNamespace()->Equals(getNamespaceDecl(ND))) {\n      } else if (isVisible(PrevDecl)) {\n        Diag(AD->getLocation(), diag::note_previous_namespace_alias) << AD->getNamespace();"}}

[j]={{"clang/lib/Parse/ParseStmt.cpp",1332,"struct MisleadingIndentationChecker {\n  void Check() {\n    if (PrevColNum != 0 && CurColNum != 0 && StmtColNum != 0 && ((PrevColNum > StmtColNum && PrevColNum == CurColNum) || !Tok.isAtStartOfLine()) && SM.getPresumedLineNumber(StmtLoc) != SM.getPresumedLineNumber(Tok.getLocation()) && (Tok.isNot(tok::identifier) || P.getPreprocessor().LookAhead(0).isNot(tok::colon))) {\n      P.Diag(StmtLoc, diag::note_previous_statement);"}}

[j]={{x,7612,"/// Diagnose cases where we have an explicit template specialization\n/// before/after an explicit template instantiation, producing diagnostics\n/// for those cases where they are required and determining whether the\n/// new specialization/instantiation will have any effect.\n///\n/// \\param NewLoc the location of the new explicit specialization or\n/// instantiation.\n///\n/// \\param NewTSK the kind of the new explicit specialization or instantiation.\n///\n/// \\param PrevDecl the previous declaration of the entity.\n///\n/// \\param PrevTSK the kind of the old explicit specialization or instantiatin.\n///\n/// \\param PrevPointOfInstantiation if valid, indicates where the previous\n/// declaration was instantiated (either implicitly or explicitly).\n///\n/// \\param HasNoEffect will be set to true to indicate that the new\n/// specialization or instantiation has no effect and should be ignored.\n///\n/// \\returns true if there was an error that should prevent the introduction of\n/// the new declaration into the AST, false otherwise.\nbool Sema::CheckSpecializationInstantiationRedecl(SourceLocation NewLoc, TemplateSpecializationKind NewTSK, NamedDecl *PrevDecl, TemplateSpecializationKind PrevTSK, SourceLocation PrevPointOfInstantiation, bool &HasNoEffect) {\n  case TSK_ExplicitInstantiationDefinition:\n    case TSK_ExplicitSpecialization:\n      Diag(PrevDecl->getLocation(), diag::note_previous_template_specialization);"}}

[j]={{v,14558,"/// Determine whether a tag with a given kind is acceptable\n/// as a redeclaration of the given tag declaration.\n///\n/// \\returns true if the new tag kind is acceptable, false otherwise.\nbool Sema::isAcceptableTagRedeclaration(const TagDecl *Previous, TagTypeKind NewTag, bool isDefinition, SourceLocation NewTagLoc, const IdentifierInfo *Name) {\n  if (Redecl->getTagKind() != NewTag) {\n    Diag(Redecl->getLocation(), diag::note_previous_use);"},{v,15071,"/// This is invoked when we see \'struct foo\' or \'struct {\'.  In the\n/// former case, Name will be non-null.  In the later case, Name will be null.\n/// TagSpec indicates what kind of tag this is. TUK indicates whether this is a\n/// reference/declaration/definition of a tag.\n///\n/// \\param IsTypeSpecifier \\c true if this is a type-specifier (or\n/// trailing-type-specifier) other than one in an alias-declaration.\n///\n/// \\param SkipBody If non-null, will be set to indicate if the caller should\n/// skip the definition of this tag and treat it as if it were a declaration.\nDeclResult Sema::ActOnTag(Scope *S, unsigned TagSpec, TagUseKind TUK, SourceLocation KWLoc, CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation NameLoc, const ParsedAttributesView &Attrs, AccessSpecifier AS, SourceLocation ModulePrivateLoc, MultiTemplateParamsArg TemplateParameterLists, bool &OwnedDecl, bool &IsDependent, SourceLocation ScopedEnumKWLoc, bool ScopedEnumUsesClassTag, TypeResult UnderlyingType, bool IsTypeSpecifier, bool IsTemplateParamOrArg, OffsetOfKind OOK, SkipBodyInfo *SkipBody) {\n  if (!Previous.empty()) {\n    if (TagDecl *PrevTagDecl = dyn_cast<TagDecl>(PrevDecl)) {\n      // If this is a use of a previous tag, or if the tag is already declared\n      // in the same scope (so that the definition/declaration completes or\n      // rementions the tag), reuse the decl.\n      if (TUK == TUK_Reference || TUK == TUK_Friend || isDeclInScope(DirectPrevDecl, SearchDC, S, SS.isNotEmpty() || isMemberSpecialization)) {\n        // Make sure that this wasn\'t declared as an enum and now used as a\n        // struct or something similar.\n        if (!isAcceptableTagRedeclaration(PrevTagDecl, Kind, TUK == TUK_Definition, KWLoc, Name)) {\n          Diag(PrevTagDecl->getLocation(), diag::note_previous_use);"},{E,1254,"/// 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 (IC) {\n    if (Synthesize)\n      if (ObjCPropertyImplDecl *PPIDecl = IC->FindPropertyImplIvarDecl(PropertyIvar)) {\n        Diag(PPIDecl->getLocation(), diag::note_previous_use);"},{E,1285,"/// 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 (IC) {\n  } else {\n    if (Synthesize)\n      if (ObjCPropertyImplDecl *PPIDecl = CatImplClass->FindPropertyImplIvarDecl(PropertyIvar)) {\n        Diag(PPIDecl->getLocation(), diag::note_previous_use);"},{x,1683,"DeclResult Sema::CheckClassTemplate(Scope *S, unsigned TagSpec, TagUseKind TUK, SourceLocation KWLoc, CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation NameLoc, const ParsedAttributesView &Attr, TemplateParameterList *TemplateParams, AccessSpecifier AS, SourceLocation ModulePrivateLoc, SourceLocation FriendLoc, unsigned NumOuterTemplateParamLists, TemplateParameterList **OuterTemplateParamLists, SkipBodyInfo *SkipBody) {\n  if (PrevClassTemplate) {\n    if (!isAcceptableTagRedeclaration(PrevRecordDecl, Kind, TUK == TUK_Definition, KWLoc, Name)) {\n      Diag(PrevRecordDecl->getLocation(), diag::note_previous_use);"},{x,3600,"TypeResult Sema::ActOnTagTemplateIdType(TagUseKind TUK, TypeSpecifierType TagSpec, SourceLocation TagLoc, CXXScopeSpec &SS, SourceLocation TemplateKWLoc, TemplateTy TemplateD, SourceLocation TemplateLoc, SourceLocation LAngleLoc, ASTTemplateArgsPtr TemplateArgsIn, SourceLocation RAngleLoc) {\n  // Check the tag kind\n  if (const RecordType *RT = Result->getAs<RecordType>()) {\n    if (!isAcceptableTagRedeclaration(D, TagKind, TUK == TUK_Definition, TagLoc, Id)) {\n      Diag(D->getLocation(), diag::note_previous_use);"},{x,7148,"DeclResult Sema::ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec, TagUseKind TUK, SourceLocation KWLoc, SourceLocation ModulePrivateLoc, CXXScopeSpec &SS, TemplateIdAnnotation &TemplateId, const ParsedAttributesView &Attr, MultiTemplateParamsArg TemplateParameterLists, SkipBodyInfo *SkipBody) {\n  if (!isAcceptableTagRedeclaration(ClassTemplate->getTemplatedDecl(), Kind, TUK == TUK_Definition, KWLoc, ClassTemplate->getIdentifier())) {\n    Diag(ClassTemplate->getTemplatedDecl()->getLocation(), diag::note_previous_use);"},{x,8202,"// Explicit instantiation of a class template specialization\nDeclResult Sema::ActOnExplicitInstantiation(Scope *S, SourceLocation ExternLoc, SourceLocation TemplateLoc, unsigned TagSpec, SourceLocation KWLoc, const CXXScopeSpec &SS, TemplateTy TemplateD, SourceLocation TemplateNameLoc, SourceLocation LAngleLoc, ASTTemplateArgsPtr TemplateArgsIn, SourceLocation RAngleLoc, const ParsedAttributesView &Attr) {\n  if (!ClassTemplate) {\n    Diag(TD->getLocation(), diag::note_previous_use);"},{x,8208,"// Explicit instantiation of a class template specialization\nDeclResult Sema::ActOnExplicitInstantiation(Scope *S, SourceLocation ExternLoc, SourceLocation TemplateLoc, unsigned TagSpec, SourceLocation KWLoc, const CXXScopeSpec &SS, TemplateTy TemplateD, SourceLocation TemplateNameLoc, SourceLocation LAngleLoc, ASTTemplateArgsPtr TemplateArgsIn, SourceLocation RAngleLoc, const ParsedAttributesView &Attr) {\n  if (!isAcceptableTagRedeclaration(ClassTemplate->getTemplatedDecl(), Kind, /*isDefinition*/ false, KWLoc, ClassTemplate->getIdentifier())) {\n    Diag(ClassTemplate->getTemplatedDecl()->getLocation(), diag::note_previous_use);"},{gb,1232,"QualType TemplateInstantiator::RebuildElaboratedType(SourceLocation KeywordLoc, ElaboratedTypeKeyword Keyword, NestedNameSpecifierLoc QualifierLoc, QualType T) {\n  if (const TagType *TT = T->getAs<TagType>()) {\n    // TODO: should we even warn on struct/class mismatches for this?  Seems\n    // like it\'s likely to produce a lot of spurious errors.\n    if (Id && Keyword != ETK_None && Keyword != ETK_Typename) {\n      if (!SemaRef.isAcceptableTagRedeclaration(TD, Kind, /*isDefinition*/ false, TagLocation, Id)) {\n        SemaRef.Diag(TD->getLocation(), diag::note_previous_use);"}}

[j]={{u,6151,"UuidAttr *Sema::mergeUuidAttr(Decl *D, const AttributeCommonInfo &CI, StringRef UuidAsWritten, MSGuidDecl *GuidDecl) {\n  if (const auto *UA = D->getAttr<UuidAttr>()) {\n    if (!UA->getGuid().empty()) {\n      Diag(CI.getLoc(), diag::note_previous_uuid);"}}

[j]={{F,9716,"// Check if a (w)string was passed when a (w)char* was needed, and offer a\n// better diagnostic if so. AT is assumed to be valid.\n// Returns true when a c_str() conversion method is found.\nbool CheckPrintfHandler::checkForCStrMembers(const analyze_printf::ArgType &AT, const Expr *E) {\n  for (MethodSet::iterator MI = Results.begin(), ME = Results.end(); MI != ME; ++MI) {\n    if (Method->getMinRequiredArguments() == 0 && AT.matchesType(S.Context, Method->getReturnType())) {\n      S.Diag(E->getBeginLoc(), diag::note_printf_c_str) << \"c_str()\" << FixItHint::CreateInsertion(EndLoc, \".c_str()\");"}}

[j]={{gb,617,"/// Prints the current instantiation stack through a series of\n/// notes.\nvoid Sema::PrintInstantiationStack() {\n  for (SmallVectorImpl<CodeSynthesisContext>::reverse_iterator Active = CodeSynthesisContexts.rbegin(), ActiveEnd = CodeSynthesisContexts.rend(); Active != ActiveEnd; ++Active, ++InstantiationIdx) {\n    case CodeSynthesisContext::PriorTemplateArgumentSubstitution: {\n      Diags.Report(Active->PointOfInstantiation, diag::note_prior_template_arg_substitution) << isa<TemplateTemplateParmDecl>(Parm) << Name << getTemplateArgumentBindingsText(TemplateParams, Active->TemplateArgs, Active->NumTemplateArgs) << Active->InstantiationRange;"}}

[j]={{v,12032,"void Sema::ActOnUninitializedDecl(Decl *RealDecl) {\n  if (VarDecl *Var = dyn_cast<VarDecl>(RealDecl)) {\n    case VarDecl::DeclarationOnly:\n      if (!Type->isDependentType() && !Var->isInvalidDecl() && Var->getStorageClass() == SC_PrivateExtern) {\n        Diag(Var->getLocation(), diag::note_private_extern);"}}

[j]={{yc,1125,"/// ActOnEndOfTranslationUnit - This is called at the very end of the\n/// translation unit when EOF is reached and all but the top-level scope is\n/// popped.\nvoid Sema::ActOnEndOfTranslationUnit() {\n  // C++ standard modules. Diagnose cases where a function is declared inline\n  // in the module purview but has no definition before the end of the TU or\n  // the start of a Private Module Fragment (if one is present).\n  if (!PendingInlineFuncDecls.empty()) {\n    for (auto *D : PendingInlineFuncDecls) {\n      if (auto *FD = dyn_cast<FunctionDecl>(D)) {\n        // If we have a PMF it should be at the end of the ModuleScopes.\n        if (DefInPMF && ModuleScopes.back().Module->Kind == Module::PrivateModuleFragment) {\n          Diag(ModuleScopes.back().BeginLoc, diag::note_private_module_fragment);"},{jc,696,"/// We have parsed the start of an export declaration, including the \'{\'\n/// (if present).\nDecl *Sema::ActOnStartExportDecl(Scope *S, SourceLocation ExportLoc, SourceLocation LBraceLoc) {\n  // C++2a [module.interface]p1:\n  //  An export-declaration shall appear only [...] in the purview of a module\n  //  interface unit. An export-declaration shall not appear directly or\n  //  indirectly within [...] a private-module-fragment.\n  if (!isCurrentModulePurview()) {\n  } else if (!ModuleScopes.back().ModuleInterface) {\n  } else if (ModuleScopes.back().Module->Kind == Module::PrivateModuleFragment) {\n    Diag(ModuleScopes.back().BeginLoc, diag::note_private_module_fragment);"}}

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

[j]={{Kb,302,"/// Actually emit an availability diagnostic for a reference to an unavailable\n/// decl.\n///\n/// \\param Ctx The context that the reference occurred in\n/// \\param ReferringDecl The exact declaration that was referenced.\n/// \\param OffendingDecl A related decl to \\c ReferringDecl that has an\n/// availability attribute corresponding to \\c K attached to it. Note that this\n/// may not be the same as ReferringDecl, i.e. if an EnumDecl is annotated and\n/// we refer to a member EnumConstantDecl, ReferringDecl is the EnumConstantDecl\n/// and OffendingDecl is the EnumDecl.\nstatic void DoEmitAvailabilityWarning(Sema &S, AvailabilityResult K, Decl *Ctx, const NamedDecl *ReferringDecl, const NamedDecl *OffendingDecl, StringRef Message, ArrayRef<SourceLocation> Locs, const ObjCInterfaceDecl *UnknownObjCClass, const ObjCPropertyDecl *ObjCProperty, bool ObjCPropertyAccess) {\n  // Matches \'diag::note_property_attribute\' options."},{Kb,471,"/// Actually emit an availability diagnostic for a reference to an unavailable\n/// decl.\n///\n/// \\param Ctx The context that the reference occurred in\n/// \\param ReferringDecl The exact declaration that was referenced.\n/// \\param OffendingDecl A related decl to \\c ReferringDecl that has an\n/// availability attribute corresponding to \\c K attached to it. Note that this\n/// may not be the same as ReferringDecl, i.e. if an EnumDecl is annotated and\n/// we refer to a member EnumConstantDecl, ReferringDecl is the EnumConstantDecl\n/// and OffendingDecl is the EnumDecl.\nstatic void DoEmitAvailabilityWarning(Sema &S, AvailabilityResult K, Decl *Ctx, const NamedDecl *ReferringDecl, const NamedDecl *OffendingDecl, StringRef Message, ArrayRef<SourceLocation> Locs, const ObjCInterfaceDecl *UnknownObjCClass, const ObjCPropertyDecl *ObjCProperty, bool ObjCPropertyAccess) {\n  if (!Message.empty()) {\n    if (ObjCProperty)\n      S.Diag(ObjCProperty->getLocation(), diag::note_property_attribute) << ObjCProperty->getDeclName() << property_note_select;"},{Kb,475,"/// Actually emit an availability diagnostic for a reference to an unavailable\n/// decl.\n///\n/// \\param Ctx The context that the reference occurred in\n/// \\param ReferringDecl The exact declaration that was referenced.\n/// \\param OffendingDecl A related decl to \\c ReferringDecl that has an\n/// availability attribute corresponding to \\c K attached to it. Note that this\n/// may not be the same as ReferringDecl, i.e. if an EnumDecl is annotated and\n/// we refer to a member EnumConstantDecl, ReferringDecl is the EnumConstantDecl\n/// and OffendingDecl is the EnumDecl.\nstatic void DoEmitAvailabilityWarning(Sema &S, AvailabilityResult K, Decl *Ctx, const NamedDecl *ReferringDecl, const NamedDecl *OffendingDecl, StringRef Message, ArrayRef<SourceLocation> Locs, const ObjCInterfaceDecl *UnknownObjCClass, const ObjCPropertyDecl *ObjCProperty, bool ObjCPropertyAccess) {\n  if (!Message.empty()) {\n  } else if (!UnknownObjCClass) {\n    if (ObjCProperty)\n      S.Diag(ObjCProperty->getLocation(), diag::note_property_attribute) << ObjCProperty->getDeclName() << property_note_select;"}}

[j]={{B,4480,"void Sema::DiagnoseUnusedBackingIvarInAccessor(Scope *S, const ObjCImplementationDecl *ImplD) {\n  for (const auto *CurMethod : ImplD->instance_methods()) {\n    // Do not issue this warning if backing ivar is used somewhere and accessor\n    // implementation makes a self call. This is to prevent false positive in\n    // cases where the ivar is accessed by another method that the accessor\n    // delegates to.\n    if (!IV->isReferenced() || !Checker.InvokedSelfMethod) {\n      Diag(PDecl->getLocation(), diag::note_property_declare);"},{E,347,"/// Check for a mismatch in the atomicity of the given properties.\nstatic void checkAtomicPropertyMismatch(Sema &S, ObjCPropertyDecl *OldProperty, ObjCPropertyDecl *NewProperty, bool PropagateAtomicity) {\n  S.Diag(OldProperty->getLocation(), diag::note_property_declare);"},{E,373,"ObjCPropertyDecl *Sema::HandlePropertyInClassExtension(Scope *S, SourceLocation AtLoc, SourceLocation LParenLoc, FieldDeclarator &FD, Selector GetterSel, SourceLocation GetterNameLoc, Selector SetterSel, SourceLocation SetterNameLoc, const bool isReadWrite, unsigned &Attributes, const unsigned AttributesAsWritten, QualType T, TypeSourceInfo *TSI, tok::ObjCKeywordKind MethodImplKind) {\n  // If we found a property in an extension, complain.\n  if (PIDecl && isa<ObjCCategoryDecl>(PIDecl->getDeclContext())) {\n    Diag(PIDecl->getLocation(), diag::note_property_declare);"},{E,389,"ObjCPropertyDecl *Sema::HandlePropertyInClassExtension(Scope *S, SourceLocation AtLoc, SourceLocation LParenLoc, FieldDeclarator &FD, Selector GetterSel, SourceLocation GetterNameLoc, Selector SetterSel, SourceLocation SetterNameLoc, const bool isReadWrite, unsigned &Attributes, const unsigned AttributesAsWritten, QualType T, TypeSourceInfo *TSI, tok::ObjCKeywordKind MethodImplKind) {\n  // Check for consistency with the previous declaration, if there is one.\n  if (PIDecl) {\n    // A readonly property declared in the primary class can be refined\n    // by adding a readwrite property within an extension.\n    // Anything else is an error.\n    if (!(PIDecl->isReadOnly() && isReadWrite)) {\n      Diag(PIDecl->getLocation(), diag::note_property_declare);"},{E,398,"ObjCPropertyDecl *Sema::HandlePropertyInClassExtension(Scope *S, SourceLocation AtLoc, SourceLocation LParenLoc, FieldDeclarator &FD, Selector GetterSel, SourceLocation GetterNameLoc, Selector SetterSel, SourceLocation SetterNameLoc, const bool isReadWrite, unsigned &Attributes, const unsigned AttributesAsWritten, QualType T, TypeSourceInfo *TSI, tok::ObjCKeywordKind MethodImplKind) {\n  // Check for consistency with the previous declaration, if there is one.\n  if (PIDecl) {\n    // Check for consistency of getters.\n    if (PIDecl->getGetterName() != GetterSel) {\n      // If the getter was written explicitly, complain.\n      if (AttributesAsWritten & ObjCPropertyAttribute::kind_getter) {\n        Diag(PIDecl->getLocation(), diag::note_property_declare);"},{E,413,"ObjCPropertyDecl *Sema::HandlePropertyInClassExtension(Scope *S, SourceLocation AtLoc, SourceLocation LParenLoc, FieldDeclarator &FD, Selector GetterSel, SourceLocation GetterNameLoc, Selector SetterSel, SourceLocation SetterNameLoc, const bool isReadWrite, unsigned &Attributes, const unsigned AttributesAsWritten, QualType T, TypeSourceInfo *TSI, tok::ObjCKeywordKind MethodImplKind) {\n  // Check for consistency with the previous declaration, if there is one.\n  if (PIDecl) {\n    if (ExistingOwnership && NewOwnership != ExistingOwnership) {\n      // If the ownership was written explicitly, complain.\n      if (getOwnershipRule(AttributesAsWritten)) {\n        Diag(PIDecl->getLocation(), diag::note_property_declare);"},{E,423,"ObjCPropertyDecl *Sema::HandlePropertyInClassExtension(Scope *S, SourceLocation AtLoc, SourceLocation LParenLoc, FieldDeclarator &FD, Selector GetterSel, SourceLocation GetterNameLoc, Selector SetterSel, SourceLocation SetterNameLoc, const bool isReadWrite, unsigned &Attributes, const unsigned AttributesAsWritten, QualType T, TypeSourceInfo *TSI, tok::ObjCKeywordKind MethodImplKind) {\n  // Check for consistency with the previous declaration, if there is one.\n  if (PIDecl) {\n    // If the redeclaration is \'weak\' but the original property is not,\n    if ((Attributes & ObjCPropertyAttribute::kind_weak) && !(PIDecl->getPropertyAttributesAsWritten() & ObjCPropertyAttribute::kind_weak) && PIDecl->getType()->getAs<ObjCObjectPointerType>() && PIDecl->getType().getObjCLifetime() == Qualifiers::OCL_None) {\n      Diag(PIDecl->getLocation(), diag::note_property_declare);"},{E,451,"ObjCPropertyDecl *Sema::HandlePropertyInClassExtension(Scope *S, SourceLocation AtLoc, SourceLocation LParenLoc, FieldDeclarator &FD, Selector GetterSel, SourceLocation GetterNameLoc, Selector SetterSel, SourceLocation SetterNameLoc, const bool isReadWrite, unsigned &Attributes, const unsigned AttributesAsWritten, QualType T, TypeSourceInfo *TSI, tok::ObjCKeywordKind MethodImplKind) {\n  if (!Context.hasSameType(PIDecl->getType(), PDecl->getType())) {\n    if (!isa<ObjCObjectPointerType>(PrimaryClassPropertyT) || !isa<ObjCObjectPointerType>(ClassExtPropertyT) || (!isObjCPointerConversion(ClassExtPropertyT, PrimaryClassPropertyT, ConvertedType, IncompatibleObjC)) || IncompatibleObjC) {\n      Diag(PIDecl->getLocation(), diag::note_property_declare);"},{E,507,"ObjCPropertyDecl *Sema::CreatePropertyDecl(Scope *S, ObjCContainerDecl *CDecl, SourceLocation AtLoc, SourceLocation LParenLoc, FieldDeclarator &FD, Selector GetterSel, SourceLocation GetterNameLoc, Selector SetterSel, SourceLocation SetterNameLoc, const bool isReadWrite, const unsigned Attributes, const unsigned AttributesAsWritten, QualType T, TypeSourceInfo *TInfo, tok::ObjCKeywordKind MethodImplKind, DeclContext *lexicalDC) {\n  // Class property and instance property can have the same name.\n  if (ObjCPropertyDecl *prevDecl = ObjCPropertyDecl::findPropertyDecl(DC, PropertyId, ObjCPropertyDecl::getQueryKind(isClassProperty))) {\n    Diag(prevDecl->getLocation(), diag::note_property_declare);"},{E,652,"static void checkARCPropertyImpl(Sema &S, SourceLocation propertyImplLoc, ObjCPropertyDecl *property, ObjCIvarDecl *ivar) {\n  S.Diag(property->getLocation(), diag::note_property_declare);"},{E,927,"/// 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 ((IC = dyn_cast<ObjCImplementationDecl>(ClassImpDecl))) {\n    if ((PIkind & (ObjCPropertyAttribute::kind_atomic | ObjCPropertyAttribute::kind_nonatomic)) == 0) {\n      Diag(property->getLocation(), diag::note_property_declare);"},{E,933,"/// 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 ((IC = dyn_cast<ObjCImplementationDecl>(ClassImpDecl))) {\n    if (const ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(property->getDeclContext())) {\n      if (!CD->IsClassExtension()) {\n        Diag(property->getLocation(), diag::note_property_declare);"},{E,1006,"/// 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 (RequireCompleteType(PropertyDiagLoc, PropertyIvarType, diag::err_incomplete_synthesized_property, property->getDeclName())) {\n      Diag(property->getLocation(), diag::note_property_declare);"},{E,1023,"/// 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        if (PropertyIvarType.isObjCGCStrong()) {\n          Diag(property->getLocation(), diag::note_property_declare);"},{E,1035,"/// 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          // Only complain here when synthesizing an ivar.\n          if (!Ivar) {\n            Diag(property->getLocation(), diag::note_property_declare);"},{E,1060,"/// 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 (AtLoc.isInvalid()) {\n      if (originalIvar) {\n        Diag(property->getLocation(), diag::note_property_declare);"},{E,1074,"/// 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(property->getLocation(), diag::note_property_declare);"},{E,1087,"/// 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)) {\n        Diag(property->getLocation(), diag::note_property_declare);"},{E,1196,"/// 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 (property->hasAttr<NSReturnsNotRetainedAttr>() && !getterMethod->hasAttr<NSReturnsNotRetainedAttr>()) {\n      Diag(property->getLocation(), diag::note_property_declare);"},{E,1344,"/// DiagnosePropertyMismatch - Compares two properties for their\n/// attributes and types and warns on a variety of inconsistencies.\n///\nvoid Sema::DiagnosePropertyMismatch(ObjCPropertyDecl *Property, ObjCPropertyDecl *SuperProperty, const IdentifierInfo *inheritedName, bool OverridingProtocolProperty) {\n  // Readonly properties from protocols can be implemented as \"readwrite\"\n  // with a custom setter name.\n  if (Property->getSetterName() != SuperProperty->getSetterName() && !(SuperProperty->isReadOnly() && isa<ObjCProtocolDecl>(SuperProperty->getDeclContext()))) {\n    Diag(SuperProperty->getLocation(), diag::note_property_declare);"},{E,1348,"/// DiagnosePropertyMismatch - Compares two properties for their\n/// attributes and types and warns on a variety of inconsistencies.\n///\nvoid Sema::DiagnosePropertyMismatch(ObjCPropertyDecl *Property, ObjCPropertyDecl *SuperProperty, const IdentifierInfo *inheritedName, bool OverridingProtocolProperty) {\n  if (Property->getGetterName() != SuperProperty->getGetterName()) {\n    Diag(SuperProperty->getLocation(), diag::note_property_declare);"},{E,1361,"/// DiagnosePropertyMismatch - Compares two properties for their\n/// attributes and types and warns on a variety of inconsistencies.\n///\nvoid Sema::DiagnosePropertyMismatch(ObjCPropertyDecl *Property, ObjCPropertyDecl *SuperProperty, const IdentifierInfo *inheritedName, bool OverridingProtocolProperty) {\n  if (!Context.propertyTypesAreCompatible(LHSType, RHSType)) {\n    if (!isObjCPointerConversion(RHSType, LHSType, ConvertedType, IncompatibleObjC) || IncompatibleObjC) {\n      Diag(SuperProperty->getLocation(), diag::note_property_declare);"},{E,1546,"/// Default synthesizes all properties which must be synthesized\n/// in class\'s \\@implementation.\nvoid Sema::DefaultSynthesizeProperties(Scope *S, ObjCImplDecl *IMPDecl, ObjCInterfaceDecl *IDecl, SourceLocation AtEnd) {\n  for (const auto &PropEntry : PropMap) {\n    if (ObjCProtocolDecl *Proto = dyn_cast<ObjCProtocolDecl>(Prop->getDeclContext())) {\n      // We won\'t auto-synthesize properties declared in protocols.\n      // Suppress the warning if class\'s superclass implements property\'s\n      // getter and implements property\'s setter (if readwrite property).\n      // Or, if property is going to be implemented in its super class.\n      if (!SuperClassImplementsProperty(IDecl, Prop) && !PropInSuperClass) {\n        Diag(Prop->getLocation(), diag::note_property_declare);"},{E,1556,"/// Default synthesizes all properties which must be synthesized\n/// in class\'s \\@implementation.\nvoid Sema::DefaultSynthesizeProperties(Scope *S, ObjCImplDecl *IMPDecl, ObjCInterfaceDecl *IDecl, SourceLocation AtEnd) {\n  for (const auto &PropEntry : PropMap) {\n    // If property to be implemented in the super class, ignore.\n    if (PropInSuperClass) {\n      if ((Prop->getPropertyAttributes() & ObjCPropertyAttribute::kind_readwrite) && (PropInSuperClass->getPropertyAttributes() & ObjCPropertyAttribute::kind_readonly) && !IMPDecl->getInstanceMethod(Prop->getSetterName()) && !IDecl->HasUserDeclaredSetterMethod(Prop)) {\n        Diag(PropInSuperClass->getLocation(), diag::note_property_declare);"},{E,1559,"/// Default synthesizes all properties which must be synthesized\n/// in class\'s \\@implementation.\nvoid Sema::DefaultSynthesizeProperties(Scope *S, ObjCImplDecl *IMPDecl, ObjCInterfaceDecl *IDecl, SourceLocation AtEnd) {\n  for (const auto &PropEntry : PropMap) {\n    // If property to be implemented in the super class, ignore.\n    if (PropInSuperClass) {\n      if ((Prop->getPropertyAttributes() & ObjCPropertyAttribute::kind_readwrite) && (PropInSuperClass->getPropertyAttributes() & ObjCPropertyAttribute::kind_readonly) && !IMPDecl->getInstanceMethod(Prop->getSetterName()) && !IDecl->HasUserDeclaredSetterMethod(Prop)) {\n      } else {\n        Diag(PropInSuperClass->getLocation(), diag::note_property_declare);"},{E,1600,"static void DiagnoseUnimplementedAccessor(Sema &S, ObjCInterfaceDecl *PrimaryClass, Selector Method, ObjCImplDecl *IMPDecl, ObjCContainerDecl *CDecl, ObjCCategoryDecl *C, ObjCPropertyDecl *Prop, llvm::SmallPtrSet<const ObjCMethodDecl *, 8> &SMap) {\n  // When reporting on missing property setter/getter implementation in\n  // categories, do not report when they are declared in primary class,\n  // class\'s protocol, or one of it super classes. This is because,\n  // the class is going to implement them.\n  if (I == SMap.end() && (PrimaryClass == nullptr || !PrimaryClass->lookupPropertyAccessor(Method, C, Prop->isClassProperty()))) {\n    S.Diag(Prop->getLocation(), diag::note_property_declare);"},{E,1750,"void Sema::AtomicPropertySetterGetterRules(ObjCImplDecl *IMPDecl, ObjCInterfaceDecl *IDecl) {\n  for (ObjCContainerDecl::PropertyMap::iterator I = PM.begin(), E = PM.end(); I != E; ++I) {\n    if (!(AttributesAsWritten & ObjCPropertyAttribute::kind_atomic) && !(AttributesAsWritten & ObjCPropertyAttribute::kind_nonatomic)) {\n      if (GetterMethod) {\n        Diag(Property->getLocation(), diag::note_property_declare);"},{E,1754,"void Sema::AtomicPropertySetterGetterRules(ObjCImplDecl *IMPDecl, ObjCInterfaceDecl *IDecl) {\n  for (ObjCContainerDecl::PropertyMap::iterator I = PM.begin(), E = PM.end(); I != E; ++I) {\n    if (!(AttributesAsWritten & ObjCPropertyAttribute::kind_atomic) && !(AttributesAsWritten & ObjCPropertyAttribute::kind_nonatomic)) {\n      if (SetterMethod) {\n        Diag(Property->getLocation(), diag::note_property_declare);"},{E,1785,"void Sema::AtomicPropertySetterGetterRules(ObjCImplDecl *IMPDecl, ObjCInterfaceDecl *IDecl) {\n  for (ObjCContainerDecl::PropertyMap::iterator I = PM.begin(), E = PM.end(); I != E; ++I) {\n    if (const ObjCPropertyImplDecl *PIDecl = IMPDecl->FindPropertyImplDecl(Property->getIdentifier(), Property->getQueryKind())) {\n      if ((bool)GetterMethod ^ (bool)SetterMethod) {\n        Diag(Property->getLocation(), diag::note_property_declare);"},{Db,562,"/// Try to find the most accurate setter declaration for the property\n/// reference.\n///\n/// \\return true if a setter was found, in which case Setter\nbool ObjCPropertyOpBuilder::findSetter(bool warn) {\n  // Do a normal method lookup first.\n  if (ObjCMethodDecl *setter = LookupMethodInReceiverType(S, SetterSelector, RefExpr)) {\n    if (setter->isPropertyAccessor() && warn)\n      if (const ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(setter->getDeclContext())) {\n        if (ObjCPropertyDecl *prop1 = IFace->FindPropertyDeclaration(AltMember, prop->getQueryKind()))\n          if (prop != prop1 && (prop1->getSetterMethodDecl() == setter)) {\n            S.Diag(prop->getLocation(), diag::note_property_declare);"},{Db,563,"/// Try to find the most accurate setter declaration for the property\n/// reference.\n///\n/// \\return true if a setter was found, in which case Setter\nbool ObjCPropertyOpBuilder::findSetter(bool warn) {\n  // Do a normal method lookup first.\n  if (ObjCMethodDecl *setter = LookupMethodInReceiverType(S, SetterSelector, RefExpr)) {\n    if (setter->isPropertyAccessor() && warn)\n      if (const ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(setter->getDeclContext())) {\n        if (ObjCPropertyDecl *prop1 = IFace->FindPropertyDeclaration(AltMember, prop->getQueryKind()))\n          if (prop != prop1 && (prop1->getSetterMethodDecl() == setter)) {\n            S.Diag(prop1->getLocation(), diag::note_property_declare);"},{Db,582,"void ObjCPropertyOpBuilder::DiagnoseUnsupportedPropertyUse() {\n  if (S.getCurLexicalContext()->isObjCContainer() && S.getCurLexicalContext()->getDeclKind() != Decl::ObjCCategoryImpl && S.getCurLexicalContext()->getDeclKind() != Decl::ObjCImplementation) {\n    if (ObjCPropertyDecl *prop = RefExpr->getExplicitProperty()) {\n      S.Diag(prop->getLocation(), diag::note_property_declare);"}}

[j]={{E,654,"static void checkARCPropertyImpl(Sema &S, SourceLocation propertyImplLoc, ObjCPropertyDecl *property, ObjCIvarDecl *ivar) {\n  if (propertyImplLoc.isValid())\n    S.Diag(propertyImplLoc, diag::note_property_synthesize);"},{E,826,"/// SelectPropertyForSynthesisFromProtocols - Finds the most appropriate\n/// property declaration that should be synthesised in all of the inherited\n/// protocols. It also diagnoses properties declared in inherited protocols with\n/// mismatched types or attributes, since any of them can be candidate for\n/// synthesis.\nstatic ObjCPropertyDecl *SelectPropertyForSynthesisFromProtocols(Sema &S, SourceLocation AtLoc, ObjCInterfaceDecl *ClassDecl, ObjCPropertyDecl *Property) {\n  if (AtLoc.isValid())\n    S.Diag(AtLoc, diag::note_property_synthesize);"},{E,1535,"/// Default synthesizes all properties which must be synthesized\n/// in class\'s \\@implementation.\nvoid Sema::DefaultSynthesizeProperties(Scope *S, ObjCImplDecl *IMPDecl, ObjCInterfaceDecl *IDecl, SourceLocation AtEnd) {\n  for (const auto &PropEntry : PropMap) {\n    if (ObjCPropertyImplDecl *PID = IMPDecl->FindPropertyImplIvarDecl(Prop->getIdentifier())) {\n      if (PID->getLocation().isValid())\n        Diag(PID->getLocation(), diag::note_property_synthesize);"}}

[j]={{N,145,"/// GetDiagForGotoScopeDecl - If this decl induces a new goto scope, return a\n/// diagnostic that should be emitted if control goes over it. If not, return 0.\nstatic ScopePair GetDiagForGotoScopeDecl(Sema &S, const Decl *D) {\n  if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {\n    if (VD->hasAttr<BlocksAttr>())\n      return ScopePair(diag::note_protected_by___block, diag::note_exits___block);"}}

[j]={{N,148,"/// GetDiagForGotoScopeDecl - If this decl induces a new goto scope, return a\n/// diagnostic that should be emitted if control goes over it. If not, return 0.\nstatic ScopePair GetDiagForGotoScopeDecl(Sema &S, const Decl *D) {\n  if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {\n    if (VD->hasAttr<CleanupAttr>())\n      return ScopePair(diag::note_protected_by_cleanup, diag::note_exits_cleanup);"}}

[j]={{N,350,"/// BuildScopeInformation - The statements from CI to CE are known to form a\n/// coherent VLA scope with a specified parent node.  Walk through the\n/// statements, adding any labels or gotos to LabelAndGotoScopes and recursively\n/// walking the AST as needed.\nvoid JumpScopeChecker::BuildScopeInformation(Stmt *S, unsigned &origParentScope) {\n  case Stmt::IfStmtClass: {\n    if (IS->isConstexpr())\n    else if (IS->isConsteval())\n      Diag = diag::note_protected_by_consteval_if;"}}

[j]={{N,348,"/// BuildScopeInformation - The statements from CI to CE are known to form a\n/// coherent VLA scope with a specified parent node.  Walk through the\n/// statements, adding any labels or gotos to LabelAndGotoScopes and recursively\n/// walking the AST as needed.\nvoid JumpScopeChecker::BuildScopeInformation(Stmt *S, unsigned &origParentScope) {\n  case Stmt::IfStmtClass: {\n    if (IS->isConstexpr())\n      Diag = diag::note_protected_by_constexpr_if;"}}

[j]={{N,387,"/// BuildScopeInformation - The statements from CI to CE are known to form a\n/// coherent VLA scope with a specified parent node.  Walk through the\n/// statements, adding any labels or gotos to LabelAndGotoScopes and recursively\n/// walking the AST as needed.\nvoid JumpScopeChecker::BuildScopeInformation(Stmt *S, unsigned &origParentScope) {\n  case Stmt::CXXTryStmtClass: {\n    // Jump from the catch into the try is not allowed either.\n    for (unsigned I = 0, E = TS->getNumHandlers(); I != E; ++I) {\n      Scopes.push_back(GotoScope(ParentScope, diag::note_protected_by_cxx_catch, diag::note_exits_cxx_catch, CS->getSourceRange().getBegin()));"}}

[j]={{N,378,"/// BuildScopeInformation - The statements from CI to CE are known to form a\n/// coherent VLA scope with a specified parent node.  Walk through the\n/// statements, adding any labels or gotos to LabelAndGotoScopes and recursively\n/// walking the AST as needed.\nvoid JumpScopeChecker::BuildScopeInformation(Stmt *S, unsigned &origParentScope) {\n  case Stmt::CXXTryStmtClass: {\n    {\n      Scopes.push_back(GotoScope(ParentScope, diag::note_protected_by_cxx_try, diag::note_exits_cxx_try, TS->getSourceRange().getBegin()));"}}

[j]={{N,346,"/// BuildScopeInformation - The statements from CI to CE are known to form a\n/// coherent VLA scope with a specified parent node.  Walk through the\n/// statements, adding any labels or gotos to LabelAndGotoScopes and recursively\n/// walking the AST as needed.\nvoid JumpScopeChecker::BuildScopeInformation(Stmt *S, unsigned &origParentScope) {\n  case Stmt::IfStmtClass: {\n    unsigned Diag = diag::note_protected_by_if_available;"}}

[j]={{N,159,"/// GetDiagForGotoScopeDecl - If this decl induces a new goto scope, return a\n/// diagnostic that should be emitted if control goes over it. If not, return 0.\nstatic ScopePair GetDiagForGotoScopeDecl(Sema &S, const Decl *D) {\n  if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {\n    if (VD->hasLocalStorage()) {\n      case QualType::DK_nontrivial_c_struct:\n        return ScopePair(diag::note_protected_by_non_trivial_c_struct_init, diag::note_exits_dtor);"}}

[j]={{N,493,"/// BuildScopeInformation - The statements from CI to CE are known to form a\n/// coherent VLA scope with a specified parent node.  Walk through the\n/// statements, adding any labels or gotos to LabelAndGotoScopes and recursively\n/// walking the AST as needed.\nvoid JumpScopeChecker::BuildScopeInformation(Stmt *S, unsigned &origParentScope) {\n  case Stmt::ObjCAutoreleasePoolStmtClass: {\n    Scopes.push_back(GotoScope(ParentScope, diag::note_protected_by_objc_autoreleasepool, diag::note_exits_objc_autoreleasepool, AS->getAtLoc()));"}}

[j]={{N,456,"/// BuildScopeInformation - The statements from CI to CE are known to form a\n/// coherent VLA scope with a specified parent node.  Walk through the\n/// statements, adding any labels or gotos to LabelAndGotoScopes and recursively\n/// walking the AST as needed.\nvoid JumpScopeChecker::BuildScopeInformation(Stmt *S, unsigned &origParentScope) {\n  case Stmt::ObjCAtTryStmtClass: {\n    // Jump from the catch to the finally or try is not valid.\n    for (ObjCAtCatchStmt *AC : AT->catch_stmts()) {\n      Scopes.push_back(GotoScope(ParentScope, diag::note_protected_by_objc_catch, diag::note_exits_objc_catch, AC->getAtCatchLoc()));"}}

[j]={{N,295,"/// BuildScopeInformation - The statements from CI to CE are known to form a\n/// coherent VLA scope with a specified parent node.  Walk through the\n/// statements, adding any labels or gotos to LabelAndGotoScopes and recursively\n/// walking the AST as needed.\nvoid JumpScopeChecker::BuildScopeInformation(Stmt *S, unsigned &origParentScope) {\n  case Stmt::ObjCForCollectionStmtClass: {\n    unsigned Diag = diag::note_protected_by_objc_fast_enumeration;"}}

[j]={{N,464,"/// BuildScopeInformation - The statements from CI to CE are known to form a\n/// coherent VLA scope with a specified parent node.  Walk through the\n/// statements, adding any labels or gotos to LabelAndGotoScopes and recursively\n/// walking the AST as needed.\nvoid JumpScopeChecker::BuildScopeInformation(Stmt *S, unsigned &origParentScope) {\n  case Stmt::ObjCAtTryStmtClass: {\n    // Jump from the finally to the try or catch is not valid.\n    if (ObjCAtFinallyStmt *AF = AT->getFinallyStmt()) {\n      Scopes.push_back(GotoScope(ParentScope, diag::note_protected_by_objc_finally, diag::note_exits_objc_finally, AF->getAtFinallyLoc()));"}}

[j]={{N,153,"/// GetDiagForGotoScopeDecl - If this decl induces a new goto scope, return a\n/// diagnostic that should be emitted if control goes over it. If not, return 0.\nstatic ScopePair GetDiagForGotoScopeDecl(Sema &S, const Decl *D) {\n  if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {\n    if (VD->hasLocalStorage()) {\n      case QualType::DK_objc_strong_lifetime:\n        return ScopePair(diag::note_protected_by_objc_strong_init, diag::note_exits_objc_strong);"}}

[j]={{N,482,"/// BuildScopeInformation - The statements from CI to CE are known to form a\n/// coherent VLA scope with a specified parent node.  Walk through the\n/// statements, adding any labels or gotos to LabelAndGotoScopes and recursively\n/// walking the AST as needed.\nvoid JumpScopeChecker::BuildScopeInformation(Stmt *S, unsigned &origParentScope) {\n  case Stmt::ObjCAtSynchronizedStmtClass: {\n    Scopes.push_back(GotoScope(ParentScope, diag::note_protected_by_objc_synchronized, diag::note_exits_objc_synchronized, AS->getAtSynchronizedLoc()));"}}

[j]={{N,448,"/// BuildScopeInformation - The statements from CI to CE are known to form a\n/// coherent VLA scope with a specified parent node.  Walk through the\n/// statements, adding any labels or gotos to LabelAndGotoScopes and recursively\n/// walking the AST as needed.\nvoid JumpScopeChecker::BuildScopeInformation(Stmt *S, unsigned &origParentScope) {\n  case Stmt::ObjCAtTryStmtClass: {\n    // Recursively walk the AST for the @try part.\n    {\n      Scopes.push_back(GotoScope(ParentScope, diag::note_protected_by_objc_try, diag::note_exits_objc_try, AT->getAtTryLoc()));"}}

[j]={{N,156,"/// GetDiagForGotoScopeDecl - If this decl induces a new goto scope, return a\n/// diagnostic that should be emitted if control goes over it. If not, return 0.\nstatic ScopePair GetDiagForGotoScopeDecl(Sema &S, const Decl *D) {\n  if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {\n    if (VD->hasLocalStorage()) {\n      case QualType::DK_objc_weak_lifetime:\n        return ScopePair(diag::note_protected_by_objc_weak_init, diag::note_exits_objc_weak);"}}

[j]={{N,405,"/// BuildScopeInformation - The statements from CI to CE are known to form a\n/// coherent VLA scope with a specified parent node.  Walk through the\n/// statements, adding any labels or gotos to LabelAndGotoScopes and recursively\n/// walking the AST as needed.\nvoid JumpScopeChecker::BuildScopeInformation(Stmt *S, unsigned &origParentScope) {\n  case Stmt::SEHTryStmtClass: {\n    // Jump from __except or __finally into the __try are not allowed either.\n    if (SEHExceptStmt *Except = TS->getExceptHandler()) {\n      Scopes.push_back(GotoScope(ParentScope, diag::note_protected_by_seh_except, diag::note_exits_seh_except, Except->getSourceRange().getBegin()));"}}

[j]={{N,409,"/// BuildScopeInformation - The statements from CI to CE are known to form a\n/// coherent VLA scope with a specified parent node.  Walk through the\n/// statements, adding any labels or gotos to LabelAndGotoScopes and recursively\n/// walking the AST as needed.\nvoid JumpScopeChecker::BuildScopeInformation(Stmt *S, unsigned &origParentScope) {\n  case Stmt::SEHTryStmtClass: {\n    // Jump from __except or __finally into the __try are not allowed either.\n    if (SEHExceptStmt *Except = TS->getExceptHandler()) {\n    } else if (SEHFinallyStmt *Finally = TS->getFinallyHandler()) {\n      Scopes.push_back(GotoScope(ParentScope, diag::note_protected_by_seh_finally, diag::note_exits_seh_finally, Finally->getSourceRange().getBegin()));"},{N,854,"/// CheckJump - Validate that the specified jump statement is valid: that it is\n/// jumping within or out of its current scope, not into a deeper one.\nvoid JumpScopeChecker::CheckJump(Stmt *From, Stmt *To, SourceLocation DiagLoc, unsigned JumpDiagError, unsigned JumpDiagWarning, unsigned JumpDiagCXX98Compat) {\n  // Warn on gotos out of __finally blocks.\n  if (isa<GotoStmt>(From) || isa<IndirectGotoStmt>(From)) {\n    // If FromScope > ToScope, FromScope is more nested and the jump goes to a\n    // less nested scope.  Check if it crosses a __finally along the way.\n    for (unsigned I = FromScope; I > ToScope; I = Scopes[I].ParentScope) {\n      if (Scopes[I].InDiag == diag::note_protected_by_seh_finally) {"}}

[j]={{N,397,"/// BuildScopeInformation - The statements from CI to CE are known to form a\n/// coherent VLA scope with a specified parent node.  Walk through the\n/// statements, adding any labels or gotos to LabelAndGotoScopes and recursively\n/// walking the AST as needed.\nvoid JumpScopeChecker::BuildScopeInformation(Stmt *S, unsigned &origParentScope) {\n  case Stmt::SEHTryStmtClass: {\n    {\n      Scopes.push_back(GotoScope(ParentScope, diag::note_protected_by_seh_try, diag::note_exits_seh_try, TS->getSourceRange().getBegin()));"}}

[j]={{N,186,"/// GetDiagForGotoScopeDecl - If this decl induces a new goto scope, return a\n/// diagnostic that should be emitted if control goes over it. If not, return 0.\nstatic ScopePair GetDiagForGotoScopeDecl(Sema &S, const Decl *D) {\n  if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {\n    if (S.Context.getLangOpts().CPlusPlus && VD->hasLocalStorage() && Init) {\n      InDiag = diag::note_protected_by_variable_init;"},{N,774,"static bool IsMicrosoftJumpWarning(unsigned JumpDiag, unsigned InDiagNote) { return (JumpDiag == diag::err_goto_into_protected_scope && (InDiagNote == diag::note_protected_by_variable_init || InDiagNote == diag::note_protected_by_variable_nontriv_destructor)); }"}}

[j]={{N,197,"/// GetDiagForGotoScopeDecl - If this decl induces a new goto scope, return a\n/// diagnostic that should be emitted if control goes over it. If not, return 0.\nstatic ScopePair GetDiagForGotoScopeDecl(Sema &S, const Decl *D) {\n  if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {\n    if (S.Context.getLangOpts().CPlusPlus && VD->hasLocalStorage() && Init) {\n      // For a variable of (array of) class type declared without an\n      // initializer, we will have call-style initialization and the initializer\n      // will be the CXXConstructExpr with no intervening nodes.\n      if (const CXXConstructExpr *CCE = dyn_cast<CXXConstructExpr>(Init)) {\n        if (Ctor->isTrivial() && Ctor->isDefaultConstructor() && VD->getInitStyle() == VarDecl::CallInit) {\n          if (OutDiag)\n          else if (!Ctor->getParent()->isPOD())\n            InDiag = diag::note_protected_by_variable_non_pod;"},{N,778,"static bool IsCXX98CompatWarning(Sema &S, unsigned InDiagNote) { return S.getLangOpts().CPlusPlus11 && InDiagNote == diag::note_protected_by_variable_non_pod; }"}}

[j]={{N,195,"/// GetDiagForGotoScopeDecl - If this decl induces a new goto scope, return a\n/// diagnostic that should be emitted if control goes over it. If not, return 0.\nstatic ScopePair GetDiagForGotoScopeDecl(Sema &S, const Decl *D) {\n  if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {\n    if (S.Context.getLangOpts().CPlusPlus && VD->hasLocalStorage() && Init) {\n      // For a variable of (array of) class type declared without an\n      // initializer, we will have call-style initialization and the initializer\n      // will be the CXXConstructExpr with no intervening nodes.\n      if (const CXXConstructExpr *CCE = dyn_cast<CXXConstructExpr>(Init)) {\n        if (Ctor->isTrivial() && Ctor->isDefaultConstructor() && VD->getInitStyle() == VarDecl::CallInit) {\n          if (OutDiag)\n            InDiag = diag::note_protected_by_variable_nontriv_destructor;"},{N,774,"static bool IsMicrosoftJumpWarning(unsigned JumpDiag, unsigned InDiagNote) { return (JumpDiag == diag::err_goto_into_protected_scope && (InDiagNote == diag::note_protected_by_variable_init || InDiagNote == diag::note_protected_by_variable_nontriv_destructor)); }"}}

[j]={{N,142,"/// GetDiagForGotoScopeDecl - If this decl induces a new goto scope, return a\n/// diagnostic that should be emitted if control goes over it. If not, return 0.\nstatic ScopePair GetDiagForGotoScopeDecl(Sema &S, const Decl *D) {\n  if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {\n    if (VD->getType()->isVariablyModifiedType())\n      InDiag = diag::note_protected_by_vla;"}}

[j]={{N,209,"/// GetDiagForGotoScopeDecl - If this decl induces a new goto scope, return a\n/// diagnostic that should be emitted if control goes over it. If not, return 0.\nstatic ScopePair GetDiagForGotoScopeDecl(Sema &S, const Decl *D) {\n  if (const TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D)) {\n    if (TD->getUnderlyingType()->isVariablyModifiedType())\n      return ScopePair(isa<TypedefDecl>(TD) ? diag::note_protected_by_vla_typedef : diag::note_protected_by_vla_type_alias, 0);"}}

[j]={{N,209,"/// GetDiagForGotoScopeDecl - If this decl induces a new goto scope, return a\n/// diagnostic that should be emitted if control goes over it. If not, return 0.\nstatic ScopePair GetDiagForGotoScopeDecl(Sema &S, const Decl *D) {\n  if (const TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D)) {\n    if (TD->getUnderlyingType()->isVariablyModifiedType())\n      return ScopePair(isa<TypedefDecl>(TD) ? diag::note_protected_by_vla_typedef : diag::note_protected_by_vla_type_alias, 0);"}}