[flang] Fix creation of deferred shape arrays by POINTER statement

[PeteSteinfeld]

Summary

It's possible to declare deferred shape array using the POINTER
statement, for example:

POINTER :: var(:)

When analyzing POINTER declarations, we were not capturing the array
specification information, if present. I fixed this by changing the
"Post" function for "parser::PointerDecl" to check to see if the
declaration contained a "DeferredShapeSpecList". In such cases, I
analyzed the shape and used to information to declare an "ObjectEntity"
that contains the shape information rather than an "UnknownEntity".

I also added a couple of small tests that fail to compile without these
changes.

[MaskRay]

In your commit the message does not include Reviewed by:. Many people agree that both Reviewed by: & Differential Revision: should be present. The Reviewed by: list indicates people who acknowledged the patch. (The Reviewers: list does not necessarily mean all the people on the list have acknowledged the patch so Reviewers: is mostly useless.)

arc amend can fetch the Phabricator summary and amend the local description.

You can install llvm/utils/git/pre-push.py to prevent accidental Summary:, Reviewers:, Subscribers: and Tags: in the presence of Differential Revision:.

[PeteSteinfeld]

In D95080#2523025, @MaskRay wrote:

In your commit the message does not include Reviewed by:. Many people agree that both Reviewed by: & Differential Revision: should be present. The Reviewed by: list indicates people who acknowledged the patch. (The Reviewers: list does not necessarily mean all the people on the list have acknowledged the patch so Reviewers: is mostly useless.)

arc amend can fetch the Phabricator summary and amend the local description.

You can install llvm/utils/git/pre-push.py to prevent accidental Summary:, Reviewers:, Subscribers: and Tags: in the presence of Differential Revision:.

Thanks for watching over these revisions. From what I can tell, the "arc diff" command adds a line to the commit message that contains a link to the Differential Revision. Here's an excerpt from the commit message from a more recent update of mine that "arc diff" added:

Differential Revision: https://reviews.llvm.org/D95894

The Differential Revision, in turn, contains information about who reviewed and approved the change. So it seems to me that adding that information to the commit message is redundant.

flang/lib/Semantics/resolve-names-utils.h

private:
   void Analyze(const parser::DefinedOpName &);
   void Analyze(const parser::GenericSpec &);
 };
 
 // Analyze a parser::ArraySpec or parser::CoarraySpec
 ArraySpec AnalyzeArraySpec(SemanticsContext &, const parser::ArraySpec &);
 ArraySpec AnalyzeArraySpec(
     SemanticsContext &, const parser::ComponentArraySpec &);
