[flang][runtime] Support DT edit descriptor in result of READ(SIZE=)

[klausler]

Summary

When a formatted I/O READ statement processes a DT edit descriptor to call a
user-defined I/O subroutine to read a derived type data item, all of the
characters that that subroutine reads via child I/O count as charecters
read by an edit descriptor and should accumulate in the result returned
by a SIZE= item in the original READ statement's control list.

[clementval]

LGTM

flang/runtime/connection.h

std::optional<std::int64_t> EffectiveRecordLength() const {
     return openRecl && recordLength && *openRecl < *recordLength ? openRecl
                                                                  : recordLength;
   }
 
   std::optional<std::int64_t> recordLength;
 
   std::int64_t currentRecordNumber{1}; // 1 is first
 
-  // positionInRecord is the 0-based bytes offset in the current recurd
+  // positionInRecord is the 0-based bytes offset in the current record
   // to/from which the next data transfer will occur.  It can be past
   // furthestPositionInRecord if moved by an X or T or TR control edit
   // descriptor.
   std::int64_t positionInRecord{0};
 
   // furthestPositionInRecord is the 0-based byte offset of the greatest
   // position in the current record to/from which any data transfer has
   // occurred, plus one.  It can be viewed as a count of bytes processed.

flang/runtime/descriptor-io.cpp

if (!external) {
       // Create a new unit to service defined I/O for an
       // internal I/O parent.
       external = &ExternalFileUnit::NewUnit(handler, true);
     }
     ChildIo &child{external->PushChildIo(io)};
     int unit{external->unitNumber()};
     int ioStat{IostatOk};
     char ioMsg[100];
+    std::optional<std::int64_t> startPos;
+    if (edit.descriptor == DataEdit::DefinedDerivedType &&
+        special.which() == typeInfo::SpecialBinding::Which::ReadFormatted) {
+      // DT is an edit descriptor so everything that the child
+      // I/O subroutine reads counts towards READ(SIZE=).
+      startPos = io.InquirePos();
+    }
     if (special.IsArgDescriptor(0)) {
       auto *p{special.GetProc<void (*)(const Descriptor &, int &, char *,
           const Descriptor &, int &, char *, std::size_t, std::size_t)>()};
       p(descriptor, unit, ioType, vListDesc, ioStat, ioMsg, ioTypeLen,
           sizeof ioMsg);
     } else {
       auto *p{special.GetProc<void (*)(const void *, int &, char *,
           const Descriptor &, int &, char *, std::size_t, std::size_t)>()};
       p(descriptor.raw().base_addr, unit, ioType, vListDesc, ioStat, ioMsg,
           ioTypeLen, sizeof ioMsg);
     }
     handler.Forward(ioStat, ioMsg, sizeof ioMsg);
     external->PopChildIo(child);
     if (!actualExternal) {
       // Close unit created for internal I/O above.
       auto *closing{external->LookUpForClose(external->unitNumber())};
       RUNTIME_CHECK(handler, external == closing);
       external->DestroyClosed();
     }
+    if (startPos) {
+      io.GotChar(io.InquirePos() - *startPos);
+    }
     return handler.GetIoStat() == IostatOk;
   } else {
     // There's a user-defined I/O subroutine, but there's a FORMAT present and
     // it does not have a DT data edit descriptor, so apply default formatting
     // to the components of the derived type as usual.
     return std::nullopt;
   }
 }

flang/runtime/internal-unit.h

public:
   InternalDescriptorUnit(Scalar, std::size_t chars, int kind);
   InternalDescriptorUnit(const Descriptor &, const Terminator &);
   void EndIoStatement();
 
   bool Emit(const char *, std::size_t, IoErrorHandler &);
   std::size_t GetNextInputBytes(const char *&, IoErrorHandler &);
   bool AdvanceRecord(IoErrorHandler &);
   void BackspaceRecord(IoErrorHandler &);
