[flang] Implement checks for defined input/output procedures

[PeteSteinfeld]

Summary

Defined input/output procedures are specified in 12.6.4.8. There are different
versions for read versus write and formatted versus unformatted, but they all
share the same basic set of dummy arguments.

I added several checking functions to check-declarations.cpp along with a test.

In the process of implementing this, I noticed and fixed a typo in
.../lib/Evaluate/characteristics.cpp.

[klausler]

Looks really good; thanks for figuring all of this out from the standard.

flang/lib/Semantics/check-declarations.cpp

1040

Consider having one call to CheckDefinedIoProc() and using two std::visit() calls to calculate its last two arguments.

1760

Should be nested in the else, I think.

[PeteSteinfeld]

flang/lib/Semantics/check-declarations.cpp

1040

Good suggestion. All of the information is actually inherent in the value of GenericKind::DefinedIo, so I can get everything I need by just passing io to CheckDefinedIoProc(). That simplifies things a lot.

flang/lib/Evaluate/characteristics.cpp

std::visit(common::visitors{
       u);
 }
 
 common::Intent DummyArgument::GetIntent() const {
   return std::visit(common::visitors{
                         [](const DummyDataObject &data) { return data.intent; },
                         [](const DummyProcedure &proc) { return proc.intent; },
                         [](const AlternateReturn &) -> common::Intent {
-                          DIE("Alternate return have no intent");
+                          DIE("Alternate returns have no intent");
                         },
                     },
       u);
 }
 
 bool DummyArgument::CanBePassedViaImplicitInterface() const {
   if (const auto *object{std::get_if<DummyDataObject>(&u)}) {
     return object->CanBePassedViaImplicitInterface();

flang/lib/Semantics/check-declarations.cpp

void SayWithDeclaration(const Symbol &symbol, A &&...x) {
     if (parser::Message * msg{messages_.Say(std::forward<A>(x)...)}) {
       if (messages_.at().begin() != symbol.name().begin()) {
         evaluate::AttachDeclaration(*msg, symbol);
       }
     }
   }
   bool IsResultOkToDiffer(const FunctionResult &);
   void CheckBindCName(const Symbol &);
+  // Check functions for defined I/O procedures
+  ENUM_CLASS(IoDirection, IoRead, IoWrite);
+  ENUM_CLASS(FormatType, Formatted, Unformatted);
+  void CheckDefinedIoProc(
+      const Symbol &, const GenericDetails &, IoDirection, FormatType);
+  bool CheckDioDummyIsData(const Symbol &, const Symbol *, std::size_t);
+  void CheckDioDummyIsDerived(const Symbol &, const Symbol &);
+  void CheckDioDummyIsDefaultInteger(const Symbol &, const Symbol &);
+  void CheckDioDummyIsScalar(const Symbol &, const Symbol &);
+  void CheckDioDummyAttrs(const Symbol &, const Symbol &, Attr);
+  void CheckDioDtvArg(const Symbol &, const Symbol *, IoDirection);
+  void CheckDefaultIntegerArg(const Symbol &, const Symbol *, Attr);
+  void CheckDioAssumedLenCharacterArg(
+      const Symbol &, const Symbol *, std::size_t, Attr);
+  void CheckDioVlistArg(const Symbol &, const Symbol *, std::size_t);
+  void CheckDioArgCount(const Symbol &, FormatType, std::size_t);
 
   SemanticsContext &context_;
   evaluate::FoldingContext &foldingContext_{context_.foldingContext()};
   parser::ContextualMessages &messages_{foldingContext_.messages()};
   const Scope *scope_{nullptr};
   bool scopeIsUninstantiatedPDT_{false};
   // This symbol is the one attached to the innermost enclosing scope
   // that has a symbol.
if (details.isDummy()) {
     if (!symbol.attrs().test(Attr::POINTER) && // C843
         (symbol.attrs().test(Attr::INTENT_IN) ||
             symbol.attrs().test(Attr::INTENT_OUT) ||
             symbol.attrs().test(Attr::INTENT_INOUT))) {
       messages_.Say("A dummy procedure without the POINTER attribute"
                     " may not have an INTENT attribute"_err_en_US);
     }
 
-    const Symbol *interface{details.interface().symbol()};
+    const Symbol *interface { details.interface().symbol() };
     if (!symbol.attrs().test(Attr::INTRINSIC) &&
         (symbol.attrs().test(Attr::ELEMENTAL) ||
             (interface && !interface->attrs().test(Attr::INTRINSIC) &&
                 interface->attrs().test(Attr::ELEMENTAL)))) {
       // There's no explicit constraint or "shall" that we can find in the
       // standard for this check, but it seems to be implied in multiple
       // sites, and ELEMENTAL non-intrinsic actual arguments *are*
       // explicitly forbidden.  But we allow "PROCEDURE(SIN)::dummy"
if (details.implicitOrSpecExprError) {
           "No explicit type declared for '%s'"_err_en_US, symbol.name());
     }
   }
 }
 
 void CheckHelper::CheckGeneric(
     const Symbol &symbol, const GenericDetails &details) {
   CheckSpecificsAreDistinguishable(symbol, details);
+  std::visit(common::visitors{
+                 [&](const GenericKind::DefinedIo &io) {
+                   switch (io) {
+                   case GenericKind::DefinedIo::ReadFormatted:
+                     CheckDefinedIoProc(symbol, details, IoDirection::IoRead,
+                         FormatType::Formatted);
+                     break;
+                   case GenericKind::DefinedIo::ReadUnformatted:
+                     CheckDefinedIoProc(symbol, details, IoDirection::IoRead,
+                         FormatType::Unformatted);
+                     break;
+                   case GenericKind::DefinedIo::WriteFormatted:
+                     CheckDefinedIoProc(symbol, details, IoDirection::IoWrite,
+                         FormatType::Formatted);
+                     break;
+                   case GenericKind::DefinedIo::WriteUnformatted:
+                     CheckDefinedIoProc(symbol, details, IoDirection::IoWrite,
+                         FormatType::Unformatted);
+                     break;
+                   }
+                 },
+                 [](const auto &) {},
+             },
+      details.kind().u);
 }
 
 // Check that the specifics of this generic are distinguishable from each other
 void CheckHelper::CheckSpecificsAreDistinguishable(
     const Symbol &generic, const GenericDetails &details) {
   GenericKind kind{details.kind()};
   const SymbolVector &specifics{details.specificProcs()};
   std::size_t count{specifics.size()};
bool CheckHelper::CheckDefinedAssignmentArg(
   }
   return true;
 }
 
 // Report a conflicting attribute error if symbol has both of these attributes
 bool CheckHelper::CheckConflicting(const Symbol &symbol, Attr a1, Attr a2) {
   if (symbol.attrs().test(a1) && symbol.attrs().test(a2)) {
     messages_.Say("'%s' may not have both the %s and %s attributes"_err_en_US,
-        symbol.name(), EnumToString(a1), EnumToString(a2));
+        symbol.name(), AttrToString(a1), AttrToString(a2));
     return true;
   } else {
     return false;
   }
 }
 
 void CheckHelper::WarnMissingFinal(const Symbol &symbol) {
   const auto *object{symbol.detailsIf<ObjectEntityDetails>()};
if (!pair.second) {
         }
         context_.SetError(symbol);
         context_.SetError(other);
       }
     }
   }
 }
 
