[flang] Check that various variables referenced in I/O statements may be defined

[klausler]

Summary

A number of I/O syntax rules involve variables that will be written to,
and must therefore be definable. This includes internal file variables,
IOSTAT= and IOMSG= specifiers, most INQUIRE statement specifiers, a few
other specifiers, and input variables. This patch checks for
these violations, and implements several additional I/O TODO constraint
checks.

[PeteSteinfeld]

All builds, tests, and looks good.

flang/lib/Semantics/check-io.h

private:
   void CheckForRequiredSpecifier(
       bool, const std::string &, bool, const std::string &) const;
 
   void CheckForProhibitedSpecifier(IoSpecKind) const;
   void CheckForProhibitedSpecifier(IoSpecKind, IoSpecKind) const;
   void CheckForProhibitedSpecifier(IoSpecKind, bool, const std::string &) const;
   void CheckForProhibitedSpecifier(bool, const std::string &, IoSpecKind) const;
 
+  template <typename A>
+  void CheckForDefinableVariable(const A &var, const std::string &s) const;
+
+  void CheckForPureSubprogram() const;
+
   void Init(IoStmtKind s) {
     stmt_ = s;
     specifierSet_.reset();
     flags_.reset();
   }
 
   void Done() { stmt_ = IoStmtKind::None; }
 
-  void CheckForPureSubprogram() const;
-
   SemanticsContext &context_;
   IoStmtKind stmt_{IoStmtKind::None};
   common::EnumSet<IoSpecKind, common::IoSpecKind_enumSize> specifierSet_;
   common::EnumSet<Flag, Flag_enumSize> flags_;
 };
 
 } // namespace Fortran::semantics
 #endif // FORTRAN_SEMANTICS_CHECK_IO_H_

flang/lib/Semantics/check-io.cpp

if (specKind == IoSpecKind::Access) {
       flags_.set(Flag::KnownAccess);
       flags_.set(Flag::AccessDirect, s == "DIRECT");
       flags_.set(Flag::AccessStream, s == "STREAM");
     }
     CheckStringValue(specKind, *charConst, parser::FindSourceLocation(spec));
   }
 }
 
