[flang] Enforce rest of semantic constraint C919

[klausler]

Summary

A reference to an allocatable or pointer component must be applied
to a scalar base object. (This is the second part of constraint C919;
the first part is already checked.)

[PeteSteinfeld]

Looks great!

flang/include/flang/Semantics/expression.h

private:
   MaybeExpr AnalyzeString(std::string &&, int kind);
   std::optional<Expr<SubscriptInteger>> AsSubscript(MaybeExpr &&);
   std::optional<Expr<SubscriptInteger>> TripletPart(
       const std::optional<parser::Subscript> &);
   std::optional<Subscript> AnalyzeSectionSubscript(
       const parser::SectionSubscript &);
   std::vector<Subscript> AnalyzeSectionSubscripts(
       const std::list<parser::SectionSubscript> &);
+  std::optional<Component> CreateComponent(
+      DataRef &&, const Symbol &, const semantics::Scope &);
   MaybeExpr Designate(DataRef &&);
   MaybeExpr CompleteSubscripts(ArrayRef &&);
   MaybeExpr ApplySubscripts(DataRef &&, std::vector<Subscript> &&);
   MaybeExpr TopLevelChecks(DataRef &&);
   std::optional<Expr<SubscriptInteger>> GetSubstringBound(
       const std::optional<parser::ScalarIntExpr> &);
   MaybeExpr AnalyzeDefinedOp(const parser::Name &, ActualArguments &&);
 

flang/lib/Semantics/expression.cpp

if (subscripts == 0) {
     return std::nullopt;
   } else if (Component * component{ref.base().UnwrapComponent()}) {
     int baseRank{component->base().Rank()};
     if (baseRank > 0) {
       int subscriptRank{0};
       for (const auto &expr : ref.subscript()) {
         subscriptRank += expr.Rank();
       }
-      if (subscriptRank > 0) {
+      if (subscriptRank > 0) { // C919a
         Say("Subscripts of component '%s' of rank-%d derived type "
             "array have rank %d but must all be scalar"_err_en_US,
             symbol.name(), baseRank, subscriptRank);
         return std::nullopt;
       }
     }
   } else if (const auto *object{
                  symbol.detailsIf<semantics::ObjectEntityDetails>()}) {

 
 // Top-level checks for data references.
 MaybeExpr ExpressionAnalyzer::TopLevelChecks(DataRef &&dataRef) {
   if (Component * component{std::get_if<Component>(&dataRef.u)}) {
     const Symbol &symbol{component->GetLastSymbol()};
     int componentRank{symbol.Rank()};
     if (componentRank > 0) {
       int baseRank{component->base().Rank()};
-      if (baseRank > 0) {
+      if (baseRank > 0) { // C919a
         Say("Reference to whole rank-%d component '%%%s' of "
             "rank-%d array of derived type is not allowed"_err_en_US,
             componentRank, symbol.name(), baseRank);
       }
     }
   }
   return Designate(std::move(dataRef));
 }
return std::visit(
           [](CoarrayRef &&coarrayRef) {
             return NamedEntity{coarrayRef.GetLastSymbol()};
           },
       },
       std::move(designator.u));
 }
 
 // Components of parent derived types are explicitly represented as such.
-static std::optional<Component> CreateComponent(
+std::optional<Component> ExpressionAnalyzer::CreateComponent(
     DataRef &&base, const Symbol &component, const semantics::Scope &scope) {
+  if (IsAllocatableOrPointer(component) && base.Rank() > 0) { // C919b
+    Say("An allocatable or pointer component reference must be applied to a scalar base"_err_en_US);
+  }
   if (&component.owner() == &scope) {
     return Component{std::move(base), component};
   }
   if (const semantics::Scope * parentScope{scope.GetDerivedTypeParent()}) {
     if (const Symbol * parentComponent{parentScope->GetSymbol()}) {
       return CreateComponent(
           DataRef{Component{std::move(base), *parentComponent}}, component,
           *parentScope);

flang/test/Semantics/deallocate01.f90

 Deallocate(x(2)%p)
 
 Deallocate(y(2)%p)
 
 Deallocate(pi)
 
 Deallocate(z%p)
 
+!ERROR: An allocatable or pointer component reference must be applied to a scalar base
 Deallocate(x%p, stat=s, errmsg=e)
-Deallocate(x%p, errmsg=e)
-Deallocate(x%p, stat=s)
+Deallocate(x, errmsg=e)
+Deallocate(x, stat=s)
 
-Deallocate(y%p, stat=s, errmsg=e)
-Deallocate(y%p, errmsg=e)
-Deallocate(y%p, stat=s)
+Deallocate(y, stat=s, errmsg=e)
+Deallocate(y, errmsg=e)
+Deallocate(y, stat=s)
 
 Deallocate(z, stat=s, errmsg=e)
 Deallocate(z, errmsg=e)
 Deallocate(z, stat=s)
 
-Deallocate(z, y%p, stat=s, errmsg=e)
-Deallocate(z, y%p, errmsg=e)
-Deallocate(z, y%p, stat=s)
+Deallocate(z, y, stat=s, errmsg=e)
+Deallocate(z, y, errmsg=e)
+Deallocate(z, y, stat=s)
 
 End Program