+bool CheckHelper::CheckDioDummyIsData(
+    const Symbol &subp, const Symbol *arg, std::size_t position) {
+  if (arg && arg->detailsIf<ObjectEntityDetails>()) {
+    return true;
+  } else {
+    if (arg) {
+      messages_.Say(arg->name(),
+          "Dummy argument '%s' must be a data object"_err_en_US, arg->name());
+    } else {
+      messages_.Say(subp.name(),
+          "Dummy argument %d of '%s' must be a data object"_err_en_US, position,
+          subp.name());
+    }
+  }
+  return false;
+}
+
+void CheckHelper::CheckDioDummyIsDerived(
+    const Symbol &subp, const Symbol &arg) {
+  if (const DeclTypeSpec * type{arg.GetType()}; type && type->AsDerived()) {
+    return;
+  }
+  messages_.Say(arg.name(),
+      "Dummy argument '%s' of a defined input/output procedure must have a"
+      " derived type"_err_en_US,
+      arg.name());
+}
+
+void CheckHelper::CheckDioDummyIsDefaultInteger(
+    const Symbol &subp, const Symbol &arg) {
+  if (const DeclTypeSpec * type{arg.GetType()};
+      type && type->IsNumeric(TypeCategory::Integer)) {
+    if (const auto kind{evaluate::ToInt64(type->numericTypeSpec().kind())};
+        kind && *kind == context_.GetDefaultKind(TypeCategory::Integer)) {
+      return;
+    }
+  }
+  messages_.Say(arg.name(),
+      "Dummy argument '%s' of a defined input/output procedure"
+      " must be an INTEGER of default KIND"_err_en_US,
+      arg.name());
+}
+
+void CheckHelper::CheckDioDummyIsScalar(const Symbol &subp, const Symbol &arg) {
+  if (arg.Rank() > 0 || arg.Corank() > 0) {
+    messages_.Say(arg.name(),
+        "Dummy argument '%s' of a defined input/output procedure"
+        " must be a scalar"_err_en_US,
+        arg.name());
+  }
+}
+
+void CheckHelper::CheckDioDtvArg(
+    const Symbol &subp, const Symbol *arg, IoDirection direction) {
+  // Dtv argument looks like: dtv-type-spec, INTENT(INOUT) :: dtv
+  if (CheckDioDummyIsData(subp, arg, 0)) {
+    CheckDioDummyIsDerived(subp, *arg);
+    CheckDioDummyAttrs(subp, *arg,
+        direction == IoDirection::IoRead ? Attr::INTENT_INOUT
+                                         : Attr::INTENT_IN);
+  }
+}
+
+void CheckHelper::CheckDefaultIntegerArg(
+    const Symbol &subp, const Symbol *arg, Attr intent) {
+  // Argument looks like: INTEGER, INTENT(intent) :: arg
+  if (CheckDioDummyIsData(subp, arg, 1)) {
+    CheckDioDummyIsDefaultInteger(subp, *arg);
+    CheckDioDummyIsScalar(subp, *arg);
+    CheckDioDummyAttrs(subp, *arg, intent);
+  }
+}
+
+void CheckHelper::CheckDioAssumedLenCharacterArg(const Symbol &subp,
+    const Symbol *arg, std::size_t argPosition, Attr intent) {
+  // Argument looks like: CHARACTER (LEN=*), INTENT(intent) :: (iotype OR iomsg)
+  if (CheckDioDummyIsData(subp, arg, argPosition)) {
+    CheckDioDummyAttrs(subp, *arg, intent);
+    if (!IsAssumedLengthCharacter(*arg)) {
+      messages_.Say(arg->name(),
+          "Dummy argument '%s' of a defined input/output procedure"
+          " must be assumed-length CHARACTER"_err_en_US,
+          arg->name());
+    }
+  }
+}
+
+void CheckHelper::CheckDioVlistArg(
+    const Symbol &subp, const Symbol *arg, std::size_t argPosition) {
+  // Vlist argument looks like: INTEGER, INTENT(IN) :: v_list(:)
+  if (CheckDioDummyIsData(subp, arg, argPosition)) {
+    CheckDioDummyIsDefaultInteger(subp, *arg);
+    CheckDioDummyAttrs(subp, *arg, Attr::INTENT_IN);
+    if (const auto *objectDetails{arg->detailsIf<ObjectEntityDetails>()}) {
+      if (objectDetails->shape().IsDeferredShape()) {
+        return;
+      }
+    }
+    messages_.Say(arg->name(),
+        "Dummy argument '%s' of a defined input/output procedure must be"
+        " deferred shape"_err_en_US,
+        arg->name());
+  }
+}
+
+void CheckHelper::CheckDioArgCount(
+    const Symbol &subp, FormatType formatType, std::size_t argCount) {
+  const std::size_t requiredArgCount{
+      (std::size_t)(formatType == FormatType::Formatted ? 6 : 4)};
+  if (argCount != requiredArgCount) {
+    SayWithDeclaration(subp,
+        "Defined input/output procedure '%s' must have"
+        " %d dummy arguments rather than %d"_err_en_US,
+        subp.name(), requiredArgCount, argCount);
+    context_.SetError(subp);
+  }
+}
+
+void CheckHelper::CheckDioDummyAttrs(
+    const Symbol &subp, const Symbol &arg, Attr goodIntent) {
+  // Defined I/O procedures can't have attributes other than INTENT
+  Attrs attrs{arg.attrs()};
+  if (!attrs.test(goodIntent)) {
+    messages_.Say(arg.name(),
+        "Dummy argument '%s' of a defined input/output procedure"
+        " must have intent '%s'"_err_en_US,
+        arg.name(), AttrToString(goodIntent));
+  }
+  attrs = attrs - Attr::INTENT_IN - Attr::INTENT_OUT - Attr::INTENT_INOUT;
+  if (!attrs.empty()) {
+    messages_.Say(arg.name(),
+        "Dummy argument '%s' of a defined input/output procedure may not have"
+        " any attributes"_err_en_US,
+        arg.name());
+  }
+}
+
+// Enforce semantics for defined input/output procedures (12.6.4.8.2) and C777
+void CheckHelper::CheckDefinedIoProc(const Symbol &symbol,
+    const GenericDetails &details, IoDirection direction,
+    FormatType formatType) {
+  for (auto ref : details.specificProcs()) {
+    const auto *binding{ref->detailsIf<ProcBindingDetails>()};
+    const Symbol &specific{*(binding ? &binding->symbol() : &*ref)};
+    if (ref->attrs().test(Attr::NOPASS)) { // C774
+      messages_.Say("Defined input/output procedure '%s' may not have NOPASS "
+                    "attribute"_err_en_US,
+          ref->name());
+      context_.SetError(*ref);
+    }
+    if (const auto *subpDetails{specific.detailsIf<SubprogramDetails>()}) {
+      const std::vector<Symbol *> &dummyArgs{subpDetails->dummyArgs()};
+      CheckDioArgCount(specific, formatType, dummyArgs.size());
+      int argCount{0};
+      for (auto *arg : dummyArgs) {
+        switch (argCount++) {
+        case 0:
+          // dtv-type-spec, INTENT(INOUT) :: dtv
+          CheckDioDtvArg(specific, arg, direction);
+          break;
+        case 1:
+          // INTEGER, INTENT(IN) :: unit
+          CheckDefaultIntegerArg(specific, arg, Attr::INTENT_IN);
+          break;
+        case 2:
+          if (formatType == FormatType::Formatted) {
+            // CHARACTER (LEN=*), INTENT(IN) :: iotype
+            CheckDioAssumedLenCharacterArg(
+                specific, arg, argCount, Attr::INTENT_IN);
+          } else {
+            // INTEGER, INTENT(OUT) :: iostat
+            CheckDefaultIntegerArg(specific, arg, Attr::INTENT_OUT);
+          }
+          break;
+        case 3:
+          if (formatType == FormatType::Formatted) {
+            // INTEGER, INTENT(IN) :: v_list(:)
+            CheckDioVlistArg(specific, arg, argCount);
+          } else {
+            // CHARACTER (LEN=*), INTENT(INOUT) :: iomsg
+            CheckDioAssumedLenCharacterArg(
+                specific, arg, argCount, Attr::INTENT_INOUT);
+          }
+          break;
+        case 4:
+          // INTEGER, INTENT(OUT) :: iostat
+          CheckDefaultIntegerArg(specific, arg, Attr::INTENT_OUT);
+          break;
+        case 5:
+          // CHARACTER (LEN=*), INTENT(INOUT) :: iomsg
+          CheckDioAssumedLenCharacterArg(
+              specific, arg, argCount, Attr::INTENT_INOUT);
+          break;
+        default:;
+        }
+      }
+    }
+  }
+}
+
 void SubprogramMatchHelper::Check(
     const Symbol &symbol1, const Symbol &symbol2) {
   const auto details1{symbol1.get<SubprogramDetails>()};
   const auto details2{symbol2.get<SubprogramDetails>()};
   if (details1.isFunction() != details2.isFunction()) {
     Say(symbol1, symbol2,
         details1.isFunction()
             ? "Module function '%s' was declared as a subroutine in the"
void DistinguishabilityHelper::SayNotDistinguishable(const Scope &scope,
   parser::Message *msg;
   if (scope.sourceRange().Contains(name)) {
     msg = &context_.Say(name,
         "Generic '%s' may not have specific procedures '%s' and"
         " '%s' as their interfaces are not distinguishable"_err_en_US,
         MakeOpName(name), name1, name2);
   } else {
     msg = &context_.Say(*GetTopLevelUnitContaining(proc1).GetName(),
-        "USE-associated generic '%s' may not have specific procedures '%s' and"
+        "USE-associated generic '%s' may not have specific procedures '%s' "
+        "and"
         " '%s' as their interfaces are not distinguishable"_err_en_US,
         MakeOpName(name), name1, name2);
   }
   AttachDeclaration(*msg, scope, proc1);
   AttachDeclaration(*msg, scope, proc2);
 }
 
 // `evaluate::AttachDeclaration` doesn't handle the generic case where `proc`

flang/test/Semantics/io11.f90

+! RUN: %S/test_errors.sh %s %t %flang_fc1
+
+! Tests for defined input/output.  See 12.6.4.8 and 15.4.3.2, and C777
+module m1
+  type,public :: t
+    integer c
+  contains
+    procedure, nopass :: tbp=>formattedReadProc !Error, NOPASS not allowed
+    !ERROR: Defined input/output procedure 'tbp' may not have NOPASS attribute
+    generic :: read(formatted) => tbp
+  end type
+  private
+contains
+  subroutine formattedReadProc(dtv, unit, iotype, vlist, iostat, iomsg)
+    class(t), intent(inout) :: dtv
+    integer, intent(in) :: unit
+    character(len=*), intent(in) :: iotype
+    integer, intent(in) :: vlist(:)
+    integer, intent(out) :: iostat
+    character(len=*), intent(inout) :: iomsg
+
+    iostat = 343
+    stop 'fail'
+  end subroutine
+end module m1
+
+module m2
+  type,public :: t
+    integer c
+  contains
+    procedure, pass :: tbp=>formattedReadProc
+    !ERROR: Defined input/output procedure 'formattedreadproc' must have 6 dummy arguments rather than 5
+    generic :: read(formatted) => tbp
+  end type
+  private
+contains
+  subroutine formattedReadProc(dtv, unit, iotype, vlist, iostat)
+    class(t), intent(inout) :: dtv
+    integer, intent(in) :: unit
+    character(len=*), intent(in) :: iotype
+    integer, intent(in) :: vlist(:)
+    integer, intent(out) :: iostat
+
+    iostat = 343
+    stop 'fail'
+  end subroutine
+end module m2
+
+module m3
+  type,public :: t
+    integer c
+  contains
+    procedure, pass :: tbp=>unformattedReadProc
+    !ERROR: Defined input/output procedure 'unformattedreadproc' must have 4 dummy arguments rather than 5
+    generic :: read(unformatted) => tbp
+  end type
+  private
+contains
+  ! Error bad # of args
+  subroutine unformattedReadProc(dtv, unit, iostat, iomsg, iotype) 
+    class(t), intent(inout) :: dtv
+    integer, intent(in) :: unit
+    integer, intent(out) :: iostat
+    character(len=*), intent(inout) :: iomsg
+    integer, intent(out) :: iotype
+
+    iostat = 343
+    stop 'fail'
+  end subroutine
+end module m3
+
+module m4
+  type,public :: t
+    integer c
+  contains
+    procedure, pass :: tbp=>formattedReadProc
+    generic :: read(formatted) => tbp
+  end type
+  private
+contains
+  !ERROR: Dummy argument 0 of 'formattedreadproc' must be a data object
+  !ERROR: Cannot use an alternate return as the passed-object dummy argument
+  subroutine formattedReadProc(*, unit, iotype, vlist, iostat, iomsg) 
+    !ERROR: Dummy argument 'unit' must be a data object
+    !ERROR: A dummy procedure without the POINTER attribute may not have an INTENT attribute
+    procedure(sin), intent(in) :: unit
+    character(len=*), intent(in) :: iotype
+    integer, intent(in) :: vlist(:)
+    integer, intent(out) :: iostat
+    character(len=*), intent(inout) :: iomsg
+
+    iostat = 343
+    stop 'fail'
+  end subroutine
+end module m4
+
+module m5
+  type,public :: t
+    integer c
+  contains
+    !ERROR: Passed-object dummy argument 'dtv' of procedure 'tbp' must be of type 't' but is 'INTEGER(4)'
+    procedure, pass :: tbp=>formattedReadProc
+    generic :: read(formatted) => tbp
+  end type
+  private
+contains
+  subroutine formattedReadProc(dtv, unit, iotype, vlist, iostat, iomsg)
+    !ERROR: Dummy argument 'dtv' of a defined input/output procedure must have a derived type
+    integer, intent(inout) :: dtv ! error, must be of type t
+    integer, intent(in) :: unit
+    character(len=*), intent(in) :: iotype
+    integer, intent(in) :: vlist(:)
+    integer, intent(out) :: iostat
+    character(len=*), intent(inout) :: iomsg
+
+    iostat = 343
+    stop 'fail'
+  end subroutine
+end module m5
+
+module m6
+  interface read(formatted) 
+    procedure :: formattedReadProc
+  end interface
+
+  contains
+    subroutine formattedReadProc(dtv, unit, iotype, vlist, iostat, iomsg)
+    !ERROR: Dummy argument 'dtv' of a defined input/output procedure must have a derived type
+      integer, intent(inout) :: dtv
+      integer, intent(in) :: unit
+      character(len=*), intent(in) :: iotype ! error, must be deferred
+      integer, intent(in) :: vlist(:)
+      integer, intent(out) :: iostat
+      character(len=*), intent(inout) :: iomsg
+    end subroutine
+end module m6
+
+module m7
+  type,public :: t
+    integer c
+  contains
+    procedure, pass :: tbp=>formattedReadProc
+    generic :: read(formatted) => tbp
+  end type
+  private
+contains
+  subroutine formattedReadProc(dtv, unit, iotype, vlist, iostat, iomsg)
+    !ERROR: Dummy argument 'dtv' of a defined input/output procedure must have intent 'INTENT(INOUT)'
+    class(t), intent(in) :: dtv ! Error, must be intent(inout)
+    integer, intent(in) :: unit
+    character(len=*), intent(in) :: iotype
+    integer, intent(in) :: vlist(:)
+    integer, intent(out) :: iostat
+    character(len=*), intent(inout) :: iomsg
+
+    iostat = 343
+    stop 'fail'
+  end subroutine
+end module m7
+
+module m8
+  type,public :: t
+    integer c
+  contains
+    procedure, pass :: tbp=>formattedWriteProc
+    generic :: write(formatted) => tbp
+  end type
+  private
+contains
+  subroutine formattedWriteProc(dtv, unit, iotype, vlist, iostat, iomsg)
+    !ERROR: Dummy argument 'dtv' of a defined input/output procedure must have intent 'INTENT(IN)'
+    class(t), intent(inout) :: dtv ! Error, must be intent(inout)
+    integer, intent(in) :: unit
+    character(len=*), intent(in) :: iotype
+    integer, intent(in) :: vlist(:)
+    integer, intent(out) :: iostat
+    character(len=*), intent(inout) :: iomsg
+
+    iostat = 343
+    stop 'fail'
+  end subroutine
+end module m8
+
+module m9
+  type,public :: t
+    integer c
+  contains
+    procedure, pass :: tbp=>formattedReadProc
+    generic :: read(formatted) => tbp
+  end type
+  private
+contains
+  subroutine formattedReadProc(dtv, unit, iotype, vlist, iostat, iomsg)
+    class(t), intent(inout) :: dtv ! Error, can't have attributes
+    !ERROR: Dummy argument 'unit' of a defined input/output procedure may not have any attributes
+    integer,  pointer, intent(in) :: unit
+    character(len=*), intent(in) :: iotype
+    integer, intent(in) :: vlist(:) 
+    integer, intent(out) :: iostat
+    character(len=*), intent(inout) :: iomsg
+
+    iostat = 343
+    stop 'fail'
+  end subroutine
+end module m9
+
+module m10
+  type,public :: t
+    integer c
+  contains
+    procedure, pass :: tbp=>formattedReadProc
+    generic :: read(formatted) => tbp
+  end type
+  private
+contains
+  subroutine formattedReadProc(dtv, unit, iotype, vlist, iostat, iomsg)
+    class(t), intent(inout) :: dtv
+    !ERROR: Dummy argument 'unit' of a defined input/output procedure must be an INTEGER of default KIND
+    real, intent(in) :: unit ! Error, must be an integer
+    character(len=*), intent(in) :: iotype
+    integer, intent(in) :: vlist(:)
+    integer, intent(out) :: iostat
+    character(len=*), intent(inout) :: iomsg
+
+    iostat = 343
+    stop 'fail'
+  end subroutine
+end module m10
+
+module m11
+  type,public :: t
+    integer c
+  contains
+    procedure, pass :: tbp=>formattedReadProc
+    generic :: read(formatted) => tbp
+  end type
+  private
+contains
+  subroutine formattedReadProc(dtv, unit, iotype, vlist, iostat, iomsg)
+    class(t), intent(inout) :: dtv
+    !ERROR: Dummy argument 'unit' of a defined input/output procedure must be an INTEGER of default KIND
+    integer(8), intent(in) :: unit ! Error, must be default KIND
+    character(len=*), intent(in) :: iotype
+    integer, intent(in) :: vlist(:)
+    integer, intent(out) :: iostat
+    character(len=*), intent(inout) :: iomsg
+
+    iostat = 343
+    stop 'fail'
+  end subroutine
+end module m11
+
+module m12
+  type,public :: t
+    integer c
+  contains
+    procedure, pass :: tbp=>formattedReadProc
+    generic :: read(formatted) => tbp
+  end type
+  private
+contains
+  subroutine formattedReadProc(dtv, unit, iotype, vlist, iostat, iomsg)
+    class(t), intent(inout) :: dtv
+    !ERROR: Dummy argument 'unit' of a defined input/output procedure must be a scalar
+    integer, dimension(22), intent(in) :: unit ! Error, must be a scalar
+    character(len=*), intent(in) :: iotype
+    integer, intent(in) :: vlist(:)
+    integer, intent(out) :: iostat
+    character(len=*), intent(inout) :: iomsg
+
+    iostat = 343
+    stop 'fail'
+  end subroutine
+end module m12
+
+module m13
+  type,public :: t
+    integer c
+  contains
+    procedure, pass :: tbp=>formattedReadProc
+    generic :: read(formatted) => tbp
+  end type
+  private
+contains
+  subroutine formattedReadProc(dtv, unit, iotype, vlist, iostat, iomsg)
+    class(t), intent(inout) :: dtv
+    !ERROR: Dummy argument 'unit' of a defined input/output procedure must have intent 'INTENT(IN)'
+    integer, intent(out) :: unit !Error, must be intent(in)
+    character(len=*), intent(in) :: iotype
+    integer, intent(in) :: vlist(:)
+    integer, intent(out) :: iostat
+    character(len=*), intent(inout) :: iomsg
+
+    iostat = 343
+    stop 'fail'
+  end subroutine
+end module m13
+
+module m14
+  type,public :: t
+    integer c
+  contains
+    procedure, pass :: tbp=>formattedReadProc
+    generic :: read(formatted) => tbp
+  end type
+  private
+contains
+  subroutine formattedReadProc(dtv, unit, iotype, vlist, iostat, iomsg)
+    class(t), intent(inout) :: dtv
+    !ERROR: Dummy argument 'unit' of a defined input/output procedure must have intent 'INTENT(IN)'
+    integer :: unit !Error, must be INTENT(IN)
+    character(len=*), intent(in) :: iotype
+    integer, intent(in) :: vlist(:)
+    integer, intent(out) :: iostat
+    character(len=*), intent(inout) :: iomsg
+
+    iostat = 343
+    stop 'fail'
+  end subroutine
+end module m14
+
+module m15
+  type,public :: t
+    integer c
+  contains
+    procedure, pass :: tbp=>formattedReadProc
+    generic :: read(formatted) => tbp
+  end type
+  private
+contains
+  subroutine formattedReadProc(dtv, unit, iotype, vlist, iostat, iomsg)
+    class(t), intent(inout) :: dtv
+    integer, intent(in) :: unit
+    !ERROR: Dummy argument 'iotype' of a defined input/output procedure must be assumed-length CHARACTER
+    character(len=5), intent(in) :: iotype ! Error, must be assumed length
+    integer, intent(in) :: vlist(:)
+    integer, intent(out) :: iostat
+    character(len=*), intent(inout) :: iomsg
+
+    iostat = 343
+    stop 'fail'
+  end subroutine
+end module m15
+
+module m16
+  type,public :: t
+    integer c
+  contains
+    procedure, pass :: tbp=>formattedReadProc
+    generic :: read(formatted) => tbp
+  end type
+  private
+contains
+  subroutine formattedReadProc(dtv, unit, iotype, vlist, iostat, iomsg)
+    class(t), intent(inout) :: dtv
+    integer, intent(in) :: unit
+    character(len=*), intent(in) :: iotype
+    !ERROR: Dummy argument 'vlist' of a defined input/output procedure must be deferred shape
+    integer, intent(in) :: vlist(5)
+    integer, intent(out) :: iostat
+    character(len=*), intent(inout) :: iomsg
+
+    iostat = 343
+    stop 'fail'
+  end subroutine
+end module m16