[flang] Detect and rewrite ambiguous READ(CVAR)[,item-list]

[klausler]

Summary

READ(CVAR)[,item-list] with a character variable CVAR
could be parsed as an unformatted READ from an internal
unit or as a formatted READ from the default external unit
with a needlessly parenthesized variable format. We parse
it as the former, but Fortran doesn't have unformatted
internal I/O.

[PeteSteinfeld]

All builds, tests, and looks good.

flang/lib/Parser/io-parsers.cpp

 
 // R1208 close-stmt -> CLOSE ( close-spec-list )
 TYPE_CONTEXT_PARSER("CLOSE statement"_en_US,
     construct<CloseStmt>("CLOSE" >> parenthesized(nonemptyList(closeSpec))))
 
 // R1210 read-stmt ->
 //         READ ( io-control-spec-list ) [input-item-list] |
 //         READ format [, input-item-list]
+// The ambiguous READ(CVAR) is parsed as if CVAR were the unit.
+// As Fortran doesn't have internal unformatted I/O, it should
+// be parsed as if (CVAR) were a format; this is corrected by
+// rewriting in semantics when we know that CVAR is character.
 constexpr auto inputItemList{
     extension<LanguageFeature::IOListLeadingComma>(
         some("," >> inputItem)) || // legacy extension: leading comma
     optionalList(inputItem)};
 
 TYPE_CONTEXT_PARSER("READ statement"_en_US,
     construct<ReadStmt>("READ (" >>
             construct<std::optional<IoUnit>>(maybe("UNIT ="_tok) >> ioUnit),

flang/lib/Semantics/rewrite-parse-tree.cpp

if (const parser::Name * name{parser::Unwrap<parser::Name>(x.format)}) {
       if (name->symbol && name->symbol->GetUltimate().has<NamelistDetails>()) {
         x.controls.emplace_front(parser::IoControlSpec{std::move(*name)});
         x.format.reset();
       }
     }
   }
 }
 
+// READ(CVAR) [, ...] will be misparsed as UNIT=CVAR; correct
+// it to READ CVAR [,...] with CVAR as a format rather than as
+// an internal I/O unit for unformatted I/O, which Fortran does
+// not support.
 void RewriteMutator::Post(parser::ReadStmt &x) {
+  if (x.iounit && !x.format && x.controls.empty()) {
+    if (auto *var{std::get_if<parser::Variable>(&x.iounit->u)}) {
+      const parser::Name &last{parser::GetLastName(*var)};
+      DeclTypeSpec *type{last.symbol ? last.symbol->GetType() : nullptr};
+      if (type && type->category() == DeclTypeSpec::Character) {
+        x.format = std::visit(
+            [](auto &&indirection) {
+              return parser::Expr{std::move(indirection)};
+            },
+            std::move(var->u));
+        x.iounit.reset();
+      }
+    }
+  }
   FixMisparsedUntaggedNamelistName(x);
 }
 
 void RewriteMutator::Post(parser::WriteStmt &x) {
   FixMisparsedUntaggedNamelistName(x);
 }
 
 void RewriteMutator::Post(parser::DataStmtConstant &x) {

flang/test/Semantics/rewrite01.f90

+! RUN: %f18 -fparse-only -fdebug-dump-parse-tree %s 2>&1 | FileCheck %s
+! Ensure that READ(CVAR) [, item-list] is corrected when CVAR is a
+! character variable so as to be a formatted read from the default
+! unit, not an unformatted read from an internal unit (which is not
+! possible in Fortran).
+character :: cvar
+! CHECK-NOT: IoUnit -> Variable -> Designator -> DataRef -> Name = 'cvar'
+! CHECK: Format -> Expr = 'cvar'
+read(cvar)
+end