[flang][nfc] Use a message class for "not yet implemented" messages

[PeteSteinfeld]

Summary

Following a previous suggestion from Peter Klausler.

[rovka]

Looks like a nice idea :)

flang/include/flang/Parser/message.h

34–35

Nit: For consistency, you should also add a comment for Todo. Additionally, since you're reformatting anyway, you can try to fit the comments on the same lines as the values, as seen e.g. in the RoundingMode enum (but only if they fit, don't stress too much about it).

[PeteSteinfeld]

flang/include/flang/Parser/message.h

34–35

Thanks, @rovka. Great feedback. I'll do it all.

flang/include/flang/Parser/message.h

 #include <string>
 #include <utility>
 #include <variant>
 
 namespace Fortran::parser {
 
 // Use "..."_err_en_US, "..."_warn_en_US, "..."_port_en_US, and "..."_en_US
 // string literals to define the static text and fatality of a message.
 //
-// Error: fatal error that prevents code and module file generation
-// Warning: likely problem,
-// Portability: nonstandard or obsolete features
-// Because: for AttachTo(), explanatory attachment in support of another message
-// Context (internal): attachment from SetContext()
-// None: everything else, common for attachments with source locations
-enum class Severity { Error, Warning, Portability, Because, Context, None };
+enum class Severity {
+  Error, // fatal error that prevents code and module file generation
+  Warning, // likely problem
+  Portability, // nonstandard or obsolete features
+  Because, // for AttachTo(), explanatory attachment to support another message
+  Context, // (internal): attachment from SetContext()
+  Todo, // a feature that's not yet implemented, a fatal error
+  None // everything else, common for attachments with source locations
+};
 
 class MessageFixedText {
 public:
   constexpr MessageFixedText() {}
   constexpr MessageFixedText(
       const char str[], std::size_t n, Severity severity = Severity::None)
       : text_{str, n}, severity_{severity} {}
   constexpr MessageFixedText(const MessageFixedText &) = default;
   constexpr MessageFixedText(MessageFixedText &&) = default;
   constexpr MessageFixedText &operator=(const MessageFixedText &) = default;
   constexpr MessageFixedText &operator=(MessageFixedText &&) = default;
 
   CharBlock text() const { return text_; }
   Severity severity() const { return severity_; }
   MessageFixedText &set_severity(Severity severity) {
     severity_ = severity;
     return *this;
   }
-  bool isFatal() const { return severity_ == Severity::Error; }
+  bool isFatal() const {
+    return severity_ == Severity::Error || severity_ == Severity::Todo;
+  }
 
 private:
   CharBlock text_;
   Severity severity_{Severity::None};
 };
 
 inline namespace literals {
 constexpr MessageFixedText operator""_err_en_US(
     const char str[], std::size_t n) {
   return MessageFixedText{str, n, Severity::Error};
 }
 constexpr MessageFixedText operator""_warn_en_US(
     const char str[], std::size_t n) {
   return MessageFixedText{str, n, Severity::Warning};
 }
 constexpr MessageFixedText operator""_port_en_US(
     const char str[], std::size_t n) {
   return MessageFixedText{str, n, Severity::Portability};
 }
+constexpr MessageFixedText operator""_todo_en_US(
+    const char str[], std::size_t n) {
+  return MessageFixedText{str, n, Severity::Todo};
+}
 constexpr MessageFixedText operator""_en_US(const char str[], std::size_t n) {
   return MessageFixedText{str, n, Severity::None};
 }
 } // namespace literals
 
 // The construction of a MessageFormattedText uses a MessageFixedText
 // as a vsnprintf() formatting string that is applied to the
 // following arguments.  CharBlock and std::string argument
 // values are also supported; they are automatically converted into
 // char pointers that are suitable for '%s' formatting.
 class MessageFormattedText {
 public:
   template <typename... A>
   MessageFormattedText(const MessageFixedText &text, A &&...x)
       : severity_{text.severity()} {
     Format(&text, Convert(std::forward<A>(x))...);
   }
   MessageFormattedText(const MessageFormattedText &) = default;
   MessageFormattedText(MessageFormattedText &&) = default;
   MessageFormattedText &operator=(const MessageFormattedText &) = default;
   MessageFormattedText &operator=(MessageFormattedText &&) = default;
   const std::string &string() const { return string_; }
-  bool isFatal() const { return severity_ == Severity::Error; }
+  bool isFatal() const {
+    return severity_ == Severity::Error || severity_ == Severity::Todo;
+  }
   Severity severity() const { return severity_; }
   MessageFormattedText &set_severity(Severity severity) {
     severity_ = severity;
     return *this;
   }
   std::string MoveString() { return std::move(string_); }
 
 private:

flang/lib/Parser/message.cpp

return common::visit(
           [](const ProvenanceRange &pr1, const ProvenanceRange &pr2) {
             return pr1.start() < pr2.start();
           },
           [](const ProvenanceRange &, CharBlock) { return true; },
       },
       location_, that.location_);
 }
 
