[flang][runtime] Detect NEWUNIT= without FILE= or STATUS='SCRATCH'

[klausler]

Summary

It is an error to open a new unit with OPEN(NEWUNIT=) and have
neither a file name nor a scratch status. Catch it, and report a
new error code.

[vzakhari]

LGTM

flang/include/flang/Runtime/iostat.h

enum Iostat {
   IostatOpenAlreadyConnected,
   IostatCannotReposition,
   IostatBadWaitId,
   IostatTooManyAsyncOps,
   IostatBadBackspaceUnit,
   IostatBadUnitNumber,
   IostatBadFlushUnit,
   IostatBadOpOnChildUnit,
+  IostatBadNewUnit,
 };
 
 const char *IostatErrorString(int);
 
 } // namespace Fortran::runtime::io
 #endif // FORTRAN_RUNTIME_IOSTAT_H_

flang/runtime/io-api.cpp

Cookie IONAME(BeginOpenUnit)( // OPEN(without NEWUNIT=)
   if (ExternalFileUnit *
       unit{ExternalFileUnit::LookUpOrCreate(
           unitNumber, terminator, wasExtant)}) {
     if (ChildIo * child{unit->GetChildIo()}) {
       return &child->BeginIoStatement<ErroneousIoStatementState>(
           IostatBadOpOnChildUnit, nullptr /* no unit */, sourceFile,
           sourceLine);
     } else {
-      return &unit->BeginIoStatement<OpenStatementState>(
-          terminator, *unit, wasExtant, sourceFile, sourceLine);
+      return &unit->BeginIoStatement<OpenStatementState>(terminator, *unit,
+          wasExtant, false /*not NEWUNIT=*/, sourceFile, sourceLine);
     }
   } else {
     return NoopUnit(terminator, unitNumber, IostatBadUnitNumber);
   }
 }
 
 Cookie IONAME(BeginOpenNewUnit)( // OPEN(NEWUNIT=j)
     const char *sourceFile, int sourceLine) {
   Terminator terminator{sourceFile, sourceLine};
   ExternalFileUnit &unit{
       ExternalFileUnit::NewUnit(terminator, false /*not child I/O*/)};
-  return &unit.BeginIoStatement<OpenStatementState>(
-      terminator, unit, false /*was an existing file*/, sourceFile, sourceLine);
+  return &unit.BeginIoStatement<OpenStatementState>(terminator, unit,
+      false /*was an existing file*/, true /*NEWUNIT=*/, sourceFile,
+      sourceLine);
 }
 
 Cookie IONAME(BeginWait)(ExternalUnit unitNumber, AsynchronousId id,
     const char *sourceFile, int sourceLine) {
   Terminator terminator{sourceFile, sourceLine};
   if (ExternalFileUnit * unit{ExternalFileUnit::LookUp(unitNumber)}) {
     if (unit->Wait(id)) {
       return &unit->BeginIoStatement<ExternalMiscIoStatementState>(terminator,

flang/runtime/io-stmt.h

 public:
   using ChildIoStatementState<DIR>::ChildIoStatementState;
   bool Receive(char *, std::size_t, std::size_t elementBytes = 0);
 };
 
 // OPEN
 class OpenStatementState : public ExternalIoStatementBase {
 public:
-  OpenStatementState(ExternalFileUnit &unit, bool wasExtant,
+  OpenStatementState(ExternalFileUnit &unit, bool wasExtant, bool isNewUnit,
       const char *sourceFile = nullptr, int sourceLine = 0)
-      : ExternalIoStatementBase{unit, sourceFile, sourceLine}, wasExtant_{
-                                                                   wasExtant} {}
+      : ExternalIoStatementBase{unit, sourceFile, sourceLine},
+        wasExtant_{wasExtant}, isNewUnit_{isNewUnit} {}
   bool wasExtant() const { return wasExtant_; }
   void set_status(OpenStatus status) { status_ = status; } // STATUS=
   void set_path(const char *, std::size_t); // FILE=
   void set_position(Position position) { position_ = position; } // POSITION=
   void set_action(Action action) { action_ = action; } // ACTION=
   void set_convert(Convert convert) { convert_ = convert; } // CONVERT=
   void set_access(Access access) { access_ = access; } // ACCESS=
   void set_isUnformatted(bool yes = true) { isUnformatted_ = yes; } // FORM=
 
   void CompleteOperation();
   int EndIoStatement();
 
 private:
   bool wasExtant_;
+  bool isNewUnit_;
   std::optional<OpenStatus> status_;
   std::optional<Position> position_;
   std::optional<Action> action_;
   Convert convert_{Convert::Unknown};
   OwningPtr<char> path_;
   std::size_t pathLength_;
   std::optional<bool> isUnformatted_;
   std::optional<Access> access_;

flang/runtime/io-stmt.cpp

void OpenStatementState::CompleteOperation() {
   if (status_) { // 12.5.6.10
     if ((*status_ == OpenStatus::New || *status_ == OpenStatus::Replace) &&
         !path_.get()) {
       SignalError("FILE= required on OPEN with STATUS='NEW' or 'REPLACE'");
     } else if (*status_ == OpenStatus::Scratch && path_.get()) {
       SignalError("FILE= may not appear on OPEN with STATUS='SCRATCH'");
     }
   }
+  // F'2023 12.5.6.13 - NEWUNIT= requires either FILE= or STATUS='SCRATCH'
+  if (isNewUnit_ && !path_.get() &&
+      status_.value_or(OpenStatus::Unknown) != OpenStatus::Scratch) {
+    SignalError(IostatBadNewUnit);
+    status_ = OpenStatus::Scratch; // error recovery
+  }
   if (path_.get() || wasExtant_ ||
       (status_ && *status_ == OpenStatus::Scratch)) {
     unit().OpenUnit(status_, action_, position_.value_or(Position::AsIs),
         std::move(path_), pathLength_, convert_, *this);
   } else {
     unit().OpenAnonymousUnit(
         status_, action_, position_.value_or(Position::AsIs), convert_, *this);
   }

flang/runtime/iostat.cpp

const char *IostatErrorString(int iostat) {
   case IostatBadBackspaceUnit:
     return "BACKSPACE on unconnected unit";
   case IostatBadUnitNumber:
     return "Negative unit number is not allowed";
   case IostatBadFlushUnit:
     return "FLUSH attempted on a bad or unconnected unit number";
   case IostatBadOpOnChildUnit:
     return "Impermissible I/O statement on child I/O unit";
+  case IostatBadNewUnit:
+    return "NEWUNIT= without FILE= or STATUS='SCRATCH'";
   default:
     return nullptr;
   }
 }
 
 } // namespace Fortran::runtime::io