[flang][runtime] Don't do partial data transfer on short character read with ADVANCE='NO', PAD='NO'

[klausler]

Summary

When a non-advancing formatted READ can't completely fill a CHARACTER
input item with data, and PAD='NO', don't modify the variable at all.
This matters when the error is recoverable.

Fixes https://github.com/llvm/llvm-project/issues/63772

[vzakhari]

LGTM

flang/runtime/edit-input.cpp

bool EditCharacterInput(
   }
   const ConnectionState &connection{io.GetConnectionState()};
   std::size_t remaining{length};
   if (edit.width && *edit.width > 0) {
     remaining = *edit.width;
   }
   // When the field is wider than the variable, we drop the leading
   // characters.  When the variable is wider than the field, there can be
-  // trailing padding.
+  // trailing padding or an EOR condition.
   const char *input{nullptr};
   std::size_t ready{0};
   // Skip leading bytes.
   // These bytes don't count towards INQUIRE(IOLENGTH=).
   std::size_t skip{remaining > length ? remaining - length : 0};
   // Transfer payload bytes; these do count.
   while (remaining > 0) {
     if (ready == 0) {
       ready = io.GetNextInputBytes(input);
+      if (ready == 0 || (ready < remaining && edit.modes.nonAdvancing)) {
+        if (io.CheckForEndOfRecord(ready)) {
           if (ready == 0) {
-        if (io.CheckForEndOfRecord()) {
-          std::fill_n(x, length, ' '); // PAD='YES'
+            // PAD='YES' and no more data
+            std::fill_n(x, length, ' ');
+            return !io.GetIoErrorHandler().InError();
+          } else {
+            // Do partial read(s) then pad on last iteration
           }
+        } else {
           return !io.GetIoErrorHandler().InError();
         }
       }
+    }
     std::size_t chunk;
     bool skipping{skip > 0};
     if (connection.isUTF8) {
       chunk = MeasureUTF8Bytes(*input);
       if (skipping) {
         --skip;
       } else if (auto ucs{DecodeUTF8(input)}) {
         *x++ = *ucs;

flang/runtime/io-stmt.h

public:
 
   // Acquires the next input character, respecting any applicable field width
   // or separator character.
   std::optional<char32_t> NextInField(
       std::optional<int> &remaining, const DataEdit &);
 
   // Detect and signal any end-of-record condition after input.
   // Returns true if at EOR and remaining input should be padded with blanks.
-  bool CheckForEndOfRecord();
+  bool CheckForEndOfRecord(std::size_t afterReading);
 
   // Skips spaces, advances records, and ignores NAMELIST comments
   std::optional<char32_t> GetNextNonBlank(std::size_t &byteCount) {
     auto ch{GetCurrentChar(byteCount)};
     bool inNamelist{mutableModes().inNamelist};
     while (!ch || *ch == ' ' || *ch == '\t' || (inNamelist && *ch == '!')) {
       if (ch && (*ch == ' ' || *ch == '\t')) {
         HandleRelativePosition(byteCount);

flang/runtime/io-stmt.cpp

if (auto next{GetCurrentChar(byteCount)}) {
       if (byteCount > static_cast<std::size_t>(*remaining)) {
         return std::nullopt;
       }
       *remaining -= byteCount;
       HandleRelativePosition(byteCount);
       GotChar(byteCount);
       return next;
     }
-    if (CheckForEndOfRecord()) { // do padding
+    if (CheckForEndOfRecord(0)) { // do padding
       --*remaining;
       return std::optional<char32_t>{' '};
     }
   }
   return std::nullopt;
 }
 
-bool IoStatementState::CheckForEndOfRecord() {
+bool IoStatementState::CheckForEndOfRecord(std::size_t afterReading) {
   const ConnectionState &connection{GetConnectionState()};
   if (!connection.IsAtEOF()) {
     if (auto length{connection.EffectiveRecordLength()}) {
-      if (connection.positionInRecord >= *length) {
+      if (connection.positionInRecord +
+              static_cast<std::int64_t>(afterReading) >=
+          *length) {
         IoErrorHandler &handler{GetIoErrorHandler()};
         const auto &modes{mutableModes()};
         if (modes.nonAdvancing) {
           if (connection.access == Access::Stream &&
               connection.unterminatedRecord) {
             // Reading final unterminated record left by a
             // non-advancing WRITE on a stream file prior to
             // positioning or ENDFILE.

flang/unittests/Runtime/ExternalIOTest.cpp

TEST(ExternalIOTests, TestNonAvancingInput) {
   // REWIND(UNIT=unit)
   io = IONAME(BeginRewind)(unit, __FILE__, __LINE__);
   ASSERT_EQ(IONAME(EndIoStatement)(io), IostatOk)
       << "EndIoStatement() for Rewind";
 
   struct TestItems {
     std::string item;
     int expectedIoStat;
-    std::string expectedItemValue;
+    std::string expectedItemValue[2];
   };
   // Actual non advancing input IO test
   TestItems inputItems[]{
-      {std::string(4, '+'), IostatOk, "ABCD"},
-      {std::string(4, '+'), IostatOk, "EFGH"},
-      {std::string(4, '+'), IostatEor, "    "},
-      {std::string(2, '+'), IostatOk, "IJ"},
-      {std::string(8, '+'), IostatEor, "KLMNOP  "},
-      {std::string(10, '+'), IostatEor, "QRSTUVWX  "},
+      {std::string(4, '+'), IostatOk, "ABCD", "ABCD"},
+      {std::string(4, '+'), IostatOk, "EFGH", "EFGH"},
+      {std::string(4, '+'), IostatEor, "++++", "    "},
+      {std::string(2, '+'), IostatOk, "IJ", "IJ"},
+      {std::string(8, '+'), IostatEor, "++++++++", "KLMNOP  "},
+      {std::string(10, '+'), IostatEor, "++++++++++", "QRSTUVWX  "},
   };
 
+  // Test with PAD='NO'
   int j{0};
   for (auto &inputItem : inputItems) {
-    // READ(UNIT=unit, FMT=fmt, ADVANCE='NO', IOSTAT=iostat) inputItem
+    // READ(UNIT=unit, FMT=fmt, ADVANCE='NO', PAD='NO', IOSTAT=iostat) inputItem
     io = IONAME(BeginExternalFormattedInput)(
         fmt.data(), fmt.length(), nullptr, unit, __FILE__, __LINE__);
     IONAME(EnableHandlers)(io, true, false, false, false, false);
     ASSERT_TRUE(IONAME(SetAdvance)(io, "NO", 2)) << "SetAdvance(NO)" << j;
+    ASSERT_TRUE(IONAME(SetPad)(io, "NO", 2)) << "SetPad(NO)" << j;
     bool result{
         IONAME(InputAscii)(io, inputItem.item.data(), inputItem.item.length())};
     ASSERT_EQ(result, inputItem.expectedIoStat == IostatOk)
         << "InputAscii() " << j;
     ASSERT_EQ(IONAME(EndIoStatement)(io), inputItem.expectedIoStat)
         << "EndIoStatement() for Read " << j;
-    ASSERT_EQ(inputItem.item, inputItem.expectedItemValue)
+    ASSERT_EQ(inputItem.item, inputItem.expectedItemValue[0])
+        << "Input-item value after non advancing read " << j;
+    j++;
+  }
+
+  // REWIND(UNIT=unit)
+  io = IONAME(BeginRewind)(unit, __FILE__, __LINE__);
+  ASSERT_EQ(IONAME(EndIoStatement)(io), IostatOk)
+      << "EndIoStatement() for Rewind";
+
+  // Test again with PAD='YES'
+  j = 0;
+  for (auto &inputItem : inputItems) {
+    // READ(UNIT=unit, FMT=fmt, ADVANCE='NO', PAD='YES', IOSTAT=iostat)
+    // inputItem
+    io = IONAME(BeginExternalFormattedInput)(
+        fmt.data(), fmt.length(), nullptr, unit, __FILE__, __LINE__);
+    IONAME(EnableHandlers)(io, true, false, false, false, false);
+    ASSERT_TRUE(IONAME(SetAdvance)(io, "NO", 2)) << "SetAdvance(NO)" << j;
+    ASSERT_TRUE(IONAME(SetPad)(io, "YES", 3)) << "SetPad(YES)" << j;
+    bool result{
+        IONAME(InputAscii)(io, inputItem.item.data(), inputItem.item.length())};
+    ASSERT_EQ(result, inputItem.expectedIoStat == IostatOk)
+        << "InputAscii() " << j;
+    ASSERT_EQ(IONAME(EndIoStatement)(io), inputItem.expectedIoStat)
+        << "EndIoStatement() for Read " << j;
+    ASSERT_EQ(inputItem.item, inputItem.expectedItemValue[1])
         << "Input-item value after non advancing read " << j;
     j++;
   }
+
   // CLOSE(UNIT=unit)
   io = IONAME(BeginClose)(unit, __FILE__, __LINE__);
   ASSERT_EQ(IONAME(EndIoStatement)(io), IostatOk)
       << "EndIoStatement() for Close";
 }
 
 TEST(ExternalIOTests, TestWriteAfterNonAvancingInput) {
   // OPEN(NEWUNIT=unit,ACCESS='SEQUENTIAL',ACTION='READWRITE',&