[flang] Fix CheckSpecificationExpr handling of associated names

[klausler]

Summary

Avoid a spurious error message about a dummy procedure reference
in a specification expression by restructuring the handling of
use-associated and host-associated symbols.

Updated to fix a circular dependence between shared library
binaries that was introduced by the original patch.

[awarzynski]

LGTM.

Thank you for resubmitting this. I tested with BUILD_SHARED_LIBS=On and it builds fine.

For our future selves: this fixes the issue that I reported here: https://reviews.llvm.org/D91209.

flang/include/flang/Semantics/scope.h

Scope &parent() {
     return parent_;
   }
   const Scope &parent() const {
     CHECK(&parent_ != this);
     return parent_;
   }
   Kind kind() const { return kind_; }
   bool IsGlobal() const { return kind_ == Kind::Global; }
-  bool IsModule() const; // only module, not submodule
-  bool IsSubmodule() const;
+  bool IsModule() const {
+    return kind_ == Kind::Module &&
+        !symbol_->get<ModuleDetails>().isSubmodule();
+  }
+  bool IsSubmodule() const {
+    return kind_ == Kind::Module && symbol_->get<ModuleDetails>().isSubmodule();
+  }
   bool IsDerivedType() const { return kind_ == Kind::DerivedType; }
   bool IsStmtFunction() const;
   bool IsParameterizedDerivedType() const;
   Symbol *symbol() { return symbol_; }
   const Symbol *symbol() const { return symbol_; }
 
   inline const Symbol *GetSymbol() const;
   const Scope *GetDerivedTypeParent() const;

flang/lib/Evaluate/check-expression.cpp

public:
   using Base::operator();
 
   Result operator()(const ProcedureDesignator &) const {
     return "dummy procedure argument";
   }
   Result operator()(const CoarrayRef &) const { return "coindexed reference"; }
 
   Result operator()(const semantics::Symbol &symbol) const {
-    if (semantics::IsNamedConstant(symbol)) {
+    const auto &ultimate{symbol.GetUltimate()};
+    if (semantics::IsNamedConstant(ultimate) || ultimate.owner().IsModule() ||
+        ultimate.owner().IsSubmodule()) {
       return std::nullopt;
-    } else if (scope_.IsDerivedType() && IsVariableName(symbol)) { // C750, C754
+    } else if (scope_.IsDerivedType() &&
+        IsVariableName(ultimate)) { // C750, C754
       return "derived type component or type parameter value not allowed to "
              "reference variable '"s +
-          symbol.name().ToString() + "'";
-    } else if (IsDummy(symbol)) {
-      if (symbol.attrs().test(semantics::Attr::OPTIONAL)) {
+          ultimate.name().ToString() + "'";
+    } else if (IsDummy(ultimate)) {
+      if (ultimate.attrs().test(semantics::Attr::OPTIONAL)) {
         return "reference to OPTIONAL dummy argument '"s +
-            symbol.name().ToString() + "'";
-      } else if (symbol.attrs().test(semantics::Attr::INTENT_OUT)) {
+            ultimate.name().ToString() + "'";
+      } else if (ultimate.attrs().test(semantics::Attr::INTENT_OUT)) {
         return "reference to INTENT(OUT) dummy argument '"s +
-            symbol.name().ToString() + "'";
-      } else if (symbol.has<semantics::ObjectEntityDetails>()) {
+            ultimate.name().ToString() + "'";
+      } else if (ultimate.has<semantics::ObjectEntityDetails>()) {
         return std::nullopt;
       } else {
         return "dummy procedure argument";
       }
-    } else if (symbol.has<semantics::UseDetails>() ||
-        symbol.has<semantics::HostAssocDetails>() ||
-        symbol.owner().kind() == semantics::Scope::Kind::Module) {
-      return std::nullopt;
     } else if (const auto *object{
-                   symbol.detailsIf<semantics::ObjectEntityDetails>()}) {
+                   ultimate.detailsIf<semantics::ObjectEntityDetails>()}) {
       // TODO: what about EQUIVALENCE with data in COMMON?
       // TODO: does this work for blank COMMON?
       if (object->commonBlock()) {
         return std::nullopt;
       }
     }
     for (const semantics::Scope *s{&scope_}; !s->IsGlobal();) {
       s = &s->parent();
-      if (s == &symbol.owner()) {
+      if (s == &ultimate.owner()) {
         return std::nullopt;
       }
     }
-    return "reference to local entity '"s + symbol.name().ToString() + "'";
+    return "reference to local entity '"s + ultimate.name().ToString() + "'";
   }
 
   Result operator()(const Component &x) const {
     // Don't look at the component symbol.
     return (*this)(x.base());
   }
   Result operator()(const DescriptorInquiry &) const {
     // Subtle: Uses of SIZE(), LBOUND(), &c. that are valid in specification

flang/lib/Semantics/scope.cpp

if (!subscripts.empty()) {
     ss << ')';
   }
   if (substringStart) {
     ss << '(' << *substringStart << ":)";
   }
   return ss.str();
 }
 
-bool Scope::IsModule() const {
-  return kind_ == Kind::Module && !symbol_->get<ModuleDetails>().isSubmodule();
-}
-bool Scope::IsSubmodule() const {
-  return kind_ == Kind::Module && symbol_->get<ModuleDetails>().isSubmodule();
-}
-
 Scope &Scope::MakeScope(Kind kind, Symbol *symbol) {
   return children_.emplace_back(*this, kind, symbol);
 }
 
 template <typename T>
 static std::vector<common::Reference<T>> GetSortedSymbols(
     std::map<SourceName, MutableSymbolRef> symbols) {
   std::vector<common::Reference<T>> result;

flang/test/Semantics/spec-expr.f90

 !   section subscript, substring starting point, substring ending point, and 
 !   type parameter value is a restricted expression
 subroutine s15()
   type :: dtype(param)
     integer, len :: param
     real, dimension((param + 2)) :: realField
   end type dtype
 end subroutine s15
+
+! Regression test: don't get confused by host association
+subroutine s16(n)
+  integer :: n
+ contains
+  subroutine inner(r)
+    real, dimension(n) :: r
+  end subroutine
+end subroutine s16