-bool Message::IsFatal() const { return severity() == Severity::Error; }
+bool Message::IsFatal() const {
+  return severity() == Severity::Error || severity() == Severity::Todo;
+}
 
 Severity Message::severity() const {
   return common::visit(
       common::visitors{
           [](const MessageExpectedText &) { return Severity::Error; },
           [](const MessageFixedText &x) { return x.severity(); },
           [](const MessageFormattedText &x) { return x.severity(); },
       },
static std::string Prefix(Severity severity) {
   case Severity::Warning:
     return "warning: ";
   case Severity::Portability:
     return "portability: ";
   case Severity::Because:
     return "because: ";
   case Severity::Context:
     return "in the context: ";
+  case Severity::Todo:
+    return "error: not yet implemented: ";
   case Severity::None:
     break;
   }
   return "";
 }
 
 void Message::Emit(llvm::raw_ostream &o, const AllCookedSources &allCooked,
     bool echoSourceLine) const {

flang/lib/Semantics/expression.cpp

common::visit(
           [&](const parser::AltReturnSpec &label) {
             if (!isSubroutine) {
               context_.Say("alternate return specification may not appear on"
                            " function reference"_err_en_US);
             }
             actual = ActualArgument(label.v);
           },
           [&](const parser::ActualArg::PercentRef &) {
-            context_.Say(
-                "not yet implemented: %REF() intrinsic for arguments"_err_en_US);
+            context_.Say("%REF() intrinsic for arguments"_todo_en_US);
           },
           [&](const parser::ActualArg::PercentVal &) {
-            context_.Say(
-                "not yet implemetned: %VAL() intrinsic for arguments"_err_en_US);
+            context_.Say("%VAL() intrinsic for arguments"_todo_en_US);
           },
       },
       std::get<parser::ActualArg>(arg.t).u);
   if (actual) {
     if (const auto &argKW{std::get<std::optional<parser::Keyword>>(arg.t)}) {
       actual->set_keyword(argKW->v.source);
     }
     actuals_.emplace_back(std::move(*actual));

flang/lib/Semantics/resolve-names.cpp

public:
   bool Pre(const parser::GenericStmt &);
   void Post(const parser::GenericStmt &);
 
   bool inInterfaceBlock() const;
   bool isGeneric() const;
   bool isAbstract() const;
 
 protected:
-  Symbol &GetGenericSymbol() {
-    return DEREF(genericInfo_.top().symbol);
-  }
+  Symbol &GetGenericSymbol() { return DEREF(genericInfo_.top().symbol); }
   // Add to generic the symbol for the subprogram with the same name
   void CheckGenericProcedures(Symbol &);
 
 private:
   // A new GenericInfo is pushed for each interface block and generic stmt
   struct GenericInfo {
     GenericInfo(bool isInterface, bool isAbstract = false)
         : isInterface{isInterface}, isAbstract{isAbstract} {}
if (!decls.empty()) {
     SetDeclTypeSpec(type);
     Walk(decls);
     EndDecl();
   }
   return false;
 }
 
 bool DeclarationVisitor::Pre(const parser::Union::UnionStmt &) {
-  Say("not yet implemented: support for UNION"_err_en_US); // TODO
+  Say("support for UNION"_todo_en_US); // TODO
   return true;
 }
 
 bool DeclarationVisitor::Pre(const parser::StructureField &x) {
   if (std::holds_alternative<parser::Statement<parser::DataComponentDefStmt>>(
           x.u)) {
     BeginDecl();
   }