Author: Florian Mayer Date: 2024-09-13T15:01:33-07:00 New Revision: e1bd9740faa62c11cc785a7b70ec1ad17e286bd1
URL: https://github.com/llvm/llvm-project/commit/e1bd9740faa62c11cc785a7b70ec1ad17e286bd1 DIFF: https://github.com/llvm/llvm-project/commit/e1bd9740faa62c11cc785a7b70ec1ad17e286bd1.diff LOG: Revert "Reapply "[clang] Extend diagnose_if to accept more detailed warning information (#70976)" (#108453)" This reverts commit e7f782e7481cea23ef452a75607d3d61f5bd0d22. This had UBSan failures: [----------] 1 test from ConfigCompileTests [ RUN ] ConfigCompileTests.DiagnosticSuppression Config fragment: compiling <unknown>:0 -> 0x00007B8366E2F7D8 (trusted=false) /usr/local/google/home/fmayer/large/llvm-project/llvm/include/llvm/ADT/IntrusiveRefCntPtr.h:203:33: runtime error: reference binding to null pointer of type 'clang::DiagnosticIDs' UndefinedBehaviorSanitizer: undefined-behavior /usr/local/google/home/fmayer/large/llvm-project/llvm/include/llvm/ADT/IntrusiveRefCntPtr.h:203:33 Pull Request: https://github.com/llvm/llvm-project/pull/108645 Added: Modified: clang-tools-extra/clangd/Diagnostics.cpp clang-tools-extra/clangd/Diagnostics.h clang-tools-extra/clangd/ParsedAST.cpp clang-tools-extra/clangd/Preamble.cpp clang-tools-extra/clangd/unittests/ConfigCompileTests.cpp clang/include/clang/Basic/Attr.td clang/include/clang/Basic/Diagnostic.h clang/include/clang/Basic/DiagnosticCategories.h clang/include/clang/Basic/DiagnosticIDs.h clang/include/clang/Basic/DiagnosticSemaKinds.td clang/lib/Basic/Diagnostic.cpp clang/lib/Basic/DiagnosticIDs.cpp clang/lib/Frontend/LogDiagnosticPrinter.cpp clang/lib/Frontend/SerializedDiagnosticPrinter.cpp clang/lib/Frontend/TextDiagnosticPrinter.cpp clang/lib/Sema/Sema.cpp clang/lib/Sema/SemaCUDA.cpp clang/lib/Sema/SemaDeclAttr.cpp clang/lib/Sema/SemaOverload.cpp clang/lib/Sema/SemaTemplateInstantiateDecl.cpp clang/lib/Serialization/ASTReader.cpp clang/lib/Serialization/ASTWriter.cpp clang/lib/StaticAnalyzer/Core/TextDiagnostics.cpp clang/test/Sema/diagnose_if.c clang/tools/diagtool/ListWarnings.cpp clang/tools/diagtool/ShowEnabledWarnings.cpp clang/tools/libclang/CXStoredDiagnostic.cpp flang/lib/Frontend/TextDiagnosticPrinter.cpp Removed: clang/test/SemaCXX/diagnose_if-warning-group.cpp ################################################################################ diff --git a/clang-tools-extra/clangd/Diagnostics.cpp b/clang-tools-extra/clangd/Diagnostics.cpp index 552dd36b6900bf..d5eca083eb6512 100644 --- a/clang-tools-extra/clangd/Diagnostics.cpp +++ b/clang-tools-extra/clangd/Diagnostics.cpp @@ -579,17 +579,7 @@ std::vector<Diag> StoreDiags::take(const clang::tidy::ClangTidyContext *Tidy) { for (auto &Diag : Output) { if (const char *ClangDiag = getDiagnosticCode(Diag.ID)) { // Warnings controlled by -Wfoo are better recognized by that name. - const StringRef Warning = [&] { - if (OrigSrcMgr) { - return OrigSrcMgr->getDiagnostics() - .getDiagnosticIDs() - ->getWarningOptionForDiag(Diag.ID); - } - if (!DiagnosticIDs::IsCustomDiag(Diag.ID)) - return DiagnosticIDs{}.getWarningOptionForDiag(Diag.ID); - return StringRef{}; - }(); - + StringRef Warning = DiagnosticIDs::getWarningOptionForDiag(Diag.ID); if (!Warning.empty()) { Diag.Name = ("-W" + Warning).str(); } else { @@ -906,23 +896,20 @@ void StoreDiags::flushLastDiag() { Output.push_back(std::move(*LastDiag)); } -bool isDiagnosticSuppressed(const clang::Diagnostic &Diag, - const llvm::StringSet<> &Suppress, - const LangOptions &LangOpts) { +bool isBuiltinDiagnosticSuppressed(unsigned ID, + const llvm::StringSet<> &Suppress, + const LangOptions &LangOpts) { // Don't complain about header-only stuff in mainfiles if it's a header. // FIXME: would be cleaner to suppress in clang, once we decide whether the // behavior should be to silently-ignore or respect the pragma. - if (Diag.getID() == diag::pp_pragma_sysheader_in_main_file && - LangOpts.IsHeaderFile) + if (ID == diag::pp_pragma_sysheader_in_main_file && LangOpts.IsHeaderFile) return true; - if (const char *CodePtr = getDiagnosticCode(Diag.getID())) { + if (const char *CodePtr = getDiagnosticCode(ID)) { if (Suppress.contains(normalizeSuppressedCode(CodePtr))) return true; } - StringRef Warning = - Diag.getDiags()->getDiagnosticIDs()->getWarningOptionForDiag( - Diag.getID()); + StringRef Warning = DiagnosticIDs::getWarningOptionForDiag(ID); if (!Warning.empty() && Suppress.contains(Warning)) return true; return false; diff --git a/clang-tools-extra/clangd/Diagnostics.h b/clang-tools-extra/clangd/Diagnostics.h index c45d8dc3aa6ce6..d4c0478c63a5cf 100644 --- a/clang-tools-extra/clangd/Diagnostics.h +++ b/clang-tools-extra/clangd/Diagnostics.h @@ -181,11 +181,11 @@ class StoreDiags : public DiagnosticConsumer { }; /// Determine whether a (non-clang-tidy) diagnostic is suppressed by config. -bool isDiagnosticSuppressed(const clang::Diagnostic &Diag, - const llvm::StringSet<> &Suppressed, - const LangOptions &); +bool isBuiltinDiagnosticSuppressed(unsigned ID, + const llvm::StringSet<> &Suppressed, + const LangOptions &); /// Take a user-specified diagnostic code, and convert it to a normalized form -/// stored in the config and consumed by isDiagnosticsSuppressed. +/// stored in the config and consumed by isBuiltinDiagnosticsSuppressed. /// /// (This strips err_ and -W prefix so we can match with or without them.) llvm::StringRef normalizeSuppressedCode(llvm::StringRef); diff --git a/clang-tools-extra/clangd/ParsedAST.cpp b/clang-tools-extra/clangd/ParsedAST.cpp index 4491be9aa0362b..a8b6cc8dd0a46f 100644 --- a/clang-tools-extra/clangd/ParsedAST.cpp +++ b/clang-tools-extra/clangd/ParsedAST.cpp @@ -340,7 +340,7 @@ void applyWarningOptions(llvm::ArrayRef<std::string> ExtraArgs, if (Enable) { if (Diags.getDiagnosticLevel(ID, SourceLocation()) < DiagnosticsEngine::Warning) { - auto Group = Diags.getDiagnosticIDs()->getGroupForDiag(ID); + auto Group = DiagnosticIDs::getGroupForDiag(ID); if (!Group || !EnabledGroups(*Group)) continue; Diags.setSeverity(ID, diag::Severity::Warning, SourceLocation()); @@ -583,8 +583,8 @@ ParsedAST::build(llvm::StringRef Filename, const ParseInputs &Inputs, ASTDiags.setLevelAdjuster([&](DiagnosticsEngine::Level DiagLevel, const clang::Diagnostic &Info) { if (Cfg.Diagnostics.SuppressAll || - isDiagnosticSuppressed(Info, Cfg.Diagnostics.Suppress, - Clang->getLangOpts())) + isBuiltinDiagnosticSuppressed(Info.getID(), Cfg.Diagnostics.Suppress, + Clang->getLangOpts())) return DiagnosticsEngine::Ignored; auto It = OverriddenSeverity.find(Info.getID()); diff --git a/clang-tools-extra/clangd/Preamble.cpp b/clang-tools-extra/clangd/Preamble.cpp index 84e8fec342829c..dd13b1a9e5613d 100644 --- a/clang-tools-extra/clangd/Preamble.cpp +++ b/clang-tools-extra/clangd/Preamble.cpp @@ -621,8 +621,8 @@ buildPreamble(PathRef FileName, CompilerInvocation CI, PreambleDiagnostics.setLevelAdjuster([&](DiagnosticsEngine::Level DiagLevel, const clang::Diagnostic &Info) { if (Cfg.Diagnostics.SuppressAll || - isDiagnosticSuppressed(Info, Cfg.Diagnostics.Suppress, - CI.getLangOpts())) + isBuiltinDiagnosticSuppressed(Info.getID(), Cfg.Diagnostics.Suppress, + CI.getLangOpts())) return DiagnosticsEngine::Ignored; switch (Info.getID()) { case diag::warn_no_newline_eof: diff --git a/clang-tools-extra/clangd/unittests/ConfigCompileTests.cpp b/clang-tools-extra/clangd/unittests/ConfigCompileTests.cpp index a812bac0338aa7..4ecfdf0184ab40 100644 --- a/clang-tools-extra/clangd/unittests/ConfigCompileTests.cpp +++ b/clang-tools-extra/clangd/unittests/ConfigCompileTests.cpp @@ -298,41 +298,20 @@ TEST_F(ConfigCompileTests, DiagnosticSuppression) { "unreachable-code", "unused-variable", "typecheck_bool_condition", "unexpected_friend", "warn_alloca")); - clang::DiagnosticsEngine DiagEngine(nullptr, nullptr, - new clang::IgnoringDiagConsumer); - - using Diag = clang::Diagnostic; - { - auto D = DiagEngine.Report(diag::warn_unreachable); - EXPECT_TRUE(isDiagnosticSuppressed( - Diag{&DiagEngine}, Conf.Diagnostics.Suppress, LangOptions())); - } + EXPECT_TRUE(isBuiltinDiagnosticSuppressed( + diag::warn_unreachable, Conf.Diagnostics.Suppress, LangOptions())); // Subcategory not respected/suppressed. - { - auto D = DiagEngine.Report(diag::warn_unreachable_break); - EXPECT_FALSE(isDiagnosticSuppressed( - Diag{&DiagEngine}, Conf.Diagnostics.Suppress, LangOptions())); - } - { - auto D = DiagEngine.Report(diag::warn_unused_variable); - EXPECT_TRUE(isDiagnosticSuppressed( - Diag{&DiagEngine}, Conf.Diagnostics.Suppress, LangOptions())); - } - { - auto D = DiagEngine.Report(diag::err_typecheck_bool_condition); - EXPECT_TRUE(isDiagnosticSuppressed( - Diag{&DiagEngine}, Conf.Diagnostics.Suppress, LangOptions())); - } - { - auto D = DiagEngine.Report(diag::err_unexpected_friend); - EXPECT_TRUE(isDiagnosticSuppressed( - Diag{&DiagEngine}, Conf.Diagnostics.Suppress, LangOptions())); - } - { - auto D = DiagEngine.Report(diag::warn_alloca); - EXPECT_TRUE(isDiagnosticSuppressed( - Diag{&DiagEngine}, Conf.Diagnostics.Suppress, LangOptions())); - } + EXPECT_FALSE(isBuiltinDiagnosticSuppressed( + diag::warn_unreachable_break, Conf.Diagnostics.Suppress, LangOptions())); + EXPECT_TRUE(isBuiltinDiagnosticSuppressed( + diag::warn_unused_variable, Conf.Diagnostics.Suppress, LangOptions())); + EXPECT_TRUE(isBuiltinDiagnosticSuppressed(diag::err_typecheck_bool_condition, + Conf.Diagnostics.Suppress, + LangOptions())); + EXPECT_TRUE(isBuiltinDiagnosticSuppressed( + diag::err_unexpected_friend, Conf.Diagnostics.Suppress, LangOptions())); + EXPECT_TRUE(isBuiltinDiagnosticSuppressed( + diag::warn_alloca, Conf.Diagnostics.Suppress, LangOptions())); Frag.Diagnostics.Suppress.emplace_back("*"); EXPECT_TRUE(compileAndApply()); diff --git a/clang/include/clang/Basic/Attr.td b/clang/include/clang/Basic/Attr.td index 70fad60d4edbb5..9a7b163b2c6da8 100644 --- a/clang/include/clang/Basic/Attr.td +++ b/clang/include/clang/Basic/Attr.td @@ -3358,16 +3358,18 @@ def DiagnoseIf : InheritableAttr { let Spellings = [GNU<"diagnose_if">]; let Subjects = SubjectList<[Function, ObjCMethod, ObjCProperty]>; let Args = [ExprArgument<"Cond">, StringArgument<"Message">, - EnumArgument<"DefaultSeverity", - "DefaultSeverity", + EnumArgument<"DiagnosticType", "DiagnosticType", /*is_string=*/true, - ["error", "warning"], - ["DS_error", "DS_warning"]>, - StringArgument<"WarningGroup", /*optional*/ 1>, + ["error", "warning"], + ["DT_Error", "DT_Warning"]>, BoolArgument<"ArgDependent", 0, /*fake*/ 1>, DeclArgument<Named, "Parent", 0, /*fake*/ 1>]; let InheritEvenIfAlreadyPresent = 1; let LateParsed = LateAttrParseStandard; + let AdditionalMembers = [{ + bool isError() const { return diagnosticType == DT_Error; } + bool isWarning() const { return diagnosticType == DT_Warning; } + }]; let TemplateDependent = 1; let Documentation = [DiagnoseIfDocs]; } diff --git a/clang/include/clang/Basic/Diagnostic.h b/clang/include/clang/Basic/Diagnostic.h index 54b69e98540239..0c7836c2ea569c 100644 --- a/clang/include/clang/Basic/Diagnostic.h +++ b/clang/include/clang/Basic/Diagnostic.h @@ -336,12 +336,10 @@ class DiagnosticsEngine : public RefCountedBase<DiagnosticsEngine> { // Map extensions to warnings or errors? diag::Severity ExtBehavior = diag::Severity::Ignored; - DiagnosticIDs &DiagIDs; - - DiagState(DiagnosticIDs &DiagIDs) + DiagState() : IgnoreAllWarnings(false), EnableAllWarnings(false), WarningsAsErrors(false), ErrorsAsFatal(false), - SuppressSystemWarnings(false), DiagIDs(DiagIDs) {} + SuppressSystemWarnings(false) {} using iterator = llvm::DenseMap<unsigned, DiagnosticMapping>::iterator; using const_iterator = @@ -872,8 +870,6 @@ class DiagnosticsEngine : public RefCountedBase<DiagnosticsEngine> { /// \param FormatString A fixed diagnostic format string that will be hashed /// and mapped to a unique DiagID. template <unsigned N> - // TODO: Deprecate this once all uses are removed from LLVM - // [[deprecated("Use a CustomDiagDesc instead of a Level")]] unsigned getCustomDiagID(Level L, const char (&FormatString)[N]) { return Diags->getCustomDiagID((DiagnosticIDs::Level)L, StringRef(FormatString, N - 1)); diff --git a/clang/include/clang/Basic/DiagnosticCategories.h b/clang/include/clang/Basic/DiagnosticCategories.h index 839f8dee3ca89f..14be326f7515f8 100644 --- a/clang/include/clang/Basic/DiagnosticCategories.h +++ b/clang/include/clang/Basic/DiagnosticCategories.h @@ -21,12 +21,11 @@ namespace clang { }; enum class Group { -#define DIAG_ENTRY(GroupName, FlagNameOffset, Members, SubGroups, Docs) \ - GroupName, +#define DIAG_ENTRY(GroupName, FlagNameOffset, Members, SubGroups, Docs) \ + GroupName, #include "clang/Basic/DiagnosticGroups.inc" #undef CATEGORY #undef DIAG_ENTRY - NUM_GROUPS }; } // end namespace diag } // end namespace clang diff --git a/clang/include/clang/Basic/DiagnosticIDs.h b/clang/include/clang/Basic/DiagnosticIDs.h index 2402996ece5c94..8b976bdac6dc51 100644 --- a/clang/include/clang/Basic/DiagnosticIDs.h +++ b/clang/include/clang/Basic/DiagnosticIDs.h @@ -14,7 +14,6 @@ #ifndef LLVM_CLANG_BASIC_DIAGNOSTICIDS_H #define LLVM_CLANG_BASIC_DIAGNOSTICIDS_H -#include "clang/Basic/DiagnosticCategories.h" #include "clang/Basic/LLVM.h" #include "llvm/ADT/IntrusiveRefCntPtr.h" #include "llvm/ADT/StringRef.h" @@ -83,7 +82,7 @@ namespace clang { /// to either Ignore (nothing), Remark (emit a remark), Warning /// (emit a warning) or Error (emit as an error). It allows clients to /// map ERRORs to Error or Fatal (stop emitting diagnostics after this one). - enum class Severity : uint8_t { + enum class Severity { // NOTE: 0 means "uncomputed". Ignored = 1, ///< Do not present this diagnostic, ignore it. Remark = 2, ///< Present this diagnostic as a remark. @@ -180,96 +179,13 @@ class DiagnosticMapping { class DiagnosticIDs : public RefCountedBase<DiagnosticIDs> { public: /// The level of the diagnostic, after it has been through mapping. - enum Level : uint8_t { Ignored, Note, Remark, Warning, Error, Fatal }; - - // Diagnostic classes. - enum Class { - CLASS_INVALID = 0x00, - CLASS_NOTE = 0x01, - CLASS_REMARK = 0x02, - CLASS_WARNING = 0x03, - CLASS_EXTENSION = 0x04, - CLASS_ERROR = 0x05 - }; - - static bool IsCustomDiag(diag::kind Diag) { - return Diag >= diag::DIAG_UPPER_LIMIT; - } - - class CustomDiagDesc { - LLVM_PREFERRED_TYPE(diag::Severity) - unsigned DefaultSeverity : 3; - LLVM_PREFERRED_TYPE(Class) - unsigned DiagClass : 3; - LLVM_PREFERRED_TYPE(bool) - unsigned ShowInSystemHeader : 1; - LLVM_PREFERRED_TYPE(bool) - unsigned ShowInSystemMacro : 1; - LLVM_PREFERRED_TYPE(bool) - unsigned HasGroup : 1; - diag::Group Group; - std::string Description; - - auto get_as_tuple() const { - return std::tuple(DefaultSeverity, DiagClass, ShowInSystemHeader, - ShowInSystemMacro, HasGroup, Group, - std::string_view{Description}); - } - - public: - CustomDiagDesc(diag::Severity DefaultSeverity, std::string Description, - unsigned Class = CLASS_WARNING, - bool ShowInSystemHeader = false, - bool ShowInSystemMacro = false, - std::optional<diag::Group> Group = std::nullopt) - : DefaultSeverity(static_cast<unsigned>(DefaultSeverity)), - DiagClass(Class), ShowInSystemHeader(ShowInSystemHeader), - ShowInSystemMacro(ShowInSystemMacro), HasGroup(Group != std::nullopt), - Group(Group.value_or(diag::Group{})), - Description(std::move(Description)) {} - - std::optional<diag::Group> GetGroup() const { - if (HasGroup) - return Group; - return std::nullopt; - } - - diag::Severity GetDefaultSeverity() const { - return static_cast<diag::Severity>(DefaultSeverity); - } - - Class GetClass() const { return static_cast<Class>(DiagClass); } - std::string_view GetDescription() const { return Description; } - bool ShouldShowInSystemHeader() const { return ShowInSystemHeader; } - - friend bool operator==(const CustomDiagDesc &lhs, - const CustomDiagDesc &rhs) { - return lhs.get_as_tuple() == rhs.get_as_tuple(); - } - - friend bool operator<(const CustomDiagDesc &lhs, - const CustomDiagDesc &rhs) { - return lhs.get_as_tuple() < rhs.get_as_tuple(); - } - }; - - struct GroupInfo { - LLVM_PREFERRED_TYPE(diag::Severity) - unsigned Severity : 3; - LLVM_PREFERRED_TYPE(bool) - unsigned HasNoWarningAsError : 1; + enum Level { + Ignored, Note, Remark, Warning, Error, Fatal }; private: /// Information for uniquing and looking up custom diags. std::unique_ptr<diag::CustomDiagInfo> CustomDiagInfo; - std::unique_ptr<GroupInfo[]> GroupInfos = []() { - auto GIs = std::make_unique<GroupInfo[]>( - static_cast<size_t>(diag::Group::NUM_GROUPS)); - for (size_t i = 0; i != static_cast<size_t>(diag::Group::NUM_GROUPS); ++i) - GIs[i] = {{}, false}; - return GIs; - }(); public: DiagnosticIDs(); @@ -284,34 +200,7 @@ class DiagnosticIDs : public RefCountedBase<DiagnosticIDs> { // FIXME: Replace this function with a create-only facilty like // createCustomDiagIDFromFormatString() to enforce safe usage. At the time of // writing, nearly all callers of this function were invalid. - unsigned getCustomDiagID(CustomDiagDesc Diag); - - // TODO: Deprecate this once all uses are removed from LLVM - // [[deprecated("Use a CustomDiagDesc instead of a Level")]] - unsigned getCustomDiagID(Level Level, StringRef Message) { - return getCustomDiagID([&]() -> CustomDiagDesc { - switch (Level) { - case DiagnosticIDs::Level::Ignored: - return {diag::Severity::Ignored, std::string(Message), CLASS_WARNING, - /*ShowInSystemHeader*/ true}; - case DiagnosticIDs::Level::Note: - return {diag::Severity::Fatal, std::string(Message), CLASS_NOTE, - /*ShowInSystemHeader*/ true}; - case DiagnosticIDs::Level::Remark: - return {diag::Severity::Remark, std::string(Message), CLASS_REMARK, - /*ShowInSystemHeader*/ true}; - case DiagnosticIDs::Level::Warning: - return {diag::Severity::Warning, std::string(Message), CLASS_WARNING, - /*ShowInSystemHeader*/ true}; - case DiagnosticIDs::Level::Error: - return {diag::Severity::Error, std::string(Message), CLASS_ERROR, - /*ShowInSystemHeader*/ true}; - case DiagnosticIDs::Level::Fatal: - return {diag::Severity::Fatal, std::string(Message), CLASS_ERROR, - /*ShowInSystemHeader*/ true}; - } - }()); - } + unsigned getCustomDiagID(Level L, StringRef FormatString); //===--------------------------------------------------------------------===// // Diagnostic classification and reporting interfaces. @@ -323,36 +212,35 @@ class DiagnosticIDs : public RefCountedBase<DiagnosticIDs> { /// Return true if the unmapped diagnostic levelof the specified /// diagnostic ID is a Warning or Extension. /// - /// This is not legal to call on NOTEs. - bool isWarningOrExtension(unsigned DiagID) const; + /// This only works on builtin diagnostics, not custom ones, and is not + /// legal to call on NOTEs. + static bool isBuiltinWarningOrExtension(unsigned DiagID); /// Return true if the specified diagnostic is mapped to errors by /// default. - bool isDefaultMappingAsError(unsigned DiagID) const; + static bool isDefaultMappingAsError(unsigned DiagID); /// Get the default mapping for this diagnostic. - DiagnosticMapping getDefaultMapping(unsigned DiagID) const; - - void initCustomDiagMapping(DiagnosticMapping &, unsigned DiagID); + static DiagnosticMapping getDefaultMapping(unsigned DiagID); - /// Determine whether the given diagnostic ID is a Note. - bool isNote(unsigned DiagID) const; + /// Determine whether the given built-in diagnostic ID is a Note. + static bool isBuiltinNote(unsigned DiagID); - /// Determine whether the given diagnostic ID is for an + /// Determine whether the given built-in diagnostic ID is for an /// extension of some sort. - bool isExtensionDiag(unsigned DiagID) const { + static bool isBuiltinExtensionDiag(unsigned DiagID) { bool ignored; - return isExtensionDiag(DiagID, ignored); + return isBuiltinExtensionDiag(DiagID, ignored); } - /// Determine whether the given diagnostic ID is for an + /// Determine whether the given built-in diagnostic ID is for an /// extension of some sort, and whether it is enabled by default. /// /// This also returns EnabledByDefault, which is set to indicate whether the /// diagnostic is ignored by default (in which case -pedantic enables it) or /// treated as a warning/error by default. /// - bool isExtensionDiag(unsigned DiagID, bool &EnabledByDefault) const; + static bool isBuiltinExtensionDiag(unsigned DiagID, bool &EnabledByDefault); /// Given a group ID, returns the flag that toggles the group. /// For example, for Group::DeprecatedDeclarations, returns @@ -362,22 +250,19 @@ class DiagnosticIDs : public RefCountedBase<DiagnosticIDs> { /// Given a diagnostic group ID, return its documentation. static StringRef getWarningOptionDocumentation(diag::Group GroupID); - void setGroupSeverity(StringRef Group, diag::Severity); - void setGroupNoWarningsAsError(StringRef Group, bool); - /// Given a group ID, returns the flag that toggles the group. /// For example, for "deprecated-declarations", returns /// Group::DeprecatedDeclarations. static std::optional<diag::Group> getGroupForWarningOption(StringRef); /// Return the lowest-level group that contains the specified diagnostic. - std::optional<diag::Group> getGroupForDiag(unsigned DiagID) const; + static std::optional<diag::Group> getGroupForDiag(unsigned DiagID); /// Return the lowest-level warning option that enables the specified /// diagnostic. /// /// If there is no -Wfoo flag that controls the diagnostic, this returns null. - StringRef getWarningOptionForDiag(unsigned DiagID); + static StringRef getWarningOptionForDiag(unsigned DiagID); /// Return the category number that a specified \p DiagID belongs to, /// or 0 if no category. @@ -478,8 +363,6 @@ class DiagnosticIDs : public RefCountedBase<DiagnosticIDs> { getDiagnosticSeverity(unsigned DiagID, SourceLocation Loc, const DiagnosticsEngine &Diag) const LLVM_READONLY; - Class getDiagClass(unsigned DiagID) const; - /// Used to report a diagnostic that is finally fully formed. /// /// \returns \c true if the diagnostic was emitted, \c false if it was diff --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td b/clang/include/clang/Basic/DiagnosticSemaKinds.td index bf97d939f02ce9..50f27eec0ef2c4 100644 --- a/clang/include/clang/Basic/DiagnosticSemaKinds.td +++ b/clang/include/clang/Basic/DiagnosticSemaKinds.td @@ -2929,15 +2929,9 @@ def ext_constexpr_function_never_constant_expr : ExtWarn< "constant expression">, InGroup<DiagGroup<"invalid-constexpr">>, DefaultError; def err_attr_cond_never_constant_expr : Error< "%0 attribute expression never produces a constant expression">; -def err_diagnose_if_unknown_warning : Error<"unknown warning group '%0'">; def err_diagnose_if_invalid_diagnostic_type : Error< "invalid diagnostic type for 'diagnose_if'; use \"error\" or \"warning\" " "instead">; -def err_diagnose_if_unknown_option : Error<"unknown diagnostic option">; -def err_diagnose_if_expected_equals : Error< - "expected '=' after diagnostic option">; -def err_diagnose_if_unexpected_value : Error< - "unexpected value; use 'true' or 'false'">; def err_constexpr_body_no_return : Error< "no return statement in %select{constexpr|consteval}0 function">; def err_constexpr_return_missing_expr : Error< diff --git a/clang/lib/Basic/Diagnostic.cpp b/clang/lib/Basic/Diagnostic.cpp index ecff80a5090630..66776daa5e1493 100644 --- a/clang/lib/Basic/Diagnostic.cpp +++ b/clang/lib/Basic/Diagnostic.cpp @@ -138,7 +138,7 @@ void DiagnosticsEngine::Reset(bool soft /*=false*/) { // Create a DiagState and DiagStatePoint representing diagnostic changes // through command-line. - DiagStates.emplace_back(*Diags); + DiagStates.emplace_back(); DiagStatesByLoc.appendFirst(&DiagStates.back()); } } @@ -166,11 +166,8 @@ DiagnosticsEngine::DiagState::getOrAddMapping(diag::kind Diag) { DiagMap.insert(std::make_pair(Diag, DiagnosticMapping())); // Initialize the entry if we added it. - if (Result.second) { - Result.first->second = DiagIDs.getDefaultMapping(Diag); - if (DiagnosticIDs::IsCustomDiag(Diag)) - DiagIDs.initCustomDiagMapping(Result.first->second, Diag); - } + if (Result.second) + Result.first->second = DiagnosticIDs::getDefaultMapping(Diag); return Result.first->second; } @@ -312,8 +309,7 @@ void DiagnosticsEngine::DiagStateMap::dump(SourceManager &SrcMgr, for (auto &Mapping : *Transition.State) { StringRef Option = - SrcMgr.getDiagnostics().Diags->getWarningOptionForDiag( - Mapping.first); + DiagnosticIDs::getWarningOptionForDiag(Mapping.first); if (!DiagName.empty() && DiagName != Option) continue; @@ -357,7 +353,9 @@ void DiagnosticsEngine::PushDiagStatePoint(DiagState *State, void DiagnosticsEngine::setSeverity(diag::kind Diag, diag::Severity Map, SourceLocation L) { - assert((Diags->isWarningOrExtension(Diag) || + assert(Diag < diag::DIAG_UPPER_LIMIT && + "Can only map builtin diagnostics"); + assert((Diags->isBuiltinWarningOrExtension(Diag) || (Map == diag::Severity::Fatal || Map == diag::Severity::Error)) && "Cannot map errors into warnings!"); assert((L.isInvalid() || SourceMgr) && "No SourceMgr for valid location"); @@ -409,8 +407,6 @@ bool DiagnosticsEngine::setSeverityForGroup(diag::Flavor Flavor, if (Diags->getDiagnosticsInGroup(Flavor, Group, GroupDiags)) return true; - Diags->setGroupSeverity(Group, Map); - // Set the mapping. for (diag::kind Diag : GroupDiags) setSeverity(Diag, Map, Loc); @@ -433,7 +429,6 @@ bool DiagnosticsEngine::setDiagnosticGroupWarningAsError(StringRef Group, if (Enabled) return setSeverityForGroup(diag::Flavor::WarningOrError, Group, diag::Severity::Error); - Diags->setGroupSeverity(Group, diag::Severity::Warning); // Otherwise, we want to set the diagnostic mapping's "no Werror" bit, and // potentially downgrade anything already mapped to be a warning. @@ -465,7 +460,6 @@ bool DiagnosticsEngine::setDiagnosticGroupErrorAsFatal(StringRef Group, if (Enabled) return setSeverityForGroup(diag::Flavor::WarningOrError, Group, diag::Severity::Fatal); - Diags->setGroupSeverity(Group, diag::Severity::Error); // Otherwise, we want to set the diagnostic mapping's "no Wfatal-errors" bit, // and potentially downgrade anything already mapped to be a fatal error. @@ -498,7 +492,7 @@ void DiagnosticsEngine::setSeverityForAll(diag::Flavor Flavor, // Set the mapping. for (diag::kind Diag : AllDiags) - if (Diags->isWarningOrExtension(Diag)) + if (Diags->isBuiltinWarningOrExtension(Diag)) setSeverity(Diag, Map, Loc); } diff --git a/clang/lib/Basic/DiagnosticIDs.cpp b/clang/lib/Basic/DiagnosticIDs.cpp index cae6642bd4bd3e..cd42573968b212 100644 --- a/clang/lib/Basic/DiagnosticIDs.cpp +++ b/clang/lib/Basic/DiagnosticIDs.cpp @@ -102,12 +102,13 @@ const uint32_t StaticDiagInfoDescriptionOffsets[] = { #undef DIAG }; +// Diagnostic classes. enum DiagnosticClass { - CLASS_NOTE = DiagnosticIDs::CLASS_NOTE, - CLASS_REMARK = DiagnosticIDs::CLASS_REMARK, - CLASS_WARNING = DiagnosticIDs::CLASS_WARNING, - CLASS_EXTENSION = DiagnosticIDs::CLASS_EXTENSION, - CLASS_ERROR = DiagnosticIDs::CLASS_ERROR, + CLASS_NOTE = 0x01, + CLASS_REMARK = 0x02, + CLASS_WARNING = 0x03, + CLASS_EXTENSION = 0x04, + CLASS_ERROR = 0x05 }; struct StaticDiagInfoRec { @@ -268,60 +269,11 @@ CATEGORY(INSTALLAPI, REFACTORING) return Found; } -//===----------------------------------------------------------------------===// -// Custom Diagnostic information -//===----------------------------------------------------------------------===// - -namespace clang { -namespace diag { -using CustomDiagDesc = DiagnosticIDs::CustomDiagDesc; -class CustomDiagInfo { - std::vector<CustomDiagDesc> DiagInfo; - std::map<CustomDiagDesc, unsigned> DiagIDs; - std::map<diag::Group, std::vector<unsigned>> GroupToDiags; - -public: - /// getDescription - Return the description of the specified custom - /// diagnostic. - const CustomDiagDesc &getDescription(unsigned DiagID) const { - assert(DiagID - DIAG_UPPER_LIMIT < DiagInfo.size() && - "Invalid diagnostic ID"); - return DiagInfo[DiagID - DIAG_UPPER_LIMIT]; - } - - unsigned getOrCreateDiagID(DiagnosticIDs::CustomDiagDesc D) { - // Check to see if it already exists. - std::map<CustomDiagDesc, unsigned>::iterator I = DiagIDs.lower_bound(D); - if (I != DiagIDs.end() && I->first == D) - return I->second; - - // If not, assign a new ID. - unsigned ID = DiagInfo.size() + DIAG_UPPER_LIMIT; - DiagIDs.insert(std::make_pair(D, ID)); - DiagInfo.push_back(D); - if (auto Group = D.GetGroup()) - GroupToDiags[*Group].emplace_back(ID); - return ID; - } - - ArrayRef<unsigned> getDiagsInGroup(diag::Group G) const { - if (auto Diags = GroupToDiags.find(G); Diags != GroupToDiags.end()) - return Diags->second; - return {}; - } -}; - -} // namespace diag -} // namespace clang - -DiagnosticMapping DiagnosticIDs::getDefaultMapping(unsigned DiagID) const { +DiagnosticMapping DiagnosticIDs::getDefaultMapping(unsigned DiagID) { DiagnosticMapping Info = DiagnosticMapping::Make( diag::Severity::Fatal, /*IsUser=*/false, /*IsPragma=*/false); - if (IsCustomDiag(DiagID)) { - Info.setSeverity( - CustomDiagInfo->getDescription(DiagID).GetDefaultSeverity()); - } else if (const StaticDiagInfoRec *StaticInfo = GetDiagInfo(DiagID)) { + if (const StaticDiagInfoRec *StaticInfo = GetDiagInfo(DiagID)) { Info.setSeverity((diag::Severity)StaticInfo->DefaultSeverity); if (StaticInfo->WarnNoWerror) { @@ -334,18 +286,6 @@ DiagnosticMapping DiagnosticIDs::getDefaultMapping(unsigned DiagID) const { return Info; } -void DiagnosticIDs::initCustomDiagMapping(DiagnosticMapping &Mapping, - unsigned DiagID) { - assert(IsCustomDiag(DiagID)); - const auto &Diag = CustomDiagInfo->getDescription(DiagID); - if (auto Group = Diag.GetGroup()) { - GroupInfo GroupInfo = GroupInfos[static_cast<size_t>(*Group)]; - if (static_cast<diag::Severity>(GroupInfo.Severity) != diag::Severity()) - Mapping.setSeverity(static_cast<diag::Severity>(GroupInfo.Severity)); - Mapping.setNoWarningAsError(GroupInfo.HasNoWarningAsError); - } -} - /// getCategoryNumberForDiag - Return the category number that a specified /// DiagID belongs to, or 0 if no category. unsigned DiagnosticIDs::getCategoryNumberForDiag(unsigned DiagID) { @@ -403,6 +343,61 @@ bool DiagnosticIDs::isDeferrable(unsigned DiagID) { return false; } +/// getBuiltinDiagClass - Return the class field of the diagnostic. +/// +static unsigned getBuiltinDiagClass(unsigned DiagID) { + if (const StaticDiagInfoRec *Info = GetDiagInfo(DiagID)) + return Info->Class; + return ~0U; +} + +//===----------------------------------------------------------------------===// +// Custom Diagnostic information +//===----------------------------------------------------------------------===// + +namespace clang { + namespace diag { + class CustomDiagInfo { + typedef std::pair<DiagnosticIDs::Level, std::string> DiagDesc; + std::vector<DiagDesc> DiagInfo; + std::map<DiagDesc, unsigned> DiagIDs; + public: + + /// getDescription - Return the description of the specified custom + /// diagnostic. + StringRef getDescription(unsigned DiagID) const { + assert(DiagID - DIAG_UPPER_LIMIT < DiagInfo.size() && + "Invalid diagnostic ID"); + return DiagInfo[DiagID-DIAG_UPPER_LIMIT].second; + } + + /// getLevel - Return the level of the specified custom diagnostic. + DiagnosticIDs::Level getLevel(unsigned DiagID) const { + assert(DiagID - DIAG_UPPER_LIMIT < DiagInfo.size() && + "Invalid diagnostic ID"); + return DiagInfo[DiagID-DIAG_UPPER_LIMIT].first; + } + + unsigned getOrCreateDiagID(DiagnosticIDs::Level L, StringRef Message, + DiagnosticIDs &Diags) { + DiagDesc D(L, std::string(Message)); + // Check to see if it already exists. + std::map<DiagDesc, unsigned>::iterator I = DiagIDs.lower_bound(D); + if (I != DiagIDs.end() && I->first == D) + return I->second; + + // If not, assign a new ID. + unsigned ID = DiagInfo.size()+DIAG_UPPER_LIMIT; + DiagIDs.insert(std::make_pair(D, ID)); + DiagInfo.push_back(D); + return ID; + } + }; + + } // end diag namespace +} // end clang namespace + + //===----------------------------------------------------------------------===// // Common Diagnostic implementation //===----------------------------------------------------------------------===// @@ -417,32 +412,38 @@ DiagnosticIDs::~DiagnosticIDs() {} /// /// \param FormatString A fixed diagnostic format string that will be hashed and /// mapped to a unique DiagID. -unsigned DiagnosticIDs::getCustomDiagID(CustomDiagDesc Diag) { +unsigned DiagnosticIDs::getCustomDiagID(Level L, StringRef FormatString) { if (!CustomDiagInfo) CustomDiagInfo.reset(new diag::CustomDiagInfo()); - return CustomDiagInfo->getOrCreateDiagID(Diag); + return CustomDiagInfo->getOrCreateDiagID(L, FormatString, *this); } -bool DiagnosticIDs::isWarningOrExtension(unsigned DiagID) const { - return DiagID < diag::DIAG_UPPER_LIMIT - ? getDiagClass(DiagID) != CLASS_ERROR - : CustomDiagInfo->getDescription(DiagID).GetClass() != CLASS_ERROR; + +/// isBuiltinWarningOrExtension - Return true if the unmapped diagnostic +/// level of the specified diagnostic ID is a Warning or Extension. +/// This only works on builtin diagnostics, not custom ones, and is not legal to +/// call on NOTEs. +bool DiagnosticIDs::isBuiltinWarningOrExtension(unsigned DiagID) { + return DiagID < diag::DIAG_UPPER_LIMIT && + getBuiltinDiagClass(DiagID) != CLASS_ERROR; } /// Determine whether the given built-in diagnostic ID is a /// Note. -bool DiagnosticIDs::isNote(unsigned DiagID) const { - return DiagID < diag::DIAG_UPPER_LIMIT && getDiagClass(DiagID) == CLASS_NOTE; +bool DiagnosticIDs::isBuiltinNote(unsigned DiagID) { + return DiagID < diag::DIAG_UPPER_LIMIT && + getBuiltinDiagClass(DiagID) == CLASS_NOTE; } -/// isExtensionDiag - Determine whether the given built-in diagnostic +/// isBuiltinExtensionDiag - Determine whether the given built-in diagnostic /// ID is for an extension of some sort. This also returns EnabledByDefault, /// which is set to indicate whether the diagnostic is ignored by default (in /// which case -pedantic enables it) or treated as a warning/error by default. /// -bool DiagnosticIDs::isExtensionDiag(unsigned DiagID, - bool &EnabledByDefault) const { - if (IsCustomDiag(DiagID) || getDiagClass(DiagID) != CLASS_EXTENSION) +bool DiagnosticIDs::isBuiltinExtensionDiag(unsigned DiagID, + bool &EnabledByDefault) { + if (DiagID >= diag::DIAG_UPPER_LIMIT || + getBuiltinDiagClass(DiagID) != CLASS_EXTENSION) return false; EnabledByDefault = @@ -450,7 +451,10 @@ bool DiagnosticIDs::isExtensionDiag(unsigned DiagID, return true; } -bool DiagnosticIDs::isDefaultMappingAsError(unsigned DiagID) const { +bool DiagnosticIDs::isDefaultMappingAsError(unsigned DiagID) { + if (DiagID >= diag::DIAG_UPPER_LIMIT) + return false; + return getDefaultMapping(DiagID).getSeverity() >= diag::Severity::Error; } @@ -460,7 +464,7 @@ StringRef DiagnosticIDs::getDescription(unsigned DiagID) const { if (const StaticDiagInfoRec *Info = GetDiagInfo(DiagID)) return Info->getDescription(); assert(CustomDiagInfo && "Invalid CustomDiagInfo"); - return CustomDiagInfo->getDescription(DiagID).GetDescription(); + return CustomDiagInfo->getDescription(DiagID); } static DiagnosticIDs::Level toLevel(diag::Severity SV) { @@ -485,7 +489,13 @@ static DiagnosticIDs::Level toLevel(diag::Severity SV) { DiagnosticIDs::Level DiagnosticIDs::getDiagnosticLevel(unsigned DiagID, SourceLocation Loc, const DiagnosticsEngine &Diag) const { - unsigned DiagClass = getDiagClass(DiagID); + // Handle custom diagnostics, which cannot be mapped. + if (DiagID >= diag::DIAG_UPPER_LIMIT) { + assert(CustomDiagInfo && "Invalid CustomDiagInfo"); + return CustomDiagInfo->getLevel(DiagID); + } + + unsigned DiagClass = getBuiltinDiagClass(DiagID); if (DiagClass == CLASS_NOTE) return DiagnosticIDs::Note; return toLevel(getDiagnosticSeverity(DiagID, Loc, Diag)); } @@ -499,8 +509,7 @@ DiagnosticIDs::getDiagnosticLevel(unsigned DiagID, SourceLocation Loc, diag::Severity DiagnosticIDs::getDiagnosticSeverity(unsigned DiagID, SourceLocation Loc, const DiagnosticsEngine &Diag) const { - bool IsCustomDiag = DiagnosticIDs::IsCustomDiag(DiagID); - assert(getDiagClass(DiagID) != CLASS_NOTE); + assert(getBuiltinDiagClass(DiagID) != CLASS_NOTE); // Specific non-error diagnostics may be mapped to various levels from ignored // to error. Errors can only be mapped to fatal. @@ -508,7 +517,7 @@ DiagnosticIDs::getDiagnosticSeverity(unsigned DiagID, SourceLocation Loc, // Get the mapping information, or compute it lazily. DiagnosticsEngine::DiagState *State = Diag.GetDiagStateForLoc(Loc); - DiagnosticMapping Mapping = State->getOrAddMapping((diag::kind)DiagID); + DiagnosticMapping &Mapping = State->getOrAddMapping((diag::kind)DiagID); // TODO: Can a null severity really get here? if (Mapping.getSeverity() != diag::Severity()) @@ -516,15 +525,14 @@ DiagnosticIDs::getDiagnosticSeverity(unsigned DiagID, SourceLocation Loc, // Upgrade ignored diagnostics if -Weverything is enabled. if (State->EnableAllWarnings && Result == diag::Severity::Ignored && - !Mapping.isUser() && - (IsCustomDiag || getDiagClass(DiagID) != CLASS_REMARK)) + !Mapping.isUser() && getBuiltinDiagClass(DiagID) != CLASS_REMARK) Result = diag::Severity::Warning; // Ignore -pedantic diagnostics inside __extension__ blocks. // (The diagnostics controlled by -pedantic are the extension diagnostics // that are not enabled by default.) bool EnabledByDefault = false; - bool IsExtensionDiag = isExtensionDiag(DiagID, EnabledByDefault); + bool IsExtensionDiag = isBuiltinExtensionDiag(DiagID, EnabledByDefault); if (Diag.AllExtensionsSilenced && IsExtensionDiag && !EnabledByDefault) return diag::Severity::Ignored; @@ -542,12 +550,10 @@ DiagnosticIDs::getDiagnosticSeverity(unsigned DiagID, SourceLocation Loc, // as well as disabling all messages which are currently mapped to Warning // (whether by default or downgraded from Error via e.g. -Wno-error or #pragma // diagnostic.) - // FIXME: Should -w be ignored for custom warnings without a group? if (State->IgnoreAllWarnings) { - if ((!IsCustomDiag || CustomDiagInfo->getDescription(DiagID).GetGroup()) && - (Result == diag::Severity::Warning || - (Result >= diag::Severity::Error && - !isDefaultMappingAsError((diag::kind)DiagID)))) + if (Result == diag::Severity::Warning || + (Result >= diag::Severity::Error && + !isDefaultMappingAsError((diag::kind)DiagID))) return diag::Severity::Ignored; } @@ -569,10 +575,9 @@ DiagnosticIDs::getDiagnosticSeverity(unsigned DiagID, SourceLocation Loc, Diag.CurDiagID != diag::fatal_too_many_errors && Diag.FatalsAsError) Result = diag::Severity::Error; + // Custom diagnostics always are emitted in system headers. bool ShowInSystemHeader = - IsCustomDiag - ? CustomDiagInfo->getDescription(DiagID).ShouldShowInSystemHeader() - : !GetDiagInfo(DiagID) || GetDiagInfo(DiagID)->WarnShowInSystemHeader; + !GetDiagInfo(DiagID) || GetDiagInfo(DiagID)->WarnShowInSystemHeader; // If we are in a system header, we ignore it. We look at the diagnostic class // because we also want to ignore extensions and warnings in -Werror and @@ -592,15 +597,6 @@ DiagnosticIDs::getDiagnosticSeverity(unsigned DiagID, SourceLocation Loc, return Result; } -DiagnosticIDs::Class DiagnosticIDs::getDiagClass(unsigned DiagID) const { - if (IsCustomDiag(DiagID)) - return Class(CustomDiagInfo->getDescription(DiagID).GetClass()); - - if (const StaticDiagInfoRec *Info = GetDiagInfo(DiagID)) - return Class(Info->Class); - return CLASS_INVALID; -} - #define GET_DIAG_ARRAYS #include "clang/Basic/DiagnosticGroups.inc" #undef GET_DIAG_ARRAYS @@ -646,12 +642,7 @@ DiagnosticIDs::getGroupForWarningOption(StringRef Name) { return static_cast<diag::Group>(Found - OptionTable); } -std::optional<diag::Group> -DiagnosticIDs::getGroupForDiag(unsigned DiagID) const { - if (IsCustomDiag(DiagID)) { - assert(CustomDiagInfo); - return CustomDiagInfo->getDescription(DiagID).GetGroup(); - } +std::optional<diag::Group> DiagnosticIDs::getGroupForDiag(unsigned DiagID) { if (const StaticDiagInfoRec *Info = GetDiagInfo(DiagID)) return static_cast<diag::Group>(Info->getOptionGroupIndex()); return std::nullopt; @@ -682,8 +673,7 @@ std::vector<std::string> DiagnosticIDs::getDiagnosticFlags() { /// were filtered out due to having the wrong flavor. static bool getDiagnosticsInGroup(diag::Flavor Flavor, const WarningOption *Group, - SmallVectorImpl<diag::kind> &Diags, - diag::CustomDiagInfo *CustomDiagInfo) { + SmallVectorImpl<diag::kind> &Diags) { // An empty group is considered to be a warning group: we have empty groups // for GCC compatibility, and GCC does not have remarks. if (!Group->Members && !Group->SubGroups) @@ -702,14 +692,9 @@ static bool getDiagnosticsInGroup(diag::Flavor Flavor, // Add the members of the subgroups. const int16_t *SubGroups = DiagSubGroups + Group->SubGroups; - for (; *SubGroups != (int16_t)-1; ++SubGroups) { - if (CustomDiagInfo) - llvm::copy( - CustomDiagInfo->getDiagsInGroup(static_cast<diag::Group>(*SubGroups)), - std::back_inserter(Diags)); + for (; *SubGroups != (int16_t)-1; ++SubGroups) NotFound &= getDiagnosticsInGroup(Flavor, &OptionTable[(short)*SubGroups], - Diags, CustomDiagInfo); - } + Diags); return NotFound; } @@ -717,49 +702,12 @@ static bool getDiagnosticsInGroup(diag::Flavor Flavor, bool DiagnosticIDs::getDiagnosticsInGroup(diag::Flavor Flavor, StringRef Group, SmallVectorImpl<diag::kind> &Diags) const { - if (std::optional<diag::Group> G = getGroupForWarningOption(Group)) { - if (CustomDiagInfo) - llvm::copy(CustomDiagInfo->getDiagsInGroup(*G), - std::back_inserter(Diags)); - return ::getDiagnosticsInGroup(Flavor, - &OptionTable[static_cast<unsigned>(*G)], - Diags, CustomDiagInfo.get()); - } + if (std::optional<diag::Group> G = getGroupForWarningOption(Group)) + return ::getDiagnosticsInGroup( + Flavor, &OptionTable[static_cast<unsigned>(*G)], Diags); return true; } -template <class Func> -static void forEachSubGroupImpl(const WarningOption *Group, Func func) { - for (const int16_t *SubGroups = DiagSubGroups + Group->SubGroups; - *SubGroups != -1; ++SubGroups) { - func(static_cast<size_t>(*SubGroups)); - forEachSubGroupImpl(&OptionTable[*SubGroups], std::move(func)); - } -} - -template <class Func> -static void forEachSubGroup(diag::Group Group, Func func) { - const WarningOption *WarningOpt = &OptionTable[static_cast<size_t>(Group)]; - func(static_cast<size_t>(Group)); - ::forEachSubGroupImpl(WarningOpt, std::move(func)); -} - -void DiagnosticIDs::setGroupSeverity(StringRef Group, diag::Severity Sev) { - if (std::optional<diag::Group> G = getGroupForWarningOption(Group)) { - ::forEachSubGroup(*G, [&](size_t SubGroup) { - GroupInfos[SubGroup].Severity = static_cast<unsigned>(Sev); - }); - } -} - -void DiagnosticIDs::setGroupNoWarningsAsError(StringRef Group, bool Val) { - if (std::optional<diag::Group> G = getGroupForWarningOption(Group)) { - ::forEachSubGroup(*G, [&](size_t SubGroup) { - GroupInfos[static_cast<size_t>(*G)].HasNoWarningAsError = Val; - }); - } -} - void DiagnosticIDs::getAllDiagnostics(diag::Flavor Flavor, std::vector<diag::kind> &Diags) { for (unsigned i = 0; i != StaticDiagInfoSize; ++i) @@ -782,7 +730,7 @@ StringRef DiagnosticIDs::getNearestOption(diag::Flavor Flavor, // Don't suggest groups that are not of this kind. llvm::SmallVector<diag::kind, 8> Diags; - if (::getDiagnosticsInGroup(Flavor, &O, Diags, nullptr) || Diags.empty()) + if (::getDiagnosticsInGroup(Flavor, &O, Diags) || Diags.empty()) continue; if (Distance == BestDistance) { @@ -895,8 +843,14 @@ void DiagnosticIDs::EmitDiag(DiagnosticsEngine &Diag, Level DiagLevel) const { } bool DiagnosticIDs::isUnrecoverable(unsigned DiagID) const { + if (DiagID >= diag::DIAG_UPPER_LIMIT) { + assert(CustomDiagInfo && "Invalid CustomDiagInfo"); + // Custom diagnostics. + return CustomDiagInfo->getLevel(DiagID) >= DiagnosticIDs::Error; + } + // Only errors may be unrecoverable. - if (getDiagClass(DiagID) < CLASS_ERROR) + if (getBuiltinDiagClass(DiagID) < CLASS_ERROR) return false; if (DiagID == diag::err_unavailable || diff --git a/clang/lib/Frontend/LogDiagnosticPrinter.cpp b/clang/lib/Frontend/LogDiagnosticPrinter.cpp index 4e963af837f01f..469d1c22633aa3 100644 --- a/clang/lib/Frontend/LogDiagnosticPrinter.cpp +++ b/clang/lib/Frontend/LogDiagnosticPrinter.cpp @@ -129,8 +129,7 @@ void LogDiagnosticPrinter::HandleDiagnostic(DiagnosticsEngine::Level Level, DE.DiagnosticLevel = Level; DE.WarningOption = - std::string(Info.getDiags()->getDiagnosticIDs()->getWarningOptionForDiag( - DE.DiagnosticID)); + std::string(DiagnosticIDs::getWarningOptionForDiag(DE.DiagnosticID)); // Format the message. SmallString<100> MessageStr; @@ -161,3 +160,4 @@ void LogDiagnosticPrinter::HandleDiagnostic(DiagnosticsEngine::Level Level, // Record the diagnostic entry. Entries.push_back(DE); } + diff --git a/clang/lib/Frontend/SerializedDiagnosticPrinter.cpp b/clang/lib/Frontend/SerializedDiagnosticPrinter.cpp index d1db31763e5009..0887b5a504f05a 100644 --- a/clang/lib/Frontend/SerializedDiagnosticPrinter.cpp +++ b/clang/lib/Frontend/SerializedDiagnosticPrinter.cpp @@ -202,7 +202,7 @@ class SDiagsWriter : public DiagnosticConsumer { /// Emit the string information for diagnostic flags. unsigned getEmitDiagnosticFlag(DiagnosticsEngine::Level DiagLevel, - const Diagnostic *Diag = nullptr); + unsigned DiagID = 0); unsigned getEmitDiagnosticFlag(StringRef DiagName); @@ -536,13 +536,11 @@ unsigned SDiagsWriter::getEmitCategory(unsigned int category) { } unsigned SDiagsWriter::getEmitDiagnosticFlag(DiagnosticsEngine::Level DiagLevel, - const Diagnostic *Diag) { - if (!Diag || DiagLevel == DiagnosticsEngine::Note) + unsigned DiagID) { + if (DiagLevel == DiagnosticsEngine::Note) return 0; // No flag for notes. - StringRef FlagName = - Diag->getDiags()->getDiagnosticIDs()->getWarningOptionForDiag( - Diag->getID()); + StringRef FlagName = DiagnosticIDs::getWarningOptionForDiag(DiagID); return getEmitDiagnosticFlag(FlagName); } @@ -657,7 +655,7 @@ void SDiagsWriter::EmitDiagnosticMessage(FullSourceLoc Loc, PresumedLoc PLoc, unsigned DiagID = DiagnosticIDs::getCategoryNumberForDiag(Info->getID()); Record.push_back(getEmitCategory(DiagID)); // Emit the diagnostic flag string lazily and get the mapped ID. - Record.push_back(getEmitDiagnosticFlag(Level, Info)); + Record.push_back(getEmitDiagnosticFlag(Level, Info->getID())); } else { Record.push_back(getEmitCategory()); Record.push_back(getEmitDiagnosticFlag(Level)); diff --git a/clang/lib/Frontend/TextDiagnosticPrinter.cpp b/clang/lib/Frontend/TextDiagnosticPrinter.cpp index c2fea3d03f0c0f..b2fb762537573e 100644 --- a/clang/lib/Frontend/TextDiagnosticPrinter.cpp +++ b/clang/lib/Frontend/TextDiagnosticPrinter.cpp @@ -70,17 +70,13 @@ static void printDiagnosticOptions(raw_ostream &OS, // flag it as such. Note that diagnostics could also have been mapped by a // pragma, but we don't currently have a way to distinguish this. if (Level == DiagnosticsEngine::Error && - Info.getDiags()->getDiagnosticIDs()->isWarningOrExtension( - Info.getID()) && - !Info.getDiags()->getDiagnosticIDs()->isDefaultMappingAsError( - Info.getID())) { + DiagnosticIDs::isBuiltinWarningOrExtension(Info.getID()) && + !DiagnosticIDs::isDefaultMappingAsError(Info.getID())) { OS << " [-Werror"; Started = true; } - StringRef Opt = - Info.getDiags()->getDiagnosticIDs()->getWarningOptionForDiag( - Info.getID()); + StringRef Opt = DiagnosticIDs::getWarningOptionForDiag(Info.getID()); if (!Opt.empty()) { OS << (Started ? "," : " [") << (Level == DiagnosticsEngine::Remark ? "-R" : "-W") << Opt; diff --git a/clang/lib/Sema/Sema.cpp b/clang/lib/Sema/Sema.cpp index d567de703903c9..46ddd360870b4f 100644 --- a/clang/lib/Sema/Sema.cpp +++ b/clang/lib/Sema/Sema.cpp @@ -1683,7 +1683,7 @@ void Sema::EmitCurrentDiagnostic(unsigned DiagID) { // that is diff erent from the last template instantiation where // we emitted an error, print a template instantiation // backtrace. - if (!Diags.getDiagnosticIDs()->isNote(DiagID)) + if (!DiagnosticIDs::isBuiltinNote(DiagID)) PrintContextStack(); } @@ -1697,8 +1697,7 @@ bool Sema::hasUncompilableErrorOccurred() const { if (Loc == DeviceDeferredDiags.end()) return false; for (auto PDAt : Loc->second) { - if (Diags.getDiagnosticIDs()->isDefaultMappingAsError( - PDAt.second.getDiagID())) + if (DiagnosticIDs::isDefaultMappingAsError(PDAt.second.getDiagID())) return true; } return false; diff --git a/clang/lib/Sema/SemaCUDA.cpp b/clang/lib/Sema/SemaCUDA.cpp index fbb3de4b3e4165..ec37c0df56c671 100644 --- a/clang/lib/Sema/SemaCUDA.cpp +++ b/clang/lib/Sema/SemaCUDA.cpp @@ -835,7 +835,7 @@ SemaBase::SemaDiagnosticBuilder SemaCUDA::DiagIfDeviceCode(SourceLocation Loc, if (!getLangOpts().CUDAIsDevice) return SemaDiagnosticBuilder::K_Nop; if (SemaRef.IsLastErrorImmediate && - getDiagnostics().getDiagnosticIDs()->isNote(DiagID)) + getDiagnostics().getDiagnosticIDs()->isBuiltinNote(DiagID)) return SemaDiagnosticBuilder::K_Immediate; return (SemaRef.getEmissionStatus(CurFunContext) == Sema::FunctionEmissionStatus::Emitted) @@ -866,7 +866,7 @@ Sema::SemaDiagnosticBuilder SemaCUDA::DiagIfHostCode(SourceLocation Loc, if (getLangOpts().CUDAIsDevice) return SemaDiagnosticBuilder::K_Nop; if (SemaRef.IsLastErrorImmediate && - getDiagnostics().getDiagnosticIDs()->isNote(DiagID)) + getDiagnostics().getDiagnosticIDs()->isBuiltinNote(DiagID)) return SemaDiagnosticBuilder::K_Immediate; return (SemaRef.getEmissionStatus(CurFunContext) == Sema::FunctionEmissionStatus::Emitted) diff --git a/clang/lib/Sema/SemaDeclAttr.cpp b/clang/lib/Sema/SemaDeclAttr.cpp index 14cc51cf89665a..c9b9f3a0007daa 100644 --- a/clang/lib/Sema/SemaDeclAttr.cpp +++ b/clang/lib/Sema/SemaDeclAttr.cpp @@ -852,38 +852,22 @@ static void handleDiagnoseIfAttr(Sema &S, Decl *D, const ParsedAttr &AL) { if (!checkFunctionConditionAttr(S, D, AL, Cond, Msg)) return; - StringRef DefaultSevStr; - if (!S.checkStringLiteralArgumentAttr(AL, 2, DefaultSevStr)) + StringRef DiagTypeStr; + if (!S.checkStringLiteralArgumentAttr(AL, 2, DiagTypeStr)) return; - DiagnoseIfAttr::DefaultSeverity DefaultSev; - if (!DiagnoseIfAttr::ConvertStrToDefaultSeverity(DefaultSevStr, DefaultSev)) { + DiagnoseIfAttr::DiagnosticType DiagType; + if (!DiagnoseIfAttr::ConvertStrToDiagnosticType(DiagTypeStr, DiagType)) { S.Diag(AL.getArgAsExpr(2)->getBeginLoc(), diag::err_diagnose_if_invalid_diagnostic_type); return; } - StringRef WarningGroup; - SmallVector<StringRef, 2> Options; - if (AL.getNumArgs() > 3) { - if (!S.checkStringLiteralArgumentAttr(AL, 3, WarningGroup)) - return; - if (WarningGroup.empty() || - !S.getDiagnostics().getDiagnosticIDs()->getGroupForWarningOption( - WarningGroup)) { - S.Diag(AL.getArgAsExpr(3)->getBeginLoc(), - diag::err_diagnose_if_unknown_warning) - << WarningGroup; - return; - } - } - bool ArgDependent = false; if (const auto *FD = dyn_cast<FunctionDecl>(D)) ArgDependent = ArgumentDependenceChecker(FD).referencesArgs(Cond); D->addAttr(::new (S.Context) DiagnoseIfAttr( - S.Context, AL, Cond, Msg, DefaultSev, WarningGroup, ArgDependent, - cast<NamedDecl>(D))); + S.Context, AL, Cond, Msg, DiagType, ArgDependent, cast<NamedDecl>(D))); } static void handleNoBuiltinAttr(Sema &S, Decl *D, const ParsedAttr &AL) { diff --git a/clang/lib/Sema/SemaOverload.cpp b/clang/lib/Sema/SemaOverload.cpp index d3e009a658f0e8..a155bb2fd3ba2a 100644 --- a/clang/lib/Sema/SemaOverload.cpp +++ b/clang/lib/Sema/SemaOverload.cpp @@ -7307,10 +7307,8 @@ static bool diagnoseDiagnoseIfAttrsWith(Sema &S, const NamedDecl *ND, return false; auto WarningBegin = std::stable_partition( - Attrs.begin(), Attrs.end(), [](const DiagnoseIfAttr *DIA) { - return DIA->getDefaultSeverity() == DiagnoseIfAttr::DS_error && - DIA->getWarningGroup().empty(); - }); + Attrs.begin(), Attrs.end(), + [](const DiagnoseIfAttr *DIA) { return DIA->isError(); }); // Note that diagnose_if attributes are late-parsed, so they appear in the // correct order (unlike enable_if attributes). @@ -7324,31 +7322,11 @@ static bool diagnoseDiagnoseIfAttrsWith(Sema &S, const NamedDecl *ND, return true; } - auto ToSeverity = [](DiagnoseIfAttr::DefaultSeverity Sev) { - switch (Sev) { - case DiagnoseIfAttr::DS_warning: - return diag::Severity::Warning; - case DiagnoseIfAttr::DS_error: - return diag::Severity::Error; - } - }; - for (const auto *DIA : llvm::make_range(WarningBegin, Attrs.end())) if (IsSuccessful(DIA)) { - if (DIA->getWarningGroup().empty() && - DIA->getDefaultSeverity() == DiagnoseIfAttr::DS_warning) { - S.Diag(Loc, diag::warn_diagnose_if_succeeded) << DIA->getMessage(); - S.Diag(DIA->getLocation(), diag::note_from_diagnose_if) - << DIA->getParent() << DIA->getCond()->getSourceRange(); - } else { - auto DiagGroup = S.Diags.getDiagnosticIDs()->getGroupForWarningOption( - DIA->getWarningGroup()); - assert(DiagGroup); - auto DiagID = S.Diags.getDiagnosticIDs()->getCustomDiagID( - {ToSeverity(DIA->getDefaultSeverity()), "%0", - DiagnosticIDs::CLASS_WARNING, false, false, *DiagGroup}); - S.Diag(Loc, DiagID) << DIA->getMessage(); - } + S.Diag(Loc, diag::warn_diagnose_if_succeeded) << DIA->getMessage(); + S.Diag(DIA->getLocation(), diag::note_from_diagnose_if) + << DIA->getParent() << DIA->getCond()->getSourceRange(); } return false; diff --git a/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp b/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp index e97a7d768b931b..bb311e38409280 100644 --- a/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp +++ b/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp @@ -284,8 +284,7 @@ static void instantiateDependentDiagnoseIfAttr( if (Cond) New->addAttr(new (S.getASTContext()) DiagnoseIfAttr( S.getASTContext(), *DIA, Cond, DIA->getMessage(), - DIA->getDefaultSeverity(), DIA->getWarningGroup(), - DIA->getArgDependent(), New)); + DIA->getDiagnosticType(), DIA->getArgDependent(), New)); } // Constructs and adds to New a new instance of CUDALaunchBoundsAttr using diff --git a/clang/lib/Serialization/ASTReader.cpp b/clang/lib/Serialization/ASTReader.cpp index 4fae6ff02ea9a3..e5a1e20a265616 100644 --- a/clang/lib/Serialization/ASTReader.cpp +++ b/clang/lib/Serialization/ASTReader.cpp @@ -6641,7 +6641,7 @@ void ASTReader::ReadPragmaDiagnosticMappings(DiagnosticsEngine &Diag) { // command line (-w, -Weverything, -Werror, ...) along with any explicit // -Wblah flags. unsigned Flags = Record[Idx++]; - DiagState Initial(*Diag.getDiagnosticIDs()); + DiagState Initial; Initial.SuppressSystemWarnings = Flags & 1; Flags >>= 1; Initial.ErrorsAsFatal = Flags & 1; Flags >>= 1; Initial.WarningsAsErrors = Flags & 1; Flags >>= 1; diff --git a/clang/lib/Serialization/ASTWriter.cpp b/clang/lib/Serialization/ASTWriter.cpp index 008bf571f847dc..c6289493fce1de 100644 --- a/clang/lib/Serialization/ASTWriter.cpp +++ b/clang/lib/Serialization/ASTWriter.cpp @@ -3219,7 +3219,7 @@ void ASTWriter::WritePragmaDiagnosticMappings(const DiagnosticsEngine &Diag, // Skip default mappings. We have a mapping for every diagnostic ever // emitted, regardless of whether it was customized. if (!I.second.isPragma() && - I.second == Diag.getDiagnosticIDs()->getDefaultMapping(I.first)) + I.second == DiagnosticIDs::getDefaultMapping(I.first)) continue; Mappings.push_back(I); } diff --git a/clang/lib/StaticAnalyzer/Core/TextDiagnostics.cpp b/clang/lib/StaticAnalyzer/Core/TextDiagnostics.cpp index 7cdd545e61b328..71268af22e2424 100644 --- a/clang/lib/StaticAnalyzer/Core/TextDiagnostics.cpp +++ b/clang/lib/StaticAnalyzer/Core/TextDiagnostics.cpp @@ -91,6 +91,7 @@ class TextDiagnostics : public PathDiagnosticConsumer { ? " [" + PD->getCheckerName() + "]" : "") .str(); + reportPiece(WarnID, PD->getLocation().asLocation(), (PD->getShortDescription() + WarningMsg).str(), PD->path.back()->getRanges(), PD->path.back()->getFixits()); diff --git a/clang/test/Sema/diagnose_if.c b/clang/test/Sema/diagnose_if.c index e9b8497d5ca4e5..4df39916c031e3 100644 --- a/clang/test/Sema/diagnose_if.c +++ b/clang/test/Sema/diagnose_if.c @@ -2,10 +2,10 @@ #define _diagnose_if(...) __attribute__((diagnose_if(__VA_ARGS__))) -void failure1(void) _diagnose_if(); // expected-error{{at least 3 arguments}} -void failure2(void) _diagnose_if(0); // expected-error{{at least 3 arguments}} -void failure3(void) _diagnose_if(0, ""); // expected-error{{at least 3 arguments}} -void failure4(void) _diagnose_if(0, "", "error", 1); // expected-error{{expected string literal as argument}} +void failure1(void) _diagnose_if(); // expected-error{{exactly 3 arguments}} +void failure2(void) _diagnose_if(0); // expected-error{{exactly 3 arguments}} +void failure3(void) _diagnose_if(0, ""); // expected-error{{exactly 3 arguments}} +void failure4(void) _diagnose_if(0, "", "error", 1); // expected-error{{exactly 3 arguments}} void failure5(void) _diagnose_if(0, 0, "error"); // expected-error{{expected string literal as argument of 'diagnose_if' attribute}} void failure6(void) _diagnose_if(0, "", "invalid"); // expected-error{{invalid diagnostic type for 'diagnose_if'; use "error" or "warning" instead}} void failure7(void) _diagnose_if(0, "", "ERROR"); // expected-error{{invalid diagnostic type}} diff --git a/clang/test/SemaCXX/diagnose_if-warning-group.cpp b/clang/test/SemaCXX/diagnose_if-warning-group.cpp deleted file mode 100644 index a39c0c0c33c9ef..00000000000000 --- a/clang/test/SemaCXX/diagnose_if-warning-group.cpp +++ /dev/null @@ -1,63 +0,0 @@ -// RUN: %clang_cc1 %s -verify=expected,wall -fno-builtin -Wno-pedantic -Werror=comment -Wno-error=abi -Wfatal-errors=assume -Wno-fatal-errors=assume -Wno-format -// RUN: %clang_cc1 %s -verify=expected,wno-all,pedantic,format -fno-builtin -Wno-all -Werror=comment -Wno-error=abi -Werror=assume -Wformat - -#define diagnose_if(...) __attribute__((diagnose_if(__VA_ARGS__))) - -#ifndef EMTY_WARNING_GROUP -void bougus_warning() diagnose_if(true, "oh no", "warning", "bogus warning") {} // expected-error {{unknown warning group 'bogus warning'}} - -void show_in_system_header() diagnose_if(true, "oh no", "warning", "assume", "Banane") {} // expected-error {{'diagnose_if' attribute takes no more than 4 arguments}} -#endif // EMTY_WARNING_GROUP - -template <bool b> -void diagnose_if_wcomma() diagnose_if(b, "oh no", "warning", "comma") {} - -template <bool b> -void diagnose_if_wcomment() diagnose_if(b, "oh no", "warning", "comment") {} - -void empty_warning_group() diagnose_if(true, "oh no", "warning", "") {} // expected-error {{unknown warning group ''}} -void empty_warning_group_error() diagnose_if(true, "oh no", "error", "") {} // expected-error {{unknown warning group ''}} - -void diagnose_if_wabi_default_error() diagnose_if(true, "ABI stuff", "error", "abi") {} -void diagnose_assume() diagnose_if(true, "Assume diagnostic", "warning", "assume") {} - -void Wall() diagnose_if(true, "oh no", "warning", "all") {} -void Wpedantic() diagnose_if(true, "oh no", "warning", "pedantic") {} -void Wformat_extra_args() diagnose_if(true, "oh no", "warning", "format-extra-args") {} - -void call() { - diagnose_if_wcomma<true>(); // expected-warning {{oh no}} - diagnose_if_wcomma<false>(); - diagnose_if_wcomment<true>(); // expected-error {{oh no}} - diagnose_if_wcomment<false>(); - -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wcomma" - diagnose_if_wcomma<true>(); - diagnose_if_wcomment<true>(); // expected-error {{oh no}} -#pragma clang diagnostic pop - -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wcomment" - diagnose_if_wcomma<true>(); // expected-warning {{oh no}} - diagnose_if_wcomment<true>(); -#pragma clang diagnostic pop - - diagnose_if_wcomma<true>(); // expected-warning {{oh no}} - diagnose_if_wcomment<true>(); // expected-error {{oh no}} - - diagnose_if_wabi_default_error(); // expected-warning {{ABI stuff}} - diagnose_assume(); // expected-error {{Assume diagnostic}} - - // Make sure that the -Wassume diagnostic isn't fatal - diagnose_if_wabi_default_error(); // expected-warning {{ABI stuff}} - - Wall(); // wall-warning {{oh no}} - Wpedantic(); // pedantic-warning {{oh no}} - Wformat_extra_args(); // format-warning {{oh no}} - -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wformat" - Wformat_extra_args(); -#pragma clang diagnostic pop -} diff --git a/clang/tools/diagtool/ListWarnings.cpp b/clang/tools/diagtool/ListWarnings.cpp index 9f9647126dd8a0..a71f6e3a66c8eb 100644 --- a/clang/tools/diagtool/ListWarnings.cpp +++ b/clang/tools/diagtool/ListWarnings.cpp @@ -53,13 +53,13 @@ int ListWarnings::run(unsigned int argc, char **argv, llvm::raw_ostream &out) { for (const DiagnosticRecord &DR : getBuiltinDiagnosticsByName()) { const unsigned diagID = DR.DiagID; - if (DiagnosticIDs{}.isNote(diagID)) + if (DiagnosticIDs::isBuiltinNote(diagID)) continue; - if (!DiagnosticIDs{}.isWarningOrExtension(diagID)) + if (!DiagnosticIDs::isBuiltinWarningOrExtension(diagID)) continue; - Entry entry(DR.getName(), DiagnosticIDs{}.getWarningOptionForDiag(diagID)); + Entry entry(DR.getName(), DiagnosticIDs::getWarningOptionForDiag(diagID)); if (entry.Flag.empty()) Unflagged.push_back(entry); @@ -97,3 +97,4 @@ int ListWarnings::run(unsigned int argc, char **argv, llvm::raw_ostream &out) { return 0; } + diff --git a/clang/tools/diagtool/ShowEnabledWarnings.cpp b/clang/tools/diagtool/ShowEnabledWarnings.cpp index caf67223921d4b..66a295db054c35 100644 --- a/clang/tools/diagtool/ShowEnabledWarnings.cpp +++ b/clang/tools/diagtool/ShowEnabledWarnings.cpp @@ -117,10 +117,10 @@ int ShowEnabledWarnings::run(unsigned int argc, char **argv, raw_ostream &Out) { for (const DiagnosticRecord &DR : getBuiltinDiagnosticsByName()) { unsigned DiagID = DR.DiagID; - if (DiagnosticIDs{}.isNote(DiagID)) + if (DiagnosticIDs::isBuiltinNote(DiagID)) continue; - if (!DiagnosticIDs{}.isWarningOrExtension(DiagID)) + if (!DiagnosticIDs::isBuiltinWarningOrExtension(DiagID)) continue; DiagnosticsEngine::Level DiagLevel = @@ -128,7 +128,7 @@ int ShowEnabledWarnings::run(unsigned int argc, char **argv, raw_ostream &Out) { if (DiagLevel == DiagnosticsEngine::Ignored) continue; - StringRef WarningOpt = DiagnosticIDs{}.getWarningOptionForDiag(DiagID); + StringRef WarningOpt = DiagnosticIDs::getWarningOptionForDiag(DiagID); Active.push_back(PrettyDiag(DR.getName(), WarningOpt, DiagLevel)); } diff --git a/clang/tools/libclang/CXStoredDiagnostic.cpp b/clang/tools/libclang/CXStoredDiagnostic.cpp index 6fb3050f5f8445..03018229549bd4 100644 --- a/clang/tools/libclang/CXStoredDiagnostic.cpp +++ b/clang/tools/libclang/CXStoredDiagnostic.cpp @@ -51,9 +51,7 @@ CXString CXStoredDiagnostic::getSpelling() const { CXString CXStoredDiagnostic::getDiagnosticOption(CXString *Disable) const { unsigned ID = Diag.getID(); - if (DiagnosticIDs::IsCustomDiag(ID)) - return cxstring::createEmpty(); - StringRef Option = DiagnosticIDs{}.getWarningOptionForDiag(ID); + StringRef Option = DiagnosticIDs::getWarningOptionForDiag(ID); if (!Option.empty()) { if (Disable) *Disable = cxstring::createDup((Twine("-Wno-") + Option).str()); diff --git a/flang/lib/Frontend/TextDiagnosticPrinter.cpp b/flang/lib/Frontend/TextDiagnosticPrinter.cpp index 8b00fb69b3cefb..1e6414f38648e0 100644 --- a/flang/lib/Frontend/TextDiagnosticPrinter.cpp +++ b/flang/lib/Frontend/TextDiagnosticPrinter.cpp @@ -38,8 +38,8 @@ TextDiagnosticPrinter::~TextDiagnosticPrinter() {} static void printRemarkOption(llvm::raw_ostream &os, clang::DiagnosticsEngine::Level level, const clang::Diagnostic &info) { - llvm::StringRef opt = info.getDiags()->getDiagnosticIDs() - ->getWarningOptionForDiag(info.getID()); + llvm::StringRef opt = + clang::DiagnosticIDs::getWarningOptionForDiag(info.getID()); if (!opt.empty()) { // We still need to check if the level is a Remark since, an unknown option // warning could be printed i.e. [-Wunknown-warning-option] _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
