[flang] Admit trailing blanks when checking I/O specifiers

[klausler]

Summary

Fortran specifically allows character-valued I/O specifiers
to have trailing blanks, e.g. OPEN(666,STATUS='SCRATCH ').
The runtime I/O library already handles them, but the I/O
static checks in semantics do not.

flang/lib/Semantics/check-io.cpp

 
 void IoChecker::Enter(const parser::ConnectSpec &spec) {
   // ConnectSpec context FileNameExpr
   if (std::get_if<parser::FileNameExpr>(&spec.u)) {
     SetSpecifier(IoSpecKind::File);
   }
 }
 
+// Ignore trailing spaces (12.5.6.2 p1) and convert to upper case
+static std::string Normalize(const std::string &value) {
+  auto upper{parser::ToUpperCaseLetters(value)};
+  std::size_t lastNonBlank{upper.find_last_not_of(" ")};
+  upper.resize(lastNonBlank == std::string::npos ? 0 : lastNonBlank + 1);
+  return upper;
+}
+
 void IoChecker::Enter(const parser::ConnectSpec::CharExpr &spec) {
   IoSpecKind specKind{};
   using ParseKind = parser::ConnectSpec::CharExpr::Kind;
   switch (std::get<ParseKind>(spec.t)) {
   case ParseKind::Access:
     specKind = IoSpecKind::Access;
     break;
   case ParseKind::Action:
case ParseKind::Convert:
     break;
   case ParseKind::Dispose:
     specKind = IoSpecKind::Dispose;
     break;
   }
   SetSpecifier(specKind);
   if (const std::optional<std::string> charConst{GetConstExpr<std::string>(
           std::get<parser::ScalarDefaultCharExpr>(spec.t))}) {
-    std::string s{parser::ToUpperCaseLetters(*charConst)};
+    std::string s{Normalize(*charConst)};
     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));
     if (specKind == IoSpecKind::Carriagecontrol &&
         (s == "FORTRAN" || s == "NONE")) {
if (std::holds_alternative<parser::Name>(spec.u)) {
     flags_.set(Flag::FmtOrNml);
   }
 }
 
 void IoChecker::Enter(const parser::IoControlSpec::Asynchronous &spec) {
   SetSpecifier(IoSpecKind::Asynchronous);
   if (const std::optional<std::string> charConst{
           GetConstExpr<std::string>(spec)}) {
-    flags_.set(
-        Flag::AsynchronousYes, parser::ToUpperCaseLetters(*charConst) == "YES");
+    flags_.set(Flag::AsynchronousYes, Normalize(*charConst) == "YES");
     CheckStringValue(IoSpecKind::Asynchronous, *charConst,
         parser::FindSourceLocation(spec)); // C1223
   }
 }
 
 void IoChecker::Enter(const parser::IoControlSpec::CharExpr &spec) {
   IoSpecKind specKind{};
   using ParseKind = parser::IoControlSpec::CharExpr::Kind;
void IoChecker::Enter(const parser::IoControlSpec::CharExpr &spec) {
   case ParseKind::Sign:
     specKind = IoSpecKind::Sign;
     break;
   }
   SetSpecifier(specKind);
   if (const std::optional<std::string> charConst{GetConstExpr<std::string>(
           std::get<parser::ScalarDefaultCharExpr>(spec.t))}) {
     if (specKind == IoSpecKind::Advance) {
-      flags_.set(
-          Flag::AdvanceYes, parser::ToUpperCaseLetters(*charConst) == "YES");
+      flags_.set(Flag::AdvanceYes, Normalize(*charConst) == "YES");
     }
     CheckStringValue(specKind, *charConst, parser::FindSourceLocation(spec));
   }
 }
 
 void IoChecker::Enter(const parser::IoControlSpec::Pos &) {
   SetSpecifier(IoSpecKind::Pos);
 }
void IoChecker::Enter(const parser::OutputItem &item) {
   }
 }
 
 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)};
+    std::string s{Normalize(*charConst)};
     if (stmt_ == IoStmtKind::Open) {
       flags_.set(Flag::KnownStatus);
       flags_.set(Flag::StatusNew, s == "NEW");
       flags_.set(Flag::StatusReplace, s == "REPLACE");
       flags_.set(Flag::StatusScratch, s == "SCRATCH");
       // CheckStringValue compares for OPEN Status string values.
       CheckStringValue(
           IoSpecKind::Status, *charConst, parser::FindSourceLocation(spec));
static std::unordered_map<IoSpecKind, const std::set<std::string>> specValues{
       {IoSpecKind::Sign, {"PLUS", "PROCESSOR_DEFINED", "SUPPRESS"}},
       {IoSpecKind::Status,
           // Open values; Close values are {"DELETE", "KEEP"}.
           {"NEW", "OLD", "REPLACE", "SCRATCH", "UNKNOWN"}},
       {IoSpecKind::Carriagecontrol, {"LIST", "FORTRAN", "NONE"}},
       {IoSpecKind::Convert, {"BIG_ENDIAN", "LITTLE_ENDIAN", "NATIVE"}},
       {IoSpecKind::Dispose, {"DELETE", "KEEP"}},
   };
-  auto upper{parser::ToUpperCaseLetters(value)};
+  auto upper{Normalize(value)};
   if (specValues.at(specKind).count(upper) == 0) {
     if (specKind == IoSpecKind::Access && upper == "APPEND") {
       if (context_.languageFeatures().ShouldWarn(
               common::LanguageFeature::OpenAccessAppend)) {
         context_.Say(source,
             "ACCESS='%s' interpreted as POSITION='%s'"_port_en_US, value,
             upper);
       }

flang/test/Semantics/io02.f90

! RUN: %python %S/test_errors.py %s %flang_fc1
   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)
 
+  !Ok: trailing spaces ignored
+  close(status='keep ', unit=17)
+
   !ERROR: IOSTAT variable 'const_stat' must be definable
   close(14, iostat=const_stat)
 
 9 continue
 end