[flang] Make not yet implemented messages more consistent

[PeteSteinfeld]

Summary

To make it easier to find things that are not yet implemented, I'm changing the
messages that appear in the compiler's output to all have the string "not yet
implemented:".

These changes apply to files in the front end. I have another set of changes
to files in the lowering code.

[klausler]

You might consider adding a new "_todo_en_US" message class and emitting the "not yet implemented: " prefix in the message emission code. That would ease future rewordings and also make grepping the source for TODO less susceptible to line breaks by clang-format.

flang/lib/Semantics/resolve-names.cpp

3312

It looks like you're erasing a recent fix of mine from resolve-names.cpp here.

3415

And here.

4724

Are you consistently retaining or discarding the TODO comments on or near these messages?

7332–7338

Here's another fix that you're reverting; please retain it.

[PeteSteinfeld]

flang/lib/Semantics/resolve-names.cpp

3312

Oops. I mistakenly based these changes on the file in fir-dev. I'll fix it up.

3415

Same here.

4724

I'm not doing anything with the comments in the code. I'm just changing the user facing messages.

7332–7338

Will do.

[PeteSteinfeld]

Responding to Peter's comments.

[PeteSteinfeld]

In D122355#3404021, @klausler wrote:

You might consider adding a new "_todo_en_US" message class and emitting the "not yet implemented: " prefix in the message emission code. That would ease future rewordings and also make grepping the source for TODO less susceptible to line breaks by clang-format.

That seems reasonable. I'd like to do that in a future patch, though.

[klausler]

I can approve this patch when the build failure is resolved.

[PeteSteinfeld]

Fixing the formatting in an attempt to make the buildbots happy.

[klausler]

Feel free to land the patch when the builds are clean.

flang/lib/Semantics/expression.cpp

