[flang] Respect left tab limit with Tn editing after ADVANCE='NO'

[klausler]

Summary

Correct the implementation of non-advancing I/O after some testing
to ensure that T tab edit descriptors are not allowed to back up
into positions of a record prior to where it stood at the beginning
of the I/O statement.

flang/runtime/connection.h

struct ConnectionState : public ConnectionAttributes {
   std::size_t RemainingSpaceInRecord() const;
   bool NeedAdvance(std::size_t) const;
   void HandleAbsolutePosition(std::int64_t);
   void HandleRelativePosition(std::int64_t);
 
   void BeginRecord() {
     positionInRecord = 0;
     furthestPositionInRecord = 0;
-    leftTabLimit.reset();
   }
 
   std::optional<std::int64_t> EffectiveRecordLength() const {
     // When an input record is longer than an explicit RECL= from OPEN
     // it is effectively truncated on input.
     return openRecl && recordLength && *openRecl < *recordLength ? openRecl
                                                                  : recordLength;
   }

flang/runtime/io-stmt.h

 
 class ExternalIoStatementBase : public IoStatementBase {
 public:
   ExternalIoStatementBase(
       ExternalFileUnit &, const char *sourceFile = nullptr, int sourceLine = 0);
   ExternalFileUnit &unit() { return unit_; }
   MutableModes &mutableModes();
   ConnectionState &GetConnectionState();
-  void CompleteOperation();
   int EndIoStatement();
   ExternalFileUnit *GetExternalFileUnit() const { return &unit_; }
 
 private:
   ExternalFileUnit &unit_;
 };
 
 template <Direction DIR>

flang/runtime/io-stmt.cpp

 ExternalIoStatementBase::ExternalIoStatementBase(
     ExternalFileUnit &unit, const char *sourceFile, int sourceLine)
     : IoStatementBase{sourceFile, sourceLine}, unit_{unit} {}
 
 MutableModes &ExternalIoStatementBase::mutableModes() { return unit_.modes; }
 
 ConnectionState &ExternalIoStatementBase::GetConnectionState() { return unit_; }
 
-void ExternalIoStatementBase::CompleteOperation() {
-  if (!completedOperation()) {
-    if (mutableModes().nonAdvancing) {
-      unit_.leftTabLimit = unit_.furthestPositionInRecord;
-    } else {
-      unit_.leftTabLimit.reset();
-    }
-    IoStatementBase::CompleteOperation();
-  }
-}
-
 int ExternalIoStatementBase::EndIoStatement() {
   CompleteOperation();
   auto result{IoStatementBase::EndIoStatement()};
   unit_.EndIoStatement(); // annihilates *this in unit_.u_
   return result;
 }
 
 void OpenStatementState::set_path(const char *path, std::size_t length) {
if (completedOperation()) {
     return;
   }
   if constexpr (DIR == Direction::Input) {
     BeginReadingRecord(); // in case there were no I/O items
     if (!mutableModes().nonAdvancing || GetIoStat() == IostatEor) {
       FinishReadingRecord();
     }
   } else {
-    if (!mutableModes().nonAdvancing) {
+    if (mutableModes().nonAdvancing) {
+      unit().leftTabLimit = unit().furthestPositionInRecord;
+    } else {
+      unit().leftTabLimit.reset();
       unit().AdvanceRecord(*this);
     }
     unit().FlushIfTerminal(*this);
   }
-  return ExternalIoStatementBase::CompleteOperation();
+  return IoStatementBase::CompleteOperation();
 }
 
 template <Direction DIR> int ExternalIoStatementState<DIR>::EndIoStatement() {
   CompleteOperation();
   return ExternalIoStatementBase::EndIoStatement();
 }
 
 template <Direction DIR>
case Backspace:
     break;
   case Endfile:
     ext.Endfile(*this);
     break;
   case Rewind:
     ext.Rewind(*this);
     break;
   }
-  return ExternalIoStatementBase::CompleteOperation();
+  return IoStatementBase::CompleteOperation();
 }
 
 int ExternalMiscIoStatementState::EndIoStatement() {
   CompleteOperation();
   return ExternalIoStatementBase::EndIoStatement();
 }
 
 InquireUnitState::InquireUnitState(

flang/runtime/unit.h

IoStatementState &BeginIoStatement(X &&...xs) {
     io_.emplace(state);
     return *io_;
   }
 
   bool Emit(
       const char *, std::size_t, std::size_t elementBytes, IoErrorHandler &);
   bool Receive(char *, std::size_t, std::size_t elementBytes, IoErrorHandler &);
   std::size_t GetNextInputBytes(const char *&, IoErrorHandler &);
-  void SetLeftTabLimit();
   bool BeginReadingRecord(IoErrorHandler &);
   void FinishReadingRecord(IoErrorHandler &);
   bool AdvanceRecord(IoErrorHandler &);
   void BackspaceRecord(IoErrorHandler &);
   void FlushOutput(IoErrorHandler &);
   void FlushIfTerminal(IoErrorHandler &);
   void Endfile(IoErrorHandler &);
   void Rewind(IoErrorHandler &);

flang/runtime/unit.cpp

if (const char *nl{
         --*recordLength;
       }
       return true;
     }
   }
   return false;
 }
 
-void ExternalFileUnit::SetLeftTabLimit() {
-  leftTabLimit = furthestPositionInRecord;
-  positionInRecord = furthestPositionInRecord;
-}
-
 bool ExternalFileUnit::BeginReadingRecord(IoErrorHandler &handler) {
   RUNTIME_CHECK(handler, direction_ == Direction::Input);
   if (!beganReadingRecord_) {
     beganReadingRecord_ = true;
     if (access == Access::Direct) {
       CheckDirectAccess(handler);
       auto need{static_cast<std::size_t>(recordOffsetInFrame_ + *openRecl)};
       auto got{ReadFrame(frameOffsetInFile_, need, handler)};