[flang-commits] [flang] [flang] Ensure names resolve in DATA statement objects (PR #82825)

[Peter Klausler via flang-commits]

https://github.com/klausler created https://github.com/llvm/llvm-project/pull/82825

When DATA statement objects have derived types obtained by implicit typing rules, their types aren't known until specification part processing is complete.  In the case of a derived type, any component name in a designator may still be in need of name resolution.  Take care of it in the deferred check visitor that runs at the end of name resolution in each specification and execution part.

Fixes https://github.com/llvm/llvm-project/issues/82069.

>From 4a11ba76e201421c1781e3f03b084bc59e231ac1 Mon Sep 17 00:00:00 2001
From: Peter Klausler <pklausler at nvidia.com>
Date: Fri, 23 Feb 2024 12:13:01 -0800
Subject: [PATCH] [flang] Ensure names resolve in DATA statement objects

When DATA statement objects have derived types obtained by
implicit typing rules, their types aren't known until
specification part processing is complete.  In the case
of a derived type, any component name in a designator may
still be in need of name resolution.  Take care of it
in the deferred check visitor that runs at the end of
name resolution in each specification and execution part.

Fixes https://github.com/llvm/llvm-project/issues/82069.
---
 flang/lib/Semantics/resolve-names.cpp | 16 +++++++++++++++-
 flang/test/Semantics/data22.f90       | 17 +++++++++++++++++
 2 files changed, 32 insertions(+), 1 deletion(-)
 create mode 100644 flang/test/Semantics/data22.f90

diff --git a/flang/lib/Semantics/resolve-names.cpp b/flang/lib/Semantics/resolve-names.cpp
index 36deab969456d0..7c2d76239f9ca4 100644
--- a/flang/lib/Semantics/resolve-names.cpp
+++ b/flang/lib/Semantics/resolve-names.cpp
@@ -8398,6 +8398,7 @@ bool ResolveNamesVisitor::Pre(const parser::PointerAssignmentStmt &x) {
   Walk(expr);
   return false;
 }
+
 void ResolveNamesVisitor::Post(const parser::Designator &x) {
   ResolveDesignator(x);
 }
@@ -8405,7 +8406,6 @@ void ResolveNamesVisitor::Post(const parser::SubstringInquiry &x) {
   Walk(std::get<parser::SubstringRange>(x.v.t).t);
   ResolveDataRef(std::get<parser::DataRef>(x.v.t));
 }
-
 void ResolveNamesVisitor::Post(const parser::ProcComponentRef &x) {
   ResolveStructureComponent(x.v.thing);
 }
@@ -8413,6 +8413,7 @@ void ResolveNamesVisitor::Post(const parser::TypeGuardStmt &x) {
   DeclTypeSpecVisitor::Post(x);
   ConstructVisitor::Post(x);
 }
+
 bool ResolveNamesVisitor::Pre(const parser::StmtFunctionStmt &x) {
   if (HandleStmtFunction(x)) {
     return false;
@@ -8950,6 +8951,8 @@ void ResolveNamesVisitor::EndScopeForNode(const ProgramTree &node) {
 // pointers, are deferred until all of the pertinent specification parts
 // have been visited.  This deferred processing enables the use of forward
 // references in these circumstances.
+// Data statement objects with implicit derived types are finally
+// resolved here.
 class DeferredCheckVisitor {
 public:
   explicit DeferredCheckVisitor(ResolveNamesVisitor &resolver)
@@ -9010,6 +9013,16 @@ class DeferredCheckVisitor {
       resolver_.CheckBindings(tbps);
     }
   }
+  bool Pre(const parser::DataStmtObject &) {
+    ++dataStmtObjectNesting_;
+    return true;
+  }
+  void Post(const parser::DataStmtObject &) { --dataStmtObjectNesting_; }
+  void Post(const parser::Designator &x) {
+    if (dataStmtObjectNesting_ > 0) {
+      resolver_.ResolveDesignator(x);
+    }
+  }
 
 private:
   void Init(const parser::Name &name,
@@ -9032,6 +9045,7 @@ class DeferredCheckVisitor {
 
   ResolveNamesVisitor &resolver_;
   bool pushedScope_{false};
+  int dataStmtObjectNesting_{0};
 };
 
 // Perform checks and completions that need to happen after all of
diff --git a/flang/test/Semantics/data22.f90 b/flang/test/Semantics/data22.f90
new file mode 100644
index 00000000000000..365958dbe7579c
--- /dev/null
+++ b/flang/test/Semantics/data22.f90
@@ -0,0 +1,17 @@
+! RUN: %flang_fc1 -fdebug-dump-symbols %s 2>&1 | FileCheck %s
+! Ensure that implicitly typed DATA statement objects with derived
+! types get their symbols resolved by the end of the name resolution pass.
+! CHECK: x1 (Implicit, InDataStmt) size=4 offset=0: ObjectEntity type: TYPE(t1) shape: 1_8:1_8 init:[t1::t1(n=123_4)]
+! CHECK: x2 (InDataStmt) size=4 offset=4: ObjectEntity type: TYPE(t2) shape: 1_8:1_8 init:[t2::t2(m=456_4)]
+implicit type(t1)(x)
+type t1
+  integer n
+end type
+dimension x1(1), x2(1)
+data x1(1)%n /123/
+data x2(1)%m /456/
+type t2
+  integer m
+end type
+type(t2) x2
+end