+  std::int64_t InquirePos();
 
 private:
   Descriptor &descriptor() { return staticDescriptor_.descriptor(); }
   const Descriptor &descriptor() const {
     return staticDescriptor_.descriptor();
   }
   Scalar CurrentRecord() const {
     return descriptor().template ZeroBasedIndexedElement<char>(

flang/runtime/internal-unit.cpp

 
 template <Direction DIR>
 void InternalDescriptorUnit<DIR>::BackspaceRecord(IoErrorHandler &handler) {
   RUNTIME_CHECK(handler, currentRecordNumber > 1);
   --currentRecordNumber;
   BeginRecord();
 }
 
+template <Direction DIR>
+std::int64_t InternalDescriptorUnit<DIR>::InquirePos() {
+  return (currentRecordNumber - 1) * recordLength.value_or(0) +
+      positionInRecord + 1;
+}
+
 template class InternalDescriptorUnit<Direction::Output>;
 template class InternalDescriptorUnit<Direction::Input>;
 } // namespace Fortran::runtime::io

flang/runtime/io-stmt.h

public:
   std::optional<DataEdit> GetNextDataEdit(int maxRepeat = 1);
   ExternalFileUnit *GetExternalFileUnit() const; // null if internal unit
   bool BeginReadingRecord();
   void FinishReadingRecord();
   bool Inquire(InquiryKeywordHash, char *, std::size_t);
   bool Inquire(InquiryKeywordHash, bool &);
   bool Inquire(InquiryKeywordHash, std::int64_t, bool &); // PENDING=
   bool Inquire(InquiryKeywordHash, std::int64_t &);
+  std::int64_t InquirePos();
   void GotChar(signed int = 1); // for READ(SIZE=); can be <0
 
   MutableModes &mutableModes();
   ConnectionState &GetConnectionState();
   IoErrorHandler &GetIoErrorHandler() const;
 
   // N.B.: this also works with base classes
   template <typename A> A *get_if() const {
std::optional<DataEdit> GetNextDataEdit(
       IoStatementState &, int maxRepeat = 1);
   ExternalFileUnit *GetExternalFileUnit() const;
   bool BeginReadingRecord();
   void FinishReadingRecord();
   bool Inquire(InquiryKeywordHash, char *, std::size_t);
   bool Inquire(InquiryKeywordHash, bool &);
   bool Inquire(InquiryKeywordHash, std::int64_t, bool &);
   bool Inquire(InquiryKeywordHash, std::int64_t &);
+  std::int64_t InquirePos();
 
   void BadInquiryKeywordHashCrash(InquiryKeywordHash);
 
 protected:
   bool completedOperation_{false};
 };
 
 // Common state for list-directed & NAMELIST I/O, both internal & external
public:
   bool Emit(const char *data, std::size_t bytes, std::size_t elementBytes = 0);
   std::size_t GetNextInputBytes(const char *&);
   bool AdvanceRecord(int = 1);
   void BackspaceRecord();
   ConnectionState &GetConnectionState() { return unit_; }
   MutableModes &mutableModes() { return unit_.modes; }
   void HandleRelativePosition(std::int64_t);
   void HandleAbsolutePosition(std::int64_t);
+  std::int64_t InquirePos();
 
 protected:
   bool free_{true};
   InternalDescriptorUnit<DIR> unit_;
 };
 
 template <Direction DIR, typename CHAR>
 class InternalFormattedIoStatementState
ExternalIoStatementBase(
       ExternalFileUnit &, const char *sourceFile = nullptr, int sourceLine = 0);
   ExternalFileUnit &unit() { return unit_; }
   MutableModes &mutableModes();
   ConnectionState &GetConnectionState();
   int asynchronousID() const { return asynchronousID_; }
   int EndIoStatement();
   ExternalFileUnit *GetExternalFileUnit() const { return &unit_; }
   void SetAsynchronous();
+  std::int64_t InquirePos();
 
 private:
   ExternalFileUnit &unit_;
   int asynchronousID_{-1};
 };
 
 template <Direction DIR>
 class ExternalIoStatementState : public ExternalIoStatementBase,