+ArraySpec AnalyzeDeferredShapeSpecList(
+    SemanticsContext &, const parser::DeferredShapeSpecList &);
 ArraySpec AnalyzeCoarraySpec(
     SemanticsContext &context, const parser::CoarraySpec &);
 
 // Perform consistency checks on equivalence sets
 class EquivalenceSets {
 public:
   EquivalenceSets(SemanticsContext &context) : context_{context} {}
   std::vector<EquivalenceSet> &sets() { return sets_; };

flang/lib/Semantics/resolve-names-utils.cpp

case IntrinsicOperator::GT:
     return RelationalOperator::GT;
   }
 }
 
 class ArraySpecAnalyzer {
 public:
   ArraySpecAnalyzer(SemanticsContext &context) : context_{context} {}
   ArraySpec Analyze(const parser::ArraySpec &);
+  ArraySpec AnalyzeDeferredShapeSpecList(const parser::DeferredShapeSpecList &);
   ArraySpec Analyze(const parser::ComponentArraySpec &);
   ArraySpec Analyze(const parser::CoarraySpec &);
 
 private:
   SemanticsContext &context_;
   ArraySpec arraySpec_;
 
   template <typename T> void Analyze(const std::list<T> &list) {

 ArraySpec AnalyzeArraySpec(
     SemanticsContext &context, const parser::ArraySpec &arraySpec) {
   return ArraySpecAnalyzer{context}.Analyze(arraySpec);
 }
 ArraySpec AnalyzeArraySpec(
     SemanticsContext &context, const parser::ComponentArraySpec &arraySpec) {
   return ArraySpecAnalyzer{context}.Analyze(arraySpec);
 }
+ArraySpec AnalyzeDeferredShapeSpecList(SemanticsContext &context,
+    const parser::DeferredShapeSpecList &deferredShapeSpecs) {
+  return ArraySpecAnalyzer{context}.AnalyzeDeferredShapeSpecList(
+      deferredShapeSpecs);
+}
 ArraySpec AnalyzeCoarraySpec(
     SemanticsContext &context, const parser::CoarraySpec &coarraySpec) {
   return ArraySpecAnalyzer{context}.Analyze(coarraySpec);
 }
 
 ArraySpec ArraySpecAnalyzer::Analyze(const parser::ComponentArraySpec &x) {
   std::visit([this](const auto &y) { Analyze(y); }, x.u);
   CHECK(!arraySpec_.empty());
   return arraySpec_;
 }
 ArraySpec ArraySpecAnalyzer::Analyze(const parser::ArraySpec &x) {
   std::visit(common::visitors{
                  [&](const parser::AssumedSizeSpec &y) {
                    Analyze(std::get<std::list<parser::ExplicitShapeSpec>>(y.t));
                    Analyze(std::get<parser::AssumedImpliedSpec>(y.t));
                  },
                  [&](const parser::ImpliedShapeSpec &y) { Analyze(y.v); },
                  [&](const auto &y) { Analyze(y); },
              },
       x.u);
   CHECK(!arraySpec_.empty());
   return arraySpec_;
 }
+ArraySpec ArraySpecAnalyzer::AnalyzeDeferredShapeSpecList(
+    const parser::DeferredShapeSpecList &x) {
+  Analyze(x);
+  CHECK(!arraySpec_.empty());
+  return arraySpec_;
+}
 ArraySpec ArraySpecAnalyzer::Analyze(const parser::CoarraySpec &x) {
   std::visit(
       common::visitors{
           [&](const parser::DeferredCoshapeSpecList &y) { MakeDeferred(y.v); },
           [&](const parser::ExplicitCoshapeSpec &y) {
             Analyze(std::get<std::list<parser::ExplicitShapeSpec>>(y.t));
             MakeImplied(
                 std::get<std::optional<parser::SpecificationExpr>>(y.t));

flang/lib/Semantics/resolve-names.cpp

public:
   void Post(const parser::ArraySpec &);
   void Post(const parser::ComponentArraySpec &);
   void Post(const parser::CoarraySpec &);
   void Post(const parser::AttrSpec &) { PostAttrSpec(); }
   void Post(const parser::ComponentAttrSpec &) { PostAttrSpec(); }
 
 protected:
   const ArraySpec &arraySpec();
+  void set_arraySpec(const ArraySpec arraySpec) { arraySpec_ = arraySpec; }
   const ArraySpec &coarraySpec();
   void BeginArraySpec();
   void EndArraySpec();
   void ClearArraySpec() { arraySpec_.clear(); }
   void ClearCoarraySpec() { coarraySpec_.clear(); }
 
 private:
   // arraySpec_/coarraySpec_ are populated from any ArraySpec/CoarraySpec
if (auto &init{std::get<std::optional<parser::Initialization>>(x.t)}) {
     }
   } else if (attrs.test(Attr::PARAMETER)) { // C882, C883
     Say(name, "Missing initialization for parameter '%s'"_err_en_US);
   }
 }
 
 void DeclarationVisitor::Post(const parser::PointerDecl &x) {
   const auto &name{std::get<parser::Name>(x.t)};
+  if (const auto &deferredShapeSpecs{
+          std::get<std::optional<parser::DeferredShapeSpecList>>(x.t)}) {
+    CHECK(arraySpec().empty());
+    BeginArraySpec();
+    set_arraySpec(AnalyzeDeferredShapeSpecList(context(), *deferredShapeSpecs));
+    Symbol &symbol{DeclareObjectEntity(name, Attrs{Attr::POINTER})};
+    symbol.ReplaceName(name.source);
+    EndArraySpec();
+  } else {
     Symbol &symbol{DeclareUnknownEntity(name, Attrs{Attr::POINTER})};
     symbol.ReplaceName(name.source);
   }
+}
 
 bool DeclarationVisitor::Pre(const parser::BindEntity &x) {
   auto kind{std::get<parser::BindEntity::Kind>(x.t)};
   auto &name{std::get<parser::Name>(x.t)};
   Symbol *symbol;
   if (kind == parser::BindEntity::Kind::Object) {
     symbol = &HandleAttributeStmt(Attr::BIND_C, name);
   } else {

flang/test/Semantics/allocate12.f90

 ! RUN: %S/test_errors.sh %s %t %f18
 ! Check for semantic errors in ALLOCATE statements
 
-subroutine C941_C942b_C950(xsrc, x1, a2, b2, cx1, ca2, cb1, cb2, c1)
+subroutine C941_C942b_C950(xsrc, x1, a2, b2, cx1, ca2, cb1, cb2, c1, c2)
 ! C941: An allocate-coarray-spec shall appear if and only if the allocate-object
 ! is a coarray.
   type type0
     real, allocatable :: array(:)
   end type
   type type1
     class(type0), pointer :: t0
   end type
! is a coarray.
 
   real, allocatable :: cx1[:], cx2(:)[:, :]
   class(A), allocatable :: ca1[:, :], ca2(:)[:]
 
   type(B) :: b1, b2(*)
   type(B) :: cb1[5:*], cb2(*)[2, -1:*]
 
   type(C) :: c1
+  pointer :: c2(:, :)
+  pointer :: varLocal(:)
 
   class(*), allocatable :: var(:), cvar(:)[:]
 
   ! Valid constructs
   allocate(x1, x2(10), cx1[*], cx2(10)[2, -1:*])
   allocate(a1, a2(10), ca1[2, -1:*], ca2(10)[*])
   allocate(b1%x, b2(1)%x, cb1%x, cb2(1)%x, SOURCE=xsrc)
   allocate(c1%x(-1:10, 1:5), c1%cx(-1:10, 1:5)[-1:5, 1:2, 2:*])
+  allocate(c2(9, 27))
+  allocate(varLocal(64))
   allocate(A:: var(5), cvar(10)[*])
 
 
   !ERROR: Coarray specification must not appear in ALLOCATE when allocatable object is not a coarray
   allocate(x1[*])
   !ERROR: Coarray specification must not appear in ALLOCATE when allocatable object is not a coarray
   allocate(x2(10)[*])
   !ERROR: Coarray specification must appear in ALLOCATE when allocatable object is a coarray