Move LogLevel enum out of cmake.h header

Move LogLevel enum into the cmMessageType.h header in preparation
for a new log level querying feature.
Wrap the enum into a new Message namespace.
Adjust all code usages.

Source/cmMessageCommand.cxx

@@ -81,91 +81,91 @@ bool cmMessageCommand(std::vector<std::string> const& args,
 
   auto type = MessageType::MESSAGE;
   auto fatal = false;
-  auto level = cmake::LogLevel::LOG_UNDEFINED;
+  auto level = Message::LogLevel::LOG_UNDEFINED;
   auto checkingType = CheckingType::UNDEFINED;
   if (*i == "SEND_ERROR") {
     type = MessageType::FATAL_ERROR;
-    level = cmake::LogLevel::LOG_ERROR;
+    level = Message::LogLevel::LOG_ERROR;
     ++i;
   } else if (*i == "FATAL_ERROR") {
     fatal = true;
     type = MessageType::FATAL_ERROR;
-    level = cmake::LogLevel::LOG_ERROR;
+    level = Message::LogLevel::LOG_ERROR;
     ++i;
   } else if (*i == "WARNING") {
     type = MessageType::WARNING;
-    level = cmake::LogLevel::LOG_WARNING;
+    level = Message::LogLevel::LOG_WARNING;
     ++i;
   } else if (*i == "AUTHOR_WARNING") {
     if (mf.IsSet("CMAKE_SUPPRESS_DEVELOPER_ERRORS") &&
         !mf.IsOn("CMAKE_SUPPRESS_DEVELOPER_ERRORS")) {
       fatal = true;
       type = MessageType::AUTHOR_ERROR;
-      level = cmake::LogLevel::LOG_ERROR;
+      level = Message::LogLevel::LOG_ERROR;
     } else if (!mf.IsOn("CMAKE_SUPPRESS_DEVELOPER_WARNINGS")) {
       type = MessageType::AUTHOR_WARNING;
-      level = cmake::LogLevel::LOG_WARNING;
+      level = Message::LogLevel::LOG_WARNING;
     } else {
       return true;
     }
     ++i;
   } else if (*i == "CHECK_START") {
-    level = cmake::LogLevel::LOG_STATUS;
+    level = Message::LogLevel::LOG_STATUS;
     checkingType = CheckingType::CHECK_START;
     ++i;
   } else if (*i == "CHECK_PASS") {
-    level = cmake::LogLevel::LOG_STATUS;
+    level = Message::LogLevel::LOG_STATUS;
     checkingType = CheckingType::CHECK_PASS;
     ++i;
   } else if (*i == "CHECK_FAIL") {
-    level = cmake::LogLevel::LOG_STATUS;
+    level = Message::LogLevel::LOG_STATUS;
     checkingType = CheckingType::CHECK_FAIL;
     ++i;
   } else if (*i == "STATUS") {
-    level = cmake::LogLevel::LOG_STATUS;
+    level = Message::LogLevel::LOG_STATUS;
     ++i;
   } else if (*i == "VERBOSE") {
-    level = cmake::LogLevel::LOG_VERBOSE;
+    level = Message::LogLevel::LOG_VERBOSE;
     ++i;
   } else if (*i == "DEBUG") {
-    level = cmake::LogLevel::LOG_DEBUG;
+    level = Message::LogLevel::LOG_DEBUG;
     ++i;
   } else if (*i == "TRACE") {
-    level = cmake::LogLevel::LOG_TRACE;
+    level = Message::LogLevel::LOG_TRACE;
     ++i;
   } else if (*i == "DEPRECATION") {
     if (mf.IsOn("CMAKE_ERROR_DEPRECATED")) {
       fatal = true;
       type = MessageType::DEPRECATION_ERROR;
-      level = cmake::LogLevel::LOG_ERROR;
+      level = Message::LogLevel::LOG_ERROR;
     } else if (!mf.IsSet("CMAKE_WARN_DEPRECATED") ||
                mf.IsOn("CMAKE_WARN_DEPRECATED")) {
       type = MessageType::DEPRECATION_WARNING;
-      level = cmake::LogLevel::LOG_WARNING;
+      level = Message::LogLevel::LOG_WARNING;
     } else {
       return true;
     }
     ++i;
   } else if (*i == "NOTICE") {
     // `NOTICE` message type is going to be output to stderr
-    level = cmake::LogLevel::LOG_NOTICE;
+    level = Message::LogLevel::LOG_NOTICE;
     ++i;
   } else {
     // Messages w/o any type are `NOTICE`s
-    level = cmake::LogLevel::LOG_NOTICE;
+    level = Message::LogLevel::LOG_NOTICE;
   }
   assert("Message log level expected to be set" &&
-         level != cmake::LogLevel::LOG_UNDEFINED);
+         level != Message::LogLevel::LOG_UNDEFINED);
 
   auto desiredLevel = mf.GetCMakeInstance()->GetLogLevel();
   assert("Expected a valid log level here" &&
-         desiredLevel != cmake::LogLevel::LOG_UNDEFINED);
+         desiredLevel != Message::LogLevel::LOG_UNDEFINED);
 
   // Command line option takes precedence over the cache variable
   if (!mf.GetCMakeInstance()->WasLogLevelSetViaCLI()) {
     const auto desiredLevelFromCache =
       cmake::StringToLogLevel(mf.GetSafeDefinition("CMAKE_MESSAGE_LOG_LEVEL"));
-    if (desiredLevelFromCache != cmake::LogLevel::LOG_UNDEFINED) {
+    if (desiredLevelFromCache != Message::LogLevel::LOG_UNDEFINED) {
       desiredLevel = desiredLevelFromCache;
     }
   }
@@ -178,17 +178,17 @@ bool cmMessageCommand(std::vector<std::string> const& args,
   auto message = cmJoin(cmMakeRange(i, args.cend()), "");
 
   switch (level) {
-    case cmake::LogLevel::LOG_ERROR:
-    case cmake::LogLevel::LOG_WARNING:
+    case Message::LogLevel::LOG_ERROR:
+    case Message::LogLevel::LOG_WARNING:
       // we've overridden the message type, above, so display it directly
       mf.GetMessenger()->DisplayMessage(type, message, mf.GetBacktrace());
       break;
 
-    case cmake::LogLevel::LOG_NOTICE:
+    case Message::LogLevel::LOG_NOTICE:
       cmSystemTools::Message(IndentText(message, mf));
       break;
 
-    case cmake::LogLevel::LOG_STATUS:
+    case Message::LogLevel::LOG_STATUS:
       switch (checkingType) {
         case CheckingType::CHECK_START:
           mf.DisplayStatus(IndentText(message, mf), -1);
@@ -209,9 +209,9 @@ bool cmMessageCommand(std::vector<std::string> const& args,
       }
       break;
 
-    case cmake::LogLevel::LOG_VERBOSE:
-    case cmake::LogLevel::LOG_DEBUG:
-    case cmake::LogLevel::LOG_TRACE:
+    case Message::LogLevel::LOG_VERBOSE:
+    case Message::LogLevel::LOG_DEBUG:
+    case Message::LogLevel::LOG_TRACE:
       mf.DisplayStatus(IndentText(message, mf), -1);
       break;
 

Source/cmMessageType.h

@@ -16,3 +16,19 @@ enum class MessageType
   DEPRECATION_ERROR,
   DEPRECATION_WARNING
 };
+
+namespace Message {
+
+/** \brief Define log level constants. */
+enum class LogLevel
+{
+  LOG_UNDEFINED,
+  LOG_ERROR,
+  LOG_WARNING,
+  LOG_NOTICE,
+  LOG_STATUS,
+  LOG_VERBOSE,
+  LOG_DEBUG,
+  LOG_TRACE
+};
+}

Source/cmake.cxx

@@ -955,7 +955,7 @@ void cmake::SetArgs(const std::vector<std::string>& args)
                      CommandArgument::Values::One,
                      [](std::string const& value, cmake* state) -> bool {
                        const auto logLevel = StringToLogLevel(value);
-                       if (logLevel == LogLevel::LOG_UNDEFINED) {
+                       if (logLevel == Message::LogLevel::LOG_UNDEFINED) {
                          cmSystemTools::Error(
                            "Invalid level specified for --log-level");
                          return false;
@@ -971,7 +971,7 @@ void cmake::SetArgs(const std::vector<std::string>& args)
                      CommandArgument::Values::One,
                      [](std::string const& value, cmake* state) -> bool {
                        const auto logLevel = StringToLogLevel(value);
-                       if (logLevel == LogLevel::LOG_UNDEFINED) {
+                       if (logLevel == Message::LogLevel::LOG_UNDEFINED) {
                          cmSystemTools::Error(
                            "Invalid level specified for --loglevel");
                          return false;
@@ -1402,14 +1402,17 @@ void cmake::SetArgs(const std::vector<std::string>& args)
 #endif
 }
 
-cmake::LogLevel cmake::StringToLogLevel(const std::string& levelStr)
+Message::LogLevel cmake::StringToLogLevel(const std::string& levelStr)
 {
-  using LevelsPair = std::pair<std::string, LogLevel>;
+  using LevelsPair = std::pair<std::string, Message::LogLevel>;
   static const std::vector<LevelsPair> levels = {
-    { "error", LogLevel::LOG_ERROR },     { "warning", LogLevel::LOG_WARNING },
-    { "notice", LogLevel::LOG_NOTICE },   { "status", LogLevel::LOG_STATUS },
-    { "verbose", LogLevel::LOG_VERBOSE }, { "debug", LogLevel::LOG_DEBUG },
-    { "trace", LogLevel::LOG_TRACE }
+    { "error", Message::LogLevel::LOG_ERROR },
+    { "warning", Message::LogLevel::LOG_WARNING },
+    { "notice", Message::LogLevel::LOG_NOTICE },
+    { "status", Message::LogLevel::LOG_STATUS },
+    { "verbose", Message::LogLevel::LOG_VERBOSE },
+    { "debug", Message::LogLevel::LOG_DEBUG },
+    { "trace", Message::LogLevel::LOG_TRACE }
   };
 
   const auto levelStrLowCase = cmSystemTools::LowerCase(levelStr);
@@ -1418,7 +1421,7 @@ cmake::LogLevel cmake::StringToLogLevel(const std::string& levelStr)
                                [&levelStrLowCase](const LevelsPair& p) {
                                  return p.first == levelStrLowCase;
                                });
-  return (it != levels.cend()) ? it->second : LogLevel::LOG_UNDEFINED;
+  return (it != levels.cend()) ? it->second : Message::LogLevel::LOG_UNDEFINED;
 }
 
 cmake::TraceFormat cmake::StringToTraceFormat(const std::string& traceStr)

Source/cmake.h

@@ -119,19 +119,6 @@ public:
     FIND_PACKAGE_MODE
   };
 
-  /** \brief Define log level constants. */
-  enum LogLevel
-  {
-    LOG_UNDEFINED,
-    LOG_ERROR,
-    LOG_WARNING,
-    LOG_NOTICE,
-    LOG_STATUS,
-    LOG_VERBOSE,
-    LOG_DEBUG,
-    LOG_TRACE
-  };
-
   /** \brief Define supported trace formats **/
   enum TraceFormat
   {
@@ -469,9 +456,9 @@ public:
   bool WasLogLevelSetViaCLI() const { return this->LogLevelWasSetViaCLI; }
 
   //! Get the selected log level for `message()` commands during the cmake run.
-  LogLevel GetLogLevel() const { return this->MessageLogLevel; }
-  void SetLogLevel(LogLevel level) { this->MessageLogLevel = level; }
-  static LogLevel StringToLogLevel(const std::string& levelStr);
+  Message::LogLevel GetLogLevel() const { return this->MessageLogLevel; }
+  void SetLogLevel(Message::LogLevel level) { this->MessageLogLevel = level; }
+  static Message::LogLevel StringToLogLevel(const std::string& levelStr);
   static TraceFormat StringToTraceFormat(const std::string& levelStr);
 
   bool HasCheckInProgress() const
@@ -732,7 +719,7 @@ private:
   std::set<std::string> DebugFindPkgs;
   std::set<std::string> DebugFindVars;
 
-  LogLevel MessageLogLevel = LogLevel::LOG_STATUS;
+  Message::LogLevel MessageLogLevel = Message::LogLevel::LOG_STATUS;
   bool LogLevelWasSetViaCLI = false;
   bool LogContext = false;