class ChildIoStatementState : public IoStatementBase,
                               public IoDirectionState<DIR> {
 public:
   ChildIoStatementState(
       ChildIo &, const char *sourceFile = nullptr, int sourceLine = 0);
   ChildIo &child() { return child_; }
   MutableModes &mutableModes();
   ConnectionState &GetConnectionState();
   ExternalFileUnit *GetExternalFileUnit() const;
-  void CompleteOperation();
   int EndIoStatement();
   bool Emit(const char *, std::size_t bytes, std::size_t elementBytes = 0);
   std::size_t GetNextInputBytes(const char *&);
   void HandleRelativePosition(std::int64_t);
   void HandleAbsolutePosition(std::int64_t);
 
 private:
   ChildIo &child_;

flang/runtime/io-stmt.cpp

 bool IoStatementBase::Inquire(InquiryKeywordHash, std::int64_t, bool &) {
   return false;
 }
 
 bool IoStatementBase::Inquire(InquiryKeywordHash, std::int64_t &) {
   return false;
 }
 
+std::int64_t IoStatementBase::InquirePos() { return 0; }
+
 void IoStatementBase::BadInquiryKeywordHashCrash(InquiryKeywordHash inquiry) {
   char buffer[16];
   const char *decode{InquiryKeywordHashDecode(buffer, sizeof buffer, inquiry)};
   Crash("Bad InquiryKeywordHash 0x%x (%s)", inquiry,
       decode ? decode : "(cannot decode)");
 }
 
 template <Direction DIR>
void InternalIoStatementState<DIR>::HandleAbsolutePosition(std::int64_t n) {
   return unit_.HandleAbsolutePosition(n);
 }
 
 template <Direction DIR>
 void InternalIoStatementState<DIR>::HandleRelativePosition(std::int64_t n) {
   return unit_.HandleRelativePosition(n);
 }
 
+template <Direction DIR>
+std::int64_t InternalIoStatementState<DIR>::InquirePos() {
+  return unit_.InquirePos();
+}
+
 template <Direction DIR, typename CHAR>
 InternalFormattedIoStatementState<DIR, CHAR>::InternalFormattedIoStatementState(
     Buffer buffer, std::size_t length, const CharType *format,
     std::size_t formatLength, const Descriptor *formatDescriptor,
     const char *sourceFile, int sourceLine)
     : InternalIoStatementState<DIR>{buffer, length, sourceFile, sourceLine},
       ioStatementState_{*this}, format_{*this, format, formatLength,
                                     formatDescriptor} {}
int ExternalIoStatementBase::EndIoStatement() {
   unit_.EndIoStatement(); // annihilates *this in unit_.u_
   return result;
 }
 
 void ExternalIoStatementBase::SetAsynchronous() {
   asynchronousID_ = unit().GetAsynchronousId(*this);
 }
 
+std::int64_t ExternalIoStatementBase::InquirePos() {
+  return unit_.InquirePos();
+}
+
 void OpenStatementState::set_path(const char *path, std::size_t length) {
   pathLength_ = TrimTrailingSpaces(path, length);
   path_ = SaveDefaultCharacter(path, pathLength_, *this);
 }
 
 void OpenStatementState::CompleteOperation() {
   if (completedOperation()) {
     return;
return common::visit(
       [&](auto &x) { return x.get().Inquire(inquiry, id, out); }, u_);
 }
 
 bool IoStatementState::Inquire(InquiryKeywordHash inquiry, std::int64_t &n) {
   return common::visit(
       [&](auto &x) { return x.get().Inquire(inquiry, n); }, u_);
 }
 
+std::int64_t IoStatementState::InquirePos() {
+  return common::visit([&](auto &x) { return x.get().InquirePos(); }, u_);
+}
+
 void IoStatementState::GotChar(int n) {
   if (auto *formattedIn{
           get_if<FormattedIoStatementState<Direction::Input>>()}) {
     formattedIn->GotChar(n);
   } else {
     GetIoErrorHandler().Crash("IoStatementState::GotChar() called for "
                               "statement that is not formatted input");
   }
ConnectionState &ChildIoStatementState<DIR>::GetConnectionState() {
   return child_.parent().GetConnectionState();
 }
 
 template <Direction DIR>
 ExternalFileUnit *ChildIoStatementState<DIR>::GetExternalFileUnit() const {
   return child_.parent().GetExternalFileUnit();
 }
 
-template <Direction DIR> void ChildIoStatementState<DIR>::CompleteOperation() {
-  IoStatementBase::CompleteOperation();
-}
-
 template <Direction DIR> int ChildIoStatementState<DIR>::EndIoStatement() {
   CompleteOperation();
   auto result{IoStatementBase::EndIoStatement()};
   child_.EndIoStatement(); // annihilates *this in child_.u_
   return result;
 }
 
 template <Direction DIR>