-void IoChecker::Enter(const parser::ConnectSpec::Newunit &) {
+void IoChecker::Enter(const parser::ConnectSpec::Newunit &var) {
+  CheckForDefinableVariable(var, "NEWUNIT");
   SetSpecifier(IoSpecKind::Newunit);
 }
 
 void IoChecker::Enter(const parser::ConnectSpec::Recl &spec) {
   SetSpecifier(IoSpecKind::Recl);
   if (const std::optional<std::int64_t> recl{
           GetConstExpr<std::int64_t>(spec)}) {
     if (*recl <= 0) {
std::visit(
       },
       spec.u);
 }
 
 void IoChecker::Enter(const parser::IdExpr &) { SetSpecifier(IoSpecKind::Id); }
 
 void IoChecker::Enter(const parser::IdVariable &spec) {
   SetSpecifier(IoSpecKind::Id);
-  auto expr{GetExpr(spec)};
+  const auto *expr{GetExpr(spec)};
   if (!expr || !expr->GetType()) {
     return;
   }
+  CheckForDefinableVariable(spec, "ID");
   int kind{expr->GetType()->kind()};
   int defaultKind{context_.GetDefaultKind(TypeCategory::Integer)};
   if (kind < defaultKind) {
     context_.Say(
         "ID kind (%d) is smaller than default INTEGER kind (%d)"_err_en_US,
         std::move(kind), std::move(defaultKind)); // C1229
   }
 }
 
 void IoChecker::Enter(const parser::InputItem &spec) {
   flags_.set(Flag::DataList);
-  if (const parser::Variable * var{std::get_if<parser::Variable>(&spec.u)}) {
-    const parser::Name &name{GetLastName(*var)};
-    if (name.symbol) {
-      if (auto *details{name.symbol->detailsIf<ObjectEntityDetails>()}) {
-        // TODO: Determine if this check is needed at all, and if so, replace
-        // the false subcondition with a check for a whole array.  Otherwise,
-        // the check incorrectly flags array element and section references.
-        if (details->IsAssumedSize() && false) {
-          // This check may be superseded by C928 or C1002.
-          context_.Say(name.source,
-              "'%s' must not be a whole assumed size array"_err_en_US,
-              name.source); // C1231
-        }
-      }
-    }
-  }
-}
+  const parser::Variable *var{std::get_if<parser::Variable>(&spec.u)};
+  if (!var) {
+    return;
+  }
+  CheckForDefinableVariable(*var, "Input");
+  const auto &name{GetLastName(*var)};
+  const auto *expr{GetExpr(*var)};
+  if (name.symbol && IsAssumedSizeArray(*name.symbol) && expr &&
+      !evaluate::IsArrayElement(*GetExpr(*var))) {
+        "Whole assumed size array '%s' may not be an input item"_err_en_US,
 
 void IoChecker::Enter(const parser::InquireSpec &spec) {
   // InquireSpec context FileNameExpr
   if (std::get_if<parser::FileNameExpr>(&spec.u)) {
     SetSpecifier(IoSpecKind::File);
   }
 }
 
case ParseKind::Write:
     break;
   case ParseKind::Convert:
     specKind = IoSpecKind::Convert;
     break;
   case ParseKind::Dispose:
     specKind = IoSpecKind::Dispose;
     break;
   }
+  CheckForDefinableVariable(std::get<parser::ScalarDefaultCharVariable>(spec.t),
+      parser::ToUpperCaseLetters(common::EnumToString(specKind)));
   SetSpecifier(specKind);
 }
 
 void IoChecker::Enter(const parser::InquireSpec::IntVar &spec) {
   IoSpecKind specKind{};
   using ParseKind = parser::InquireSpec::IntVar::Kind;
   switch (std::get<parser::InquireSpec::IntVar::Kind>(spec.t)) {
   case ParseKind::Iostat:
case ParseKind::Pos:
     break;
   case ParseKind::Recl:
     specKind = IoSpecKind::Recl;
     break;
   case ParseKind::Size:
     specKind = IoSpecKind::Size;
     break;
   }
+  CheckForDefinableVariable(std::get<parser::ScalarIntVariable>(spec.t),
+      parser::ToUpperCaseLetters(common::EnumToString(specKind)));
   SetSpecifier(specKind);
 }
 
 void IoChecker::Enter(const parser::InquireSpec::LogVar &spec) {
   IoSpecKind specKind{};
   using ParseKind = parser::InquireSpec::LogVar::Kind;
   switch (std::get<parser::InquireSpec::LogVar::Kind>(spec.t)) {
   case ParseKind::Exist:

 void IoChecker::Enter(const parser::IoControlSpec::Pos &) {
   SetSpecifier(IoSpecKind::Pos);
 }
 
 void IoChecker::Enter(const parser::IoControlSpec::Rec &) {
   SetSpecifier(IoSpecKind::Rec);
 }
 
-void IoChecker::Enter(const parser::IoControlSpec::Size &) {
+void IoChecker::Enter(const parser::IoControlSpec::Size &var) {
+  CheckForDefinableVariable(var, "SIZE");
   SetSpecifier(IoSpecKind::Size);
 }
 
 void IoChecker::Enter(const parser::IoUnit &spec) {
   if (const parser::Variable * var{std::get_if<parser::Variable>(&spec.u)}) {
-    // TODO: C1201 - internal file variable must not be an array section ...
-    if (auto expr{GetExpr(*var)}) {
-      if (!ExprTypeKindIsDefault(*expr, context_)) {
+    if (stmt_ == IoStmtKind::Write) {
+      CheckForDefinableVariable(*var, "Internal file");
+    }
+    if (const auto *expr{GetExpr(*var)}) {
+      if (HasVectorSubscript(*expr)) {
+        context_.Say(parser::FindSourceLocation(*var), // C1201
+            "Internal file must not have a vector subscript"_err_en_US);
+      } else if (!ExprTypeKindIsDefault(*expr, context_)) {
         // This may be too restrictive; other kinds may be valid.
-        context_.Say( // C1202
+        context_.Say(parser::FindSourceLocation(*var), // C1202
             "Invalid character kind for an internal file variable"_err_en_US);
       }
     }
     SetSpecifier(IoSpecKind::Unit);
     flags_.set(Flag::InternalUnit);
   } else if (std::get_if<parser::Star>(&spec.u)) {
     SetSpecifier(IoSpecKind::Unit);
     flags_.set(Flag::StarUnit);
   }
 }
 
-void IoChecker::Enter(const parser::MsgVariable &) {
+void IoChecker::Enter(const parser::MsgVariable &var) {
+  if (stmt_ == IoStmtKind::None) {
+    // allocate, deallocate, image control
+    CheckForDefinableVariable(var, "ERRMSG");
+    return;
+  }
+  CheckForDefinableVariable(var, "IOMSG");
   SetSpecifier(IoSpecKind::Iomsg);
 }
 
-void IoChecker::Enter(const parser::OutputItem &) {
+void IoChecker::Enter(const parser::OutputItem &item) {
   flags_.set(Flag::DataList);
-  // TODO: C1233 - output item must not be a procedure pointer
+  if (const auto *x{std::get_if<parser::Expr>(&item.u)}) {
+    if (const auto *expr{GetExpr(*x)}) {
+      if (IsProcedurePointer(*expr)) {
+        context_.Say(parser::FindSourceLocation(*x),
+            "Output item must not be a procedure pointer"_err_en_US); // C1233
+      }
+    }
+  }
 }
 
 void IoChecker::Enter(const parser::StatusExpr &spec) {
   SetSpecifier(IoSpecKind::Status);
   if (const std::optional<std::string> charConst{
           GetConstExpr<std::string>(spec)}) {
     // Status values for Open and Close are different.
     std::string s{parser::ToUpperCaseLetters(*charConst)};
if (const std::optional<std::string> charConst{
     CHECK(stmt_ == IoStmtKind::Close);
     if (s != "DELETE" && s != "KEEP") {
       context_.Say(parser::FindSourceLocation(spec),
           "Invalid STATUS value '%s'"_err_en_US, *charConst);
     }
   }
 }
 
-void IoChecker::Enter(const parser::StatVariable &) {
+void IoChecker::Enter(const parser::StatVariable &var) {
   if (stmt_ == IoStmtKind::None) {
-    // ALLOCATE & DEALLOCATE
-  } else {
-    SetSpecifier(IoSpecKind::Iostat);
+    // allocate, deallocate, image control
+    CheckForDefinableVariable(var, "STAT");
+    return;
   }
+  CheckForDefinableVariable(var, "IOSTAT");
+  SetSpecifier(IoSpecKind::Iostat);
 }
 
 void IoChecker::Leave(const parser::BackspaceStmt &) {
   CheckForPureSubprogram();
   CheckForRequiredSpecifier(
       flags_.test(Flag::NumberUnit), "UNIT number"); // C1240
   Done();
 }
void IoChecker::CheckStringValue(IoSpecKind specKind, const std::string &value,
   if (!specValues.at(specKind).count(parser::ToUpperCaseLetters(value))) {
     context_.Say(source, "Invalid %s value '%s'"_err_en_US,
         parser::ToUpperCaseLetters(common::EnumToString(specKind)), value);
   }
 }
 
 // CheckForRequiredSpecifier and CheckForProhibitedSpecifier functions
 // need conditions to check, and string arguments to insert into a message.
-// A IoSpecKind provides both an absence/presence condition and a string
+// An IoSpecKind provides both an absence/presence condition and a string
 // argument (its name).  A (condition, string) pair provides an arbitrary
 // condition and an arbitrary string.
 
 void IoChecker::CheckForRequiredSpecifier(IoSpecKind specKind) const {
   if (!specifierSet_.test(specKind)) {
     context_.Say("%s statement must have a %s specifier"_err_en_US,
         parser::ToUpperCaseLetters(common::EnumToString(stmt_)),
         parser::ToUpperCaseLetters(common::EnumToString(specKind)));

 void IoChecker::CheckForProhibitedSpecifier(
     bool condition, const std::string &s, IoSpecKind specKind) const {
   if (condition && specifierSet_.test(specKind)) {
     context_.Say("If %s appears, %s must not appear"_err_en_US, s,
         parser::ToUpperCaseLetters(common::EnumToString(specKind)));
   }
 }
 
+template <typename A>
+void IoChecker::CheckForDefinableVariable(
+    const A &var, const std::string &s) const {
+  const Symbol *sym{
+      GetFirstName(*parser::Unwrap<parser::Variable>(var)).symbol};
+  if (WhyNotModifiable(*sym, context_.FindScope(*context_.location()))) {
+    context_.Say(parser::FindSourceLocation(var),
+        "%s variable '%s' must be definable"_err_en_US, s, sym->name());
+  }
+}
+
 void IoChecker::CheckForPureSubprogram() const { // C1597
   CHECK(context_.location());
   if (FindPureProcedureContaining(context_.FindScope(*context_.location()))) {
     context_.Say("External I/O is not allowed in a pure subprogram"_err_en_US);
   }
 }
 
 } // namespace Fortran::semantics

flang/test/Semantics/deallocate05.f90

 Type t
   Type(dt) :: p
 End Type
 
 Type(t),Allocatable :: x(:)
 
 Real :: r
 Integer :: s
+Integer, Parameter :: const_s = 13
 Integer :: e
 Integer :: pi
 Character(256) :: ee
 Procedure(Real) :: prp
 
 Allocate(rp)
 Deallocate(rp)
 

 !ERROR: name in DEALLOCATE statement must be a variable name
 Deallocate(maxvalue)
 
 !ERROR: component in DEALLOCATE statement must have the ALLOCATABLE or POINTER attribute
 Deallocate(x%p)
 
 !ERROR: STAT may not be duplicated in a DEALLOCATE statement
 Deallocate(x, stat=s, stat=s)
+!ERROR: STAT variable 'const_s' must be definable
+Deallocate(x, stat=const_s)
 !ERROR: ERRMSG may not be duplicated in a DEALLOCATE statement
 Deallocate(x, errmsg=ee, errmsg=ee)
 !ERROR: STAT may not be duplicated in a DEALLOCATE statement
 Deallocate(x, stat=s, errmsg=ee, stat=s)
 !ERROR: ERRMSG may not be duplicated in a DEALLOCATE statement
 Deallocate(x, stat=s, errmsg=ee, errmsg=ee)
 
 End Program deallocatetest

flang/test/Semantics/io01.f90

! RUN: %S/test_errors.sh %s %t %f18
   character(len=20) :: convert_(2) = (/"big_endiaN", "nativE    "/)
   character(len=20) :: dispose_(2) = (/ "deletE", "keeP  "/)
   character(len=66) :: cc, msg
 
   integer :: new_unit
   integer :: unit10 = 10
   integer :: unit11 = 11
   integer :: n = 40
+  integer, parameter :: const_new_unit = 66
 
   integer(kind=1) :: stat1
   integer(kind=2) :: stat2
   integer(kind=4) :: stat4
   integer(kind=8) :: stat8
 
   cc = 'scratch'
 
3 continue
 
   !ERROR: If STATUS='STREAM' appears, RECL must not appear
   open(10, access='st'//'ream', recl=13)
 
   !ERROR: Duplicate NEWUNIT specifier
   !ERROR: If NEWUNIT appears, FILE or STATUS must also appear
   open(newunit=n, newunit=nn, iostat=stat4)
 
+  !ERROR: NEWUNIT variable 'const_new_unit' must be definable
+  open(newunit=const_new_unit, status=cc)
+
   !ERROR: Duplicate UNIT specifier
   open(unit=100, unit=100)
 
   !ERROR: Duplicate UNIT specifier
   open(101, delim=delim_(1), unit=102)
 
   !ERROR: Duplicate UNIT specifier
   open(unit=103, &

flang/test/Semantics/io02.f90

 ! RUN: %S/test_errors.sh %s %t %f18
   integer :: unit10 = 10
   integer :: unit11 = 11
+  integer, parameter :: const_stat = 6666
 
   integer(kind=1) :: stat1
   integer(kind=8) :: stat8
 
   character(len=55) :: msg
 
   close(unit10)
   close(unit=unit11, err=9, iomsg=msg, iostat=stat1)
! RUN: %S/test_errors.sh %s %t %f18
   close(err=9, unit=15, err=9, iostat=stat8)
 
   !ERROR: Invalid STATUS value 'kept'
   close(status='kept', unit=16)
 
   !ERROR: Invalid STATUS value 'old'
   close(status='old', unit=17)
 
+  !ERROR: IOSTAT variable 'const_stat' must be definable
+  close(14, iostat=const_stat)
+
 9 continue
 end

flang/test/Semantics/io03.f90

 ! RUN: %S/test_errors.sh %s %t %f18
   character(kind=1,len=50) internal_file
   character(kind=2,len=50) internal_file2
   character(kind=4,len=50) internal_file4
+  character(kind=1,len=50) internal_fileA(20)
   character(kind=1,len=111) msg
   character(20) advance
+  character(20) :: cvar;
+  character, parameter :: const_internal_file = "(I6)"
+  character, parameter :: const_cvar = "Ceci n'est pas une pipe."
   integer*1 stat1
   integer*2 stat2, id2
   integer*8 stat8
   integer :: iunit = 10
-  integer, parameter :: junit = 11
+  integer, parameter :: junit = 11, const_size = 13, const_int = 15
+  integer :: vv(10) = 7
 
   namelist /mmm/ mm1, mm2
   namelist /nnn/ nn1, nn2
 
   advance='no'
 
   open(10)
 
   read*
   print*, 'Ok'
   read(*)
   read*, jj
   read(*, *) jj
   read(unit=*, *) jj
   read(*, fmt=*) jj
   read(*, '(I4)') jj
   read(*, fmt='(I4)') jj
   read(fmt='(I4)', unit=*) jj
   read(iunit, *) jj
   read(junit, *) jj
-  read(10, *) jj
+  read(10, *) jj, cvar, cvar(7:17)
   read(internal_file, *) jj
+  read(internal_fileA(3), *) jj
+  read(internal_fileA(4:9), *) jj
   read(10, nnn)
   read(internal_file, nnn)
   read(internal_file, nml=nnn)
+  read(const_internal_file, *)
   read(fmt=*, unit=internal_file)
   read(nml=nnn, unit=internal_file)
   read(iunit, nnn)
   read(10, nml=nnn)
   read(10, asynchronous='no') jj
   read(10, asynchronous='yes') jj
   read(10, eor=9, advance='no', fmt='(I4)') jj
   read(10, eor=9, advance='no', fmt='(I4)') jj
   read(10, asynchronous='yes', id=id) jj
   read(10, '(I4)', advance='no', asynchronous='yes', blank='null', &
       decimal='comma', end=9, eor=9, err=9, id=id, iomsg=msg, iostat=stat2, &
       pad='no', round='processor_defined', size=kk) jj
 
   !ERROR: Invalid character kind for an internal file variable
   read(internal_file2, *) jj
 
   !ERROR: Invalid character kind for an internal file variable
   read(internal_file4, *) jj
 
+  !ERROR: Internal file must not have a vector subscript
+  read(internal_fileA(vv), *) jj
+
+  !ERROR: Input variable 'const_int' must be definable
+  read(11, *) const_int
+
+  !ERROR: SIZE variable 'const_size' must be definable
+  read(11, pos=ipos, size=const_size, end=9)
+
+  !ERROR: Input variable 'const_cvar' must be definable
+  read(11, *) const_cvar
+
+  !ERROR: Input variable 'const_cvar' must be definable
+  read(11, *) const_cvar(3:13)
+
   !ERROR: Duplicate IOSTAT specifier
   read(11, pos=ipos, iostat=stat1, iostat=stat2)
 
   !ERROR: Duplicate END specifier
   read(11, end=9, pos=ipos, end=9)
 
   !ERROR: Duplicate NML specifier
   read(10, nml=mmm, nml=nnn)
! RUN: %S/test_errors.sh %s %t %f18
   !ERROR: If PAD appears, FMT or NML must also appear
   read(10, pad='no', round='nearest') jj
 
   !ERROR: ID kind (2) is smaller than default INTEGER kind (4)
   read(10, id=id2, asynchronous='yes') jj
 
 9 continue
 end
+
+subroutine s(aa, n)
+  integer :: aa(5,*)
+  integer, intent(in) :: n
+  integer :: bb(10), vv(10)
+  type tt
+    real :: x, y, z
+  end type tt
+  type(tt) :: qq(20)
+
+  vv = 1
+
+  read(*, *) aa(n,1)
+  read(*, *) aa(n:n+2,2)
+  read(*, *) qq(2:5)%y
+
+  !ERROR: Input variable 'n' must be definable
+  read(*, *) n
+
+  !ERROR: Whole assumed size array 'aa' may not be an input item
+  read(*, *) aa
+end

flang/test/Semantics/io04.f90

 ! RUN: %S/test_errors.sh %s %t %f18
   character(kind=1,len=50) internal_file
   character(kind=1,len=100) msg
   character(20) sign
+  character, parameter :: const_internal_file = "(I6)"
   integer*1 stat1, id1
   integer*2 stat2
   integer*4 stat4
   integer*8 stat8
   integer :: iunit = 10
   integer, parameter :: junit = 11
   integer, pointer :: a(:)
+  integer, parameter :: const_id = 66666
+  procedure(), pointer :: procptr
 
   namelist /nnn/ nn1, nn2
 
   sign = 'suppress'
 
   open(10)
 
   write(*)
! RUN: %S/test_errors.sh %s %t %f18
   !ERROR: WRITE statement must not have a PAD specifier
   write(*, eor=9, blank='zero', end=9, pad='no')
 
   !ERROR: If NML appears, REC must not appear
   !ERROR: If NML appears, FMT must not appear
   !ERROR: If NML appears, a data list must not appear
   write(10, nnn, rec=40, fmt=1) 'Ok'
 
+  !ERROR: Internal file variable 'const_internal_file' must be definable
+  write(const_internal_file, fmt=*)
+
   !ERROR: If UNIT=* appears, POS must not appear
   write(*, pos=n, nml=nnn)
 
   !ERROR: If UNIT=* appears, REC must not appear
   write(*, rec=n)
 
   !ERROR: If UNIT=internal-file appears, POS must not appear
   write(internal_file, err=9, pos=n, nml=nnn)
! RUN: %S/test_errors.sh %s %t %f18
 
   !ERROR: If DELIM appears, FMT=* or NML must also appear
   !ERROR: Invalid DELIM value 'Nix'
   write(delim='Nix', fmt='(A)', unit=10) 'Ok'
 
   !ERROR: ID kind (1) is smaller than default INTEGER kind (4)
   write(id=id1, unit=10, asynchronous='Yes') 'Ok'
 
+  !ERROR: ID variable 'const_id' must be definable
+  write(10, *, asynchronous='yes', id=const_id, iostat=stat2) 'Ok'
+
   write(*, '(X)')
 
+  !ERROR: Output item must not be a procedure pointer
+  print*, n1, procptr, n2
+
 1 format (A)
 9 continue
 end

flang/test/Semantics/io05.f90

 ! RUN: %S/test_errors.sh %s %t %f18
   character*20 c(25), cv
   character(kind=1,len=59) msg
+  character, parameter :: const_round = "c'est quoi?"
   logical*2 v(5), lv
   integer*1 stat1
   integer*2 stat4
   integer*8 stat8, iv
+  integer, parameter :: const_id = 1
 
   inquire(10)
   inquire(file='abc')
   inquire(10, pos=ipos, iomsg=msg, iostat=stat1)
   inquire(file='abc', &
       access=c(1), action=c(2), asynchronous=c(3), blank=c(4), decimal=c(5), &
       delim=c(6), direct=c(7), encoding=c(8), form=c(9), formatted=c(10), &
       name=c(11), pad=c(12), position=c(13), read=c(14), readwrite=c(15), &
       round=c(16), sequential=c(17), sign=c(18), stream=c(19), &
       unformatted=c(20), write=c(21), &
       err=9, &
       nextrec=nextrec, number=number, pos=jpos, recl=jrecl, size=jsize, &
       iomsg=msg, &
       iostat=stat4, &
       exist=v(1), named=v(2), opened=v(3), pending=v(4))
   inquire(pending=v(5), file='abc')
   inquire(10, id=id, pending=v(5))
+  inquire(10, id=const_id, pending=v(5))
 
   ! using variable 'cv' multiple times seems to be allowed
   inquire(file='abc', &
       access=cv, action=cv, asynchronous=cv, blank=cv, decimal=cv, &
       delim=cv, direct=cv, encoding=cv, form=cv, formatted=cv, &
       name=cv, pad=cv, position=cv, read=cv, readwrite=cv, &
       round=cv, sequential=cv, sign=cv, stream=cv, &
       unformatted=cv, write=cv, &
! RUN: %S/test_errors.sh %s %t %f18
   inquire(1, read=c(1), write=c(2), sign=c(3), sign=c(4), read=c(5), write=c(1))
 
   !ERROR: Duplicate IOMSG specifier
   inquire(10, iomsg=msg, pos=ipos, iomsg=msg)
 
   !ERROR: If ID appears, PENDING must also appear
   inquire(file='abc', id=id)
 
+  !ERROR: ROUND variable 'const_round' must be definable
+  inquire(file='abc', round=const_round)
+
 9 continue
 end

flang/test/Semantics/io06.f90

 ! RUN: %S/test_errors.sh %s %t %f18
   character(kind=1,len=100) msg1
   character(kind=2,len=200) msg2
+  character, parameter :: const_msg = 'doof'
   integer(1) stat1
   integer(2) stat2
   integer(8) stat8
 
   open(10)
 
   backspace(10)
   backspace(10, iomsg=msg1, iostat=stat1, err=9)
! RUN: %S/test_errors.sh %s %t %f18
   wait(99, id=id1, end=9, eor=9, err=9, iostat=stat1, iomsg=msg1)
 
   !ERROR: Duplicate UNIT specifier
   backspace(10, unit=11)
 
   !ERROR: Duplicate IOSTAT specifier
   endfile(iostat=stat2, err=9, unit=10, iostat=stat8, iomsg=msg1)
 
+  !ERROR: IOMSG variable 'const_msg' must be definable
+  flush(iomsg=const_msg, unit=10, iostat=stat8, err=9)
+
   !ERROR: REWIND statement must have a UNIT number specifier
   rewind(iostat=stat2)
 
   !ERROR: Duplicate ERR specifier
   !ERROR: Duplicate ERR specifier
   flush(err=9, unit=10, &
         err=9, &
         err=9)
 
   !ERROR: Duplicate ID specifier
   !ERROR: WAIT statement must have a UNIT number specifier
   wait(id=id2, eor=9, id=id3)
 
 9 continue
 end