return std::visit(
         }
       },
       proc.details());
 }
 
 static int GetPassIndex(const Symbol &proc) {
   CHECK(!proc.attrs().test(semantics::Attr::NOPASS));
   std::optional<parser::CharBlock> passName{GetPassName(proc)};
-  const auto *interface{semantics::FindInterface(proc)};
+  const auto *interface { semantics::FindInterface(proc) };
   if (!passName || !interface) {
     return 0; // first argument is passed-object
   }
   const auto &subp{interface->get<semantics::SubprogramDetails>()};
   int index{0};
   for (const auto *arg : subp.dummyArgs()) {
     if (arg && arg->name() == passName) {
       return index;

 }
 
 void ArgumentAnalyzer::Analyze(
     const parser::ActualArgSpec &arg, bool isSubroutine) {
   // TODO: Actual arguments that are procedures and procedure pointers need to
   // be detected and represented (they're not expressions).
   // TODO: C1534: Don't allow a "restricted" specific intrinsic to be passed.
   std::optional<ActualArgument> actual;
-  std::visit(common::visitors{
-                 [&](const common::Indirection<parser::Expr> &x) {
-                   actual = AnalyzeExpr(x.value());
-                   SetArgSourceLocation(actual, x.value().source);
-                 },
-                 [&](const parser::AltReturnSpec &label) {
-                   if (!isSubroutine) {
-                     context_.Say(
-                         "alternate return specification may not appear on"
+  std::visit(
+      common::visitors{
+              context_.Say("alternate return specification may not appear on"
                            " function reference"_err_en_US);
-                   }
-                   actual = ActualArgument(label.v);
-                 },
-                 [&](const parser::ActualArg::PercentRef &) {
-                   context_.Say("TODO: %REF() argument"_err_en_US);
-                 },
-                 [&](const parser::ActualArg::PercentVal &) {
-                   context_.Say("TODO: %VAL() argument"_err_en_US);
-                 },
-             },
+            context_.Say(
+                "not yet implemented: %REF() intrinsic for arguments"_err_en_US);
+            context_.Say(
+                "not yet implemetned: %VAL() intrinsic for arguments"_err_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));
   } else {
     fatalErrors_ = true;

flang/lib/Semantics/resolve-names.cpp

void SubprogramVisitor::Post(const parser::EntryStmt &stmt) {
   Symbol *entrySymbol{&MakeSymbol(outer, name.source, attrs)};
   if (auto *generic{entrySymbol->detailsIf<GenericDetails>()}) {
     CHECK(generic->specific());
     entrySymbol = generic->specific();
   }
   entrySymbol->set_details(std::move(entryDetails));
   SetBindNameOn(*entrySymbol);
   entrySymbol->set(subpFlag);
   Resolve(name, *entrySymbol);
 }
 
 // A subprogram declared with MODULE PROCEDURE
 bool SubprogramVisitor::BeginMpSubprogram(const parser::Name &name) {
   auto *symbol{FindSymbol(name)};
   if (symbol && symbol->has<SubprogramNameDetails>()) {
     symbol = FindSymbol(currScope().parent(), name);
   }
bool SubprogramVisitor::HandlePreviousCalls(
     const parser::Name &name, Symbol &symbol, Symbol::Flag subpFlag) {
   // If the extant symbol is a generic, check its homonymous specific
   // procedure instead if it has one.
   if (auto *generic{symbol.detailsIf<GenericDetails>()}) {
     return generic->specific() &&
         HandlePreviousCalls(name, *generic->specific(), subpFlag);
   } else if (const auto *proc{symbol.detailsIf<ProcEntityDetails>()}; proc &&
              !proc->isDummy() &&
              !symbol.attrs().HasAny(Attrs{Attr::INTRINSIC, Attr::POINTER})) {
     // There's a symbol created for previous calls to this subprogram or
     // ENTRY's name.  We have to replace that symbol in situ to avoid the
     // obligation to rewrite symbol pointers in the parse tree.
     if (!symbol.test(subpFlag)) {
       Say2(name,
           subpFlag == Symbol::Flag::Function
               ? "'%s' was previously called as a subroutine"_err_en_US
               : "'%s' was previously called as a function"_err_en_US,
if (!decls.empty()) {
     SetDeclTypeSpec(type);
     Walk(decls);
     EndDecl();
   }
   return false;
 }
 
 bool DeclarationVisitor::Pre(const parser::Union::UnionStmt &) {
-  Say("UNION is not yet supported"_err_en_US); // TODO
+  Say("not yet implemented: support for UNION"_err_en_US); // TODO
   return true;
 }
 
 bool DeclarationVisitor::Pre(const parser::StructureField &x) {
   if (std::holds_alternative<parser::Statement<parser::DataComponentDefStmt>>(
           x.u)) {
     BeginDecl();
   }
bool ResolveNames(
   ResolveNamesVisitor{context, implicitRulesMap, top}.Walk(program);
   return !context.AnyFatalError();
 }
 
 // Processes a module (but not internal) function when it is referenced
 // in a specification expression in a sibling procedure.
 void ResolveSpecificationParts(
     SemanticsContext &context, const Symbol &subprogram) {
   auto originalLocation{context.location()};
   ImplicitRulesMap implicitRulesMap;
   bool localImplicitRulesMap{false};
   if (!sharedImplicitRulesMap) {
     sharedImplicitRulesMap = &implicitRulesMap;
     localImplicitRulesMap = true;
   }
   ResolveNamesVisitor visitor{
       context, *sharedImplicitRulesMap, context.globalScope()};
   const auto &details{subprogram.get<SubprogramNameDetails>()};
   ProgramTree &node{details.node()};
   const Scope &moduleScope{subprogram.owner()};
   if (localImplicitRulesMap) {
     visitor.BeginScope(const_cast<Scope &>(moduleScope));
   } else {

flang/runtime/edit-output.cpp

bool RealOutputEditing<binaryPrecision>::EditListDirectedOutput(
   }
   return EditFOutput(edit);
 }
 
 // 13.7.5.2.6 in F'2018
 template <int binaryPrecision>
 bool RealOutputEditing<binaryPrecision>::EditEXOutput(const DataEdit &) {
   io_.GetIoErrorHandler().Crash(
-      "EX output editing is not yet implemented"); // TODO
+      "not yet implemented: EX output editing"); // TODO
 }
 
 template <int KIND> bool RealOutputEditing<KIND>::Edit(const DataEdit &edit) {
   switch (edit.descriptor) {
   case 'D':
     return EditEorDOutput(edit);
   case 'E':
     if (edit.variation == 'X') {

flang/test/Semantics/struct01.f90

 ! RUN: %python %S/test_errors.py %s %flang_fc1
 ! Check for new semantic errors from misuse of the DEC STRUCTURE extension
 program main
   !ERROR: Derived type '/undeclared/' not found
   record /undeclared/ var
   structure /s/
     !ERROR: /s/ is not a known STRUCTURE
     record /s/ attemptToRecurse
-    !ERROR: UNION is not yet supported
+    !ERROR: not yet implemented: support for UNION
     union
       map
         integer j
       end map
       map
         real x
       end map
     end union
   end structure
 end