[flang] Expunge needless semantics::ProcInterface

[klausler]

Summary

The ProcInterface structure is used only by ProcEntityDetails; it represents
what a program might have put in parentheses in a procedure-declaration-stmt,
either the name of a procedure interface or a declaration-type-spec.

If a procedure entity has an implicit interface, the function result
type (if any) can be kept in EntityDetails::type_, which already exists
and is currently redundant for ProcEntityDetails symbols.

All that is really needed is a nullable Symbol pointer in ProcEntityDetails
to point to the procedure's explicit interface, when it has one.

Also, catch the case where a procedure has an explicit interface
and a program attempts to also give it a type.

[jeanPerier]

I feel sorry to bother you here because there is something odd with clang-format that is a bit unrelated to your patch.
My top of the tree clang-format agrees with the formatting of your patch, but the build bot clang format (and @PeteSteinfeld's clang-format).

I had a similar issue in one of my patch, it seems my clang-format and yours want the "*" in if (const Symbol *interface{proc.procInterface()}) next to the variable name (which makes more sense IMHO), while the build bot clang-format (and older clang format I could test) wants the "*" in the middle of two spaces if (const Symbol * interface{proc.procInterface()}). Given most of flang codebase is using the latter style, it may be better to stick with it, especially if it still is what the build bot expects.

[PeteSteinfeld]

In D140134#4000527, @jeanPerier wrote:

I feel sorry to bother you here because there is something odd with clang-format that is a bit unrelated to your patch.
My top of the tree clang-format agrees with the formatting of your patch, but the build bot clang format (and @PeteSteinfeld's clang-format).

I had a similar issue in one of my patch, it seems my clang-format and yours want the "*" in if (const Symbol *interface{proc.procInterface()}) next to the variable name (which makes more sense IMHO), while the build bot clang-format (and older clang format I could test) wants the "*" in the middle of two spaces if (const Symbol * interface{proc.procInterface()}). Given most of flang codebase is using the latter style, it may be better to stick with it, especially if it still is what the build bot expects.

I'm not sure if this is documented anywhere, but I believe that the version of clang-format that the build bots use gets built from the latest released sources. The latest released version of llvm has the tag "llvmorg-15.0.6". I'd guess that if you build clang-format from that release, you'll match the build bots.

[klausler]

I have always been using the top-of-tree clang-format.

Agree that the extra space after the '*' in some but not all pointer declarations looks weird. There have also been issues with spaces in a few braced declarations.

flang/include/flang/Evaluate/characteristics.h

public:
   DEFAULT_CONSTRUCTORS_AND_ASSIGNMENTS(TypeAndShape)
 
   bool operator==(const TypeAndShape &) const;
   bool operator!=(const TypeAndShape &that) const { return !(*this == that); }
 
   static std::optional<TypeAndShape> Characterize(
       const semantics::Symbol &, FoldingContext &);
   static std::optional<TypeAndShape> Characterize(
-      const semantics::ProcInterface &, FoldingContext &);
-  static std::optional<TypeAndShape> Characterize(
       const semantics::DeclTypeSpec &, FoldingContext &);
   static std::optional<TypeAndShape> Characterize(
       const ActualArgument &, FoldingContext &);
 
   // Handle Expr<T> & Designator<T>
   template <typename A>
   static std::optional<TypeAndShape> Characterize(
       const A &x, FoldingContext &context) {

flang/include/flang/Semantics/symbol.h

 class ProcEntityDetails : public EntityDetails, public WithPassArg {
 public:
   ProcEntityDetails() = default;
   explicit ProcEntityDetails(EntityDetails &&);
   ProcEntityDetails(const ProcEntityDetails &) = default;
   ProcEntityDetails(ProcEntityDetails &&) = default;
   ProcEntityDetails &operator=(const ProcEntityDetails &) = default;
 
-  const ProcInterface &interface() const { return interface_; }
-  ProcInterface &interface() { return interface_; }
-  void set_interface(const ProcInterface &interface) { interface_ = interface; }
-  bool IsInterfaceSet() {
-    return interface_.symbol() != nullptr || interface_.type() != nullptr;
-  }
+  const Symbol *procInterface() const { return procInterface_; }
+  void set_procInterface(const Symbol &sym) { procInterface_ = &sym; }
+  bool IsInterfaceSet() { return procInterface_ || type(); }
   inline bool HasExplicitInterface() const;
 
   // Be advised: !init().has_value() => uninitialized pointer,
   // while *init() == nullptr => explicit NULL() initialization.
   std::optional<const Symbol *> init() const { return init_; }
   void set_init(const Symbol &symbol) { init_ = &symbol; }
   void set_init(std::nullptr_t) { init_ = nullptr; }
 
 private:
-  ProcInterface interface_;
+  const Symbol *procInterface_{nullptr};
   std::optional<const Symbol *> init_;
   friend llvm::raw_ostream &operator<<(
       llvm::raw_ostream &, const ProcEntityDetails &);
 };
 
 // These derived type details represent the characteristics of a derived
 // type definition that are shared by all instantiations of that type.
 // The DerivedTypeSpec instances whose type symbols share these details
return common::visit(
               return x.symbol().RankImpl(depth);
             },
             [&](const UseDetails &x) { return x.symbol().RankImpl(depth); },
             [&](const HostAssocDetails &x) {
               return x.symbol().RankImpl(depth);
             },
             [](const ObjectEntityDetails &oed) { return oed.shape().Rank(); },
             [&](const ProcEntityDetails &ped) {
-              const Symbol *iface{ped.interface().symbol()};
+              const Symbol *iface{ped.procInterface()};
               return iface ? iface->RankImpl(depth) : 0;
             },
             [](const AssocEntityDetails &aed) {
               if (const auto &expr{aed.expr()}) {
                 if (auto assocRank{aed.rank()}) {
                   return *assocRank;
                 } else {
                   return expr->Rank();
private:
   }
 };
 
 // Define a few member functions here in the header so that they
 // can be used by lib/Evaluate without inducing a dependence cycle
 // between the two shared libraries.
 
 inline bool ProcEntityDetails::HasExplicitInterface() const {
-  if (auto *symbol{interface_.symbol()}) {
-    return symbol->HasExplicitInterface();
-  }
-  return false;
+  return procInterface_ && procInterface_->HasExplicitInterface();
 }
 
 inline Symbol &Symbol::GetUltimate() {
   return const_cast<Symbol &>(const_cast<const Symbol *>(this)->GetUltimate());
 }
 inline const Symbol &Symbol::GetUltimate() const {
   if (const auto *details{detailsIf<UseDetails>()}) {
     return details->symbol().GetUltimate();
return common::visit(
       common::visitors{
           [](const EntityDetails &x) { return x.type(); },
           [](const ObjectEntityDetails &x) { return x.type(); },
           [](const AssocEntityDetails &x) { return x.type(); },
           [&](const SubprogramDetails &x) {
             return x.isFunction() ? x.result().GetTypeImpl(depth) : nullptr;
           },
           [&](const ProcEntityDetails &x) {
-            const Symbol *symbol{x.interface().symbol()};
-            return symbol ? symbol->GetTypeImpl(depth) : x.interface().type();
+            const Symbol *symbol{x.procInterface()};
+            return symbol ? symbol->GetTypeImpl(depth) : x.type();
           },
           [&](const ProcBindingDetails &x) {
             return x.symbol().GetTypeImpl(depth);
           },
           [](const TypeParamDetails &x) { return x.type(); },
           [&](const UseDetails &x) { return x.symbol().GetTypeImpl(depth); },
           [&](const HostAssocDetails &x) {
             return x.symbol().GetTypeImpl(depth);

flang/include/flang/Semantics/type.h

 private:
   Category category_;
   std::variant<std::monostate, NumericTypeSpec, LogicalTypeSpec,
       CharacterTypeSpec, DerivedTypeSpec>
       typeSpec_;
 };
 llvm::raw_ostream &operator<<(llvm::raw_ostream &, const DeclTypeSpec &);
 
-// This represents a proc-interface in the declaration of a procedure or
-// procedure component. It comprises a symbol that represents the specific
-// interface or a decl-type-spec that represents the function return type.
-class ProcInterface {
-public:
-  const Symbol *symbol() const { return symbol_; }
-  const DeclTypeSpec *type() const { return type_; }
-  void set_symbol(const Symbol &symbol);
-  void set_type(const DeclTypeSpec &type);
-
-private:
-  const Symbol *symbol_{nullptr};
-  const DeclTypeSpec *type_{nullptr};
-};
-
 // Define some member functions here in the header so that they can be used by
 // lib/Evaluate without link-time dependency on Semantics.
 
 inline bool ArraySpec::IsExplicitShape() const {
   return CheckAll([](const ShapeSpec &x) { return x.ubound().isExplicit(); });
 }
 inline bool ArraySpec::CanBeAssumedShape() const {
   return CheckAll([](const ShapeSpec &x) { return x.ubound().isColon(); });

flang/lib/Evaluate/call.cpp

int ProcedureDesignator::Rank() const {
   }
   return 0;
 }
 
 const Symbol *ProcedureDesignator::GetInterfaceSymbol() const {
   if (const Symbol * symbol{GetSymbol()}) {
     const Symbol &ultimate{symbol->GetUltimate()};
     if (const auto *proc{ultimate.detailsIf<semantics::ProcEntityDetails>()}) {
-      return proc->interface().symbol();
+      return proc->procInterface();
     } else if (const auto *binding{
                    ultimate.detailsIf<semantics::ProcBindingDetails>()}) {
       return &binding->symbol();
     } else if (ultimate.has<semantics::SubprogramDetails>()) {
       return &ultimate;
     }
   }
   return nullptr;

flang/lib/Evaluate/characteristics.cpp

 }
 
 std::optional<TypeAndShape> TypeAndShape::Characterize(
     const semantics::Symbol &symbol, FoldingContext &context) {
   const auto &ultimate{symbol.GetUltimate()};
   return common::visit(
       common::visitors{
           [&](const semantics::ProcEntityDetails &proc) {
-            const semantics::ProcInterface &interface { proc.interface() };
-            if (interface.type()) {
-              return Characterize(*interface.type(), context);
-            } else if (interface.symbol()) {
-              return Characterize(*interface.symbol(), context);
+            if (proc.procInterface()) {
+              return Characterize(*proc.procInterface(), context);
+            } else if (proc.type()) {
+              return Characterize(*proc.type(), context);
             } else {
               return std::optional<TypeAndShape>{};
             }
           },
           [&](const semantics::AssocEntityDetails &assoc) {
             return Characterize(assoc, context);
           },
           [&](const semantics::ProcBindingDetails &binding) {
return common::visit(
               // declaration checking in Semantics.
               auto intrinsic{context.intrinsics().IsSpecificIntrinsicFunction(
                   symbol.name().ToString())};
               if (intrinsic && intrinsic->isRestrictedSpecific) {
                 intrinsic.reset(); // Exclude intrinsics from table 16.3.
               }
               return intrinsic;
             }
-            const semantics::ProcInterface &interface { proc.interface() };
-            if (const semantics::Symbol * interfaceSymbol{interface.symbol()}) {
+            if (const semantics::Symbol *
+                interfaceSymbol{proc.procInterface()}) {
               auto interface {
                 CharacterizeProcedure(*interfaceSymbol, context, seenProcs)
               };
               if (interface && IsPointer(symbol)) {
                 interface->attrs.reset(Procedure::Attr::Elemental);
               }
               return interface;
             } else {
               result.attrs.set(Procedure::Attr::ImplicitInterface);
-              const semantics::DeclTypeSpec *type{interface.type()};
+              const semantics::DeclTypeSpec *type{proc.type()};
               if (symbol.test(semantics::Symbol::Flag::Subroutine)) {
                 // ignore any implicit typing
                 result.attrs.set(Procedure::Attr::Subroutine);
               } else if (type) {
                 if (auto resultType{DynamicType::From(*type)}) {
                   result.functionResult = FunctionResult{*resultType};
                 } else {
                   return std::nullopt;

flang/lib/Evaluate/shape.cpp

return common::visit(
               NamedEntity base{symbol};
               return Result{CreateShape(n, base)};
             }
           },
           [](const semantics::EntityDetails &) {
             return ScalarShape(); // no dimensions seen
           },
           [&](const semantics::ProcEntityDetails &proc) {
-            if (const Symbol * interface{proc.interface().symbol()}) {
+            if (const Symbol * interface{proc.procInterface()}) {
               return (*this)(*interface);
             } else {
               return ScalarShape();
             }
           },
           [&](const semantics::AssocEntityDetails &assoc) {
             NamedEntity base{symbol};
             if (assoc.rank()) { // SELECT RANK case

flang/lib/Evaluate/tools.cpp

if (symbol.has<ObjectEntityDetails>()) {
     return false;
   }
 }
 
 bool IsPureProcedure(const Symbol &original) {
   // An ENTRY is pure if its containing subprogram is
   const Symbol &symbol{DEREF(GetMainEntry(&original.GetUltimate()))};
   if (const auto *procDetails{symbol.detailsIf<ProcEntityDetails>()}) {
-    if (const Symbol * procInterface{procDetails->interface().symbol()}) {
+    if (procDetails->procInterface()) {
       // procedure with a pure interface
-      return IsPureProcedure(*procInterface);
+      return IsPureProcedure(*procDetails->procInterface());
     }
   } else if (const auto *details{symbol.detailsIf<ProcBindingDetails>()}) {
     return IsPureProcedure(details->symbol());
   } else if (!IsProcedure(symbol)) {
     return false;
   }
   if (IsStmtFunction(symbol)) {
     // Section 15.7(1) states that a statement function is PURE if it does not
bool IsPureProcedure(const Scope &scope) {
   const Symbol *symbol{scope.GetSymbol()};
   return symbol && IsPureProcedure(*symbol);
 }
 
 bool IsElementalProcedure(const Symbol &original) {
   // An ENTRY is elemental if its containing subprogram is
   const Symbol &symbol{DEREF(GetMainEntry(&original.GetUltimate()))};
   if (const auto *procDetails{symbol.detailsIf<ProcEntityDetails>()}) {
-    if (const Symbol * procInterface{procDetails->interface().symbol()}) {
+    if (const Symbol * procInterface{procDetails->procInterface()}) {
       // procedure with an elemental interface, ignoring the elemental
       // aspect of intrinsic functions
       return !procInterface->attrs().test(Attr::INTRINSIC) &&
           IsElementalProcedure(*procInterface);
     }
   } else if (const auto *details{symbol.detailsIf<ProcBindingDetails>()}) {
     return !details->symbol().attrs().test(Attr::INTRINSIC) &&
         IsElementalProcedure(details->symbol());
   } else if (!IsProcedure(symbol)) {
     return false;
   }
   return symbol.attrs().test(Attr::ELEMENTAL);
 }
 
 bool IsFunction(const Symbol &symbol) {
   const Symbol &ultimate{symbol.GetUltimate()};
   return ultimate.test(Symbol::Flag::Function) ||
       (!ultimate.test(Symbol::Flag::Subroutine) &&
           common::visit(
               common::visitors{
                   [](const SubprogramDetails &x) { return x.isFunction(); },
                   [](const ProcEntityDetails &x) {
-                    const auto &ifc{x.interface()};
-                    return ifc.type() ||
-                        (ifc.symbol() && IsFunction(*ifc.symbol()));
+                    const Symbol *ifc{x.procInterface()};
+                    return x.type() || (ifc && IsFunction(*ifc));
                   },
                   [](const ProcBindingDetails &x) {
                     return IsFunction(x.symbol());
                   },
                   [](const auto &) { return false; },
               },
               ultimate.details()));
 }
static const Symbol *FindFunctionResult(
   if (!seen.insert(root).second) {
     return nullptr; // don't loop
   }
   return common::visit(
       common::visitors{[](const SubprogramDetails &subp) {
                          return subp.isFunction() ? &subp.result() : nullptr;
                        },
           [&](const ProcEntityDetails &proc) {
-            const Symbol *iface{proc.interface().symbol()};
+            const Symbol *iface{proc.procInterface()};
             return iface ? FindFunctionResult(*iface, seen) : nullptr;
           },
           [&](const ProcBindingDetails &binding) {
             return FindFunctionResult(binding.symbol(), seen);
           },
           [](const auto &) -> const Symbol * { return nullptr; }},
       root.details());
 }

flang/lib/Semantics/check-declarations.cpp

if (!symbol.attrs().test(Attr::POINTER) && // C843
       messages_.Say("A dummy procedure without the POINTER attribute"
                     " may not have an INTENT attribute"_err_en_US);
     }
     if (InElemental()) { // C15100
       messages_.Say(
           "An ELEMENTAL subprogram may not have a dummy procedure"_err_en_US);
     }
     const Symbol *interface {
-      details.interface().symbol()
+      details.procInterface()
     };
     if (!symbol.attrs().test(Attr::INTRINSIC) &&
         (IsElementalProcedure(symbol) ||
             (interface && !interface->attrs().test(Attr::INTRINSIC) &&
                 IsElementalProcedure(*interface)))) {
       // There's no explicit constraint or "shall" that we can find in the
       // standard for this check, but it seems to be implied in multiple
       // sites, and ELEMENTAL non-intrinsic actual arguments *are*
messages_.Say("OPTIONAL attribute may apply only to a dummy "
                   "argument"_err_en_US); // C849
   } else if (symbol.owner().IsDerivedType()) {
     if (!symbol.attrs().test(Attr::POINTER)) { // C756
       const auto &name{symbol.name()};
       messages_.Say(name,
           "Procedure component '%s' must have POINTER attribute"_err_en_US,
           name);
     }
-    CheckPassArg(symbol, details.interface().symbol(), details);
+    CheckPassArg(symbol, details.procInterface(), details);
   }
   if (symbol.attrs().test(Attr::POINTER)) {
     CheckPointerInitialization(symbol);
-    if (const Symbol *interface{details.interface().symbol()}) {
+    if (const Symbol * interface{details.procInterface()}) {
       const Symbol &ultimate{interface->GetUltimate()};
       if (ultimate.attrs().test(Attr::INTRINSIC)) {
         if (const auto intrinsic{
                 context_.intrinsics().IsSpecificIntrinsicFunction(
                     ultimate.name().ToString())};
             !intrinsic || intrinsic->isRestrictedSpecific) { // C1515
           messages_.Say(
               "Intrinsic procedure '%s' is not an unrestricted specific "
if (!pair.second) {
           msg->Attach(other.name(), "Conflicting declaration"_en_US);
         }
         context_.SetError(symbol);
         context_.SetError(other);
       }
     }
   }
   if (const auto *proc{symbol.detailsIf<ProcEntityDetails>()}) {
-    if (!proc->interface().symbol() ||
-        !proc->interface().symbol()->attrs().test(Attr::BIND_C)) {
+    if (!proc->procInterface() ||
+        !proc->procInterface()->attrs().test(Attr::BIND_C)) {
       messages_.Say(symbol.name(),
           "An interface name with BIND attribute must be specified if the BIND attribute is specified in a procedure declaration statement"_err_en_US);
       context_.SetError(symbol);
     }
   } else if (const auto *derived{symbol.detailsIf<DerivedTypeDetails>()}) {
     if (derived->sequence()) { // C1801
       messages_.Say(symbol.name(),
           "A derived type with the BIND attribute cannot have the SEQUENCE attribute"_err_en_US);

flang/lib/Semantics/mod-file.cpp

void ModFileWriter::PutProcEntity(llvm::raw_ostream &os, const Symbol &symbol) {
   if (symbol.attrs().test(Attr::INTRINSIC)) {
     os << "intrinsic::" << symbol.name() << '\n';
     if (!isSubmodule_ && symbol.attrs().test(Attr::PRIVATE)) {
       os << "private::" << symbol.name() << '\n';
     }
     return;
   }
   const auto &details{symbol.get<ProcEntityDetails>()};
-  const ProcInterface &interface { details.interface() };
   Attrs attrs{symbol.attrs()};
   if (details.passName()) {
     attrs.reset(Attr::PASS);
   }
   PutEntity(
       os, symbol,
       [&]() {
         os << "procedure(";
-        if (interface.symbol()) {
-          os << interface.symbol()->name();
-        } else if (interface.type()) {
-          PutType(os, *interface.type());
+        if (details.procInterface()) {
+          os << details.procInterface()->name();
+        } else if (details.type()) {
+          PutType(os, *details.type());
         }
         os << ')';
         PutPassName(os, details.passName());
       },
       attrs);
   os << '\n';
 }
 
for (const auto &pair : scope_) {
     } else if (symbol.has<SubprogramDetails>()) {
       // An internal subprogram is needed if it is used as interface
       // for a dummy or return value procedure.
       bool needed{false};
       const auto hasInterface{[&symbol](const Symbol *s) -> bool {
         // Is 's' a procedure with interface 'symbol'?
         if (s) {
           if (const auto *sDetails{s->detailsIf<ProcEntityDetails>()}) {
-            const ProcInterface &sInterface{sDetails->interface()};
-            if (sInterface.symbol() == &symbol) {
+            if (sDetails->procInterface() == &symbol) {
               return true;
             }
           }
         }
         return false;
       }};
       for (const Symbol *dummyArg : details.dummyArgs()) {
         needed = needed || hasInterface(dummyArg);
common::visit(common::visitors{
                       }
                     },
                     [this](const CommonBlockDetails &details) {
                       for (const auto &object : details.objects()) {
                         DoSymbol(*object);
                       }
                     },
                     [this](const ProcEntityDetails &details) {
-                      if (const Symbol * symbol{details.interface().symbol()}) {
-                        DoSymbol(*symbol);
+                      if (details.procInterface()) {
+                        DoSymbol(*details.procInterface());
+                      } else {
+                        DoType(details.type());
                       }
-                      DoType(details.interface().type());
                     },
                     [](const auto &) {},
                 },
       symbol.details());
   if (!symbol.has<UseDetails>()) {
     DoType(symbol.GetType());
   }
   if (!scope.IsDerivedType()) {

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

 void SymbolMapper::MapSymbolExprs(Symbol &symbol) {
   if (auto *object{symbol.detailsIf<ObjectEntityDetails>()}) {
     if (const DeclTypeSpec *type{object->type()}) {
       if (const DeclTypeSpec *newType{MapType(*type)}) {
         object->ReplaceType(*newType);
       }
     }
   }
-  common::visit(common::visitors{[&](ObjectEntityDetails &object) {
-                                   for (ShapeSpec &spec : object.shape()) {
-                                     MapShapeSpec(spec);
-                                   }
-                                   for (ShapeSpec &spec : object.coshape()) {
-                                     MapShapeSpec(spec);
-                                   }
-                                 },
-                    [&](ProcEntityDetails &proc) {
-                      if (const Symbol *mappedSymbol{
-                              MapInterface(proc.interface().symbol())}) {
-                        proc.interface().set_symbol(*mappedSymbol);
-                      } else if (const DeclTypeSpec *mappedType{
-                                     MapType(proc.interface().type())}) {
-                        proc.interface().set_type(*mappedType);
-                      }
-                      if (proc.init()) {
-                        if (const Symbol *mapped{MapSymbol(*proc.init())}) {
-                          proc.set_init(*mapped);
-                        }
-                      }
-                    },
-                    [&](const HostAssocDetails &hostAssoc) {
-                      if (const Symbol *mapped{MapSymbol(hostAssoc.symbol())}) {
-                        symbol.set_details(HostAssocDetails{*mapped});
-                      }
-                    },
-                    [](const auto &) {}},
+  common::visit(
+      common::visitors{[&](ObjectEntityDetails &object) {
+            if (const Symbol *
+                mappedSymbol{MapInterface(proc.procInterface())}) {
+              proc.set_procInterface(*mappedSymbol);
+            } else if (const DeclTypeSpec * mappedType{MapType(proc.type())}) {
+              proc.set_type(*mappedType);
+              if (const Symbol * mapped{MapSymbol(*proc.init())}) {
+            if (const Symbol * mapped{MapSymbol(hostAssoc.symbol())}) {
       symbol.details());
 }
 
 const Symbol *SymbolMapper::MapSymbol(const Symbol &symbol) const {
   if (auto iter{map_.symbolMap.find(&symbol)}; iter != map_.symbolMap.end()) {
     return iter->second;
   }
   return nullptr;

flang/lib/Semantics/resolve-names.cpp

private:
   // Set when walking DATA & array constructor implied DO loop bounds
   // to warn about use of the implied DO intex therein.
   std::optional<SourceName> checkIndexUseInOwnBounds_;
   bool hasBindCName_{false};
 
   bool HandleAttributeStmt(Attr, const std::list<parser::Name> &);
   Symbol &HandleAttributeStmt(Attr, const parser::Name &);
   Symbol &DeclareUnknownEntity(const parser::Name &, Attrs);
-  Symbol &DeclareProcEntity(const parser::Name &, Attrs, const ProcInterface &);
+  Symbol &DeclareProcEntity(
+      const parser::Name &, Attrs, const Symbol *interface);
   void SetType(const parser::Name &, const DeclTypeSpec &);
   std::optional<DerivedTypeSpec> ResolveDerivedType(const parser::Name &);
   std::optional<DerivedTypeSpec> ResolveExtendsType(
       const parser::Name &, const parser::Name *);
   Symbol *MakeTypeSymbol(const SourceName &, Details &&);
   Symbol *MakeTypeSymbol(const parser::Name &, Details &&);
   bool OkToAddComponent(const parser::Name &, const Symbol * = nullptr);
   ParamValue GetParamValue(
if (context().HasError(symbol) || symbol.has<T>()) {
             name, symbol, "'%s' is already declared as an object"_err_en_US);
       }
     } else if (!CheckPossibleBadForwardRef(symbol)) {
       SayAlreadyDeclared(name, symbol);
     }
     context().SetError(symbol);
     return symbol;
   }
-  bool HasCycle(const Symbol &, const ProcInterface &);
+  bool HasCycle(const Symbol &, const Symbol *interface);
 };
 
 // Resolve construct entities and statement entities.
 // Check that construct names don't conflict with other names.
 class ConstructVisitor : public virtual DeclarationVisitor {
 public:
   bool Pre(const parser::ConcurrentHeader &);
   bool Pre(const parser::LocalitySpec::Local &);
static bool NeedsType(const Symbol &symbol) {
   return !symbol.GetType() &&
       common::visit(common::visitors{
                         [](const EntityDetails &) { return true; },
                         [](const ObjectEntityDetails &) { return true; },
                         [](const AssocEntityDetails &) { return true; },
                         [&](const ProcEntityDetails &p) {
                           return symbol.test(Symbol::Flag::Function) &&
                               !symbol.attrs().test(Attr::INTRINSIC) &&
-                              !p.interface().type() && !p.interface().symbol();
+                              !p.type() && !p.procInterface();
                         },
                         [](const auto &) { return false; },
                     },
           symbol.details());
 }
 
 void ScopeHandler::ApplyImplicitRules(
     Symbol &symbol, bool allowForwardReference) {
if (symbol.attrs().test(Attr::EXTERNAL)) {
       ConvertToProcEntity(symbol);
     }
     SetBindNameOn(symbol);
     return symbol;
   }
 }
 
 bool DeclarationVisitor::HasCycle(
-    const Symbol &procSymbol, const ProcInterface &interface) {
+    const Symbol &procSymbol, const Symbol *interface) {
   SourceOrderedSymbolSet procsInCycle;
   procsInCycle.insert(procSymbol);
-  const ProcInterface *thisInterface{&interface};
-  bool haveInterface{true};
-  while (haveInterface) {
-    haveInterface = false;
-    if (const Symbol * interfaceSymbol{thisInterface->symbol()}) {
-      if (procsInCycle.count(*interfaceSymbol) > 0) {
-        for (const auto &procInCycle : procsInCycle) {
-          Say(procInCycle->name(),
-              "The interface for procedure '%s' is recursively "
-              "defined"_err_en_US,
-              procInCycle->name());
-          context().SetError(*procInCycle);
-        }
-        return true;
-      } else if (const auto *procDetails{
-                     interfaceSymbol->detailsIf<ProcEntityDetails>()}) {
-        haveInterface = true;
-        thisInterface = &procDetails->interface();
-        procsInCycle.insert(*interfaceSymbol);
-      }
+  while (interface) {
+    if (procsInCycle.count(*interface) > 0) {
+                   interface->detailsIf<ProcEntityDetails>()}) {
+      procsInCycle.insert(*interface);
+      interface = procDetails->procInterface();
+    } else {
+      break;
     }
   }
   return false;
 }
 
 Symbol &DeclarationVisitor::DeclareProcEntity(
-    const parser::Name &name, Attrs attrs, const ProcInterface &interface) {
+    const parser::Name &name, Attrs attrs, const Symbol *interface) {
   Symbol &symbol{DeclareEntity<ProcEntityDetails>(name, attrs)};
   if (auto *details{symbol.detailsIf<ProcEntityDetails>()}) {
     if (details->IsInterfaceSet()) {
       SayWithDecl(name, symbol,
           "The interface for procedure '%s' has already been "
           "declared"_err_en_US);
       context().SetError(symbol);
     } else if (HasCycle(symbol, interface)) {
       return symbol;
-    } else if (interface.type()) {
-      symbol.set(Symbol::Flag::Function);
-    } else if (interface.symbol()) {
-      if (interface.symbol()->test(Symbol::Flag::Function)) {
+    } else if (interface) {
+      details->set_procInterface(*interface);
+      if (interface->test(Symbol::Flag::Function)) {
         symbol.set(Symbol::Flag::Function);
-      } else if (interface.symbol()->test(Symbol::Flag::Subroutine)) {
+      } else if (interface->test(Symbol::Flag::Subroutine)) {
         symbol.set(Symbol::Flag::Subroutine);
       }
+    } else if (auto *type{GetDeclTypeSpec()}) {
+      SetType(name, *type);
+      symbol.set(Symbol::Flag::Function);
     }
-    details->set_interface(interface);
     SetBindNameOn(symbol);
     SetPassNameOn(symbol);
   }
   return symbol;
 }
 
 Symbol &DeclarationVisitor::DeclareObjectEntity(
     const parser::Name &name, Attrs attrs) {

 void DeclarationVisitor::Post(const parser::ProcInterface &x) {
   if (auto *name{std::get_if<parser::Name>(&x.u)}) {
     interfaceName_ = name;
     NoteInterfaceName(*name);
   }
 }
 void DeclarationVisitor::Post(const parser::ProcDecl &x) {
   const auto &name{std::get<parser::Name>(x.t)};
-  ProcInterface interface;
+  const Symbol *procInterface{nullptr};
   if (interfaceName_) {
-    interface.set_symbol(*interfaceName_->symbol);
-  } else if (auto *type{GetDeclTypeSpec()}) {
-    interface.set_type(*type);
+    procInterface = interfaceName_->symbol;
   }
   auto attrs{HandleSaveName(name.source, GetAttrs())};
   DerivedTypeDetails *dtDetails{nullptr};
   if (Symbol * symbol{currScope().symbol()}) {
     dtDetails = symbol->detailsIf<DerivedTypeDetails>();
   }
   if (!dtDetails) {
     attrs.set(Attr::EXTERNAL);
   }
-  Symbol &symbol{DeclareProcEntity(name, attrs, interface)};
+  Symbol &symbol{DeclareProcEntity(name, attrs, procInterface)};
   symbol.ReplaceName(name.source);
   if (dtDetails) {
     dtDetails->add_component(symbol);
   }
   if (hasBindCName_ && (IsPointer(symbol) || IsDummy(symbol))) {
     Say(symbol.name(),
         "BIND(C) procedure with NAME= specified can neither have POINTER attribute nor be a dummy procedure"_err_en_US);
   }
Symbol &symbol{
         MakeSymbol(InclusiveScope(), name.source, Attrs{Attr::INTRINSIC})};
     CHECK(interface->functionResult.has_value());
     evaluate::DynamicType dyType{
         DEREF(interface->functionResult->GetTypeAndShape()).type()};
     CHECK(common::IsNumericTypeCategory(dyType.category()));
     const DeclTypeSpec &typeSpec{
         MakeNumericType(dyType.category(), dyType.kind())};
     ProcEntityDetails details;
-    ProcInterface procInterface;
-    procInterface.set_type(typeSpec);
-    details.set_interface(procInterface);
+    details.set_type(typeSpec);
     symbol.set_details(std::move(details));
     symbol.set(Symbol::Flag::Function);
     if (interface->IsElemental()) {
       SetExplicitAttr(symbol, Attr::ELEMENTAL);
     }
     if (interface->IsPure()) {
       SetExplicitAttr(symbol, Attr::PURE);
     }
if (type.category() == DeclTypeSpec::Character) {
       SetType(name,
           currScope().MakeCharacterType(std::move(length), std::move(kind)));
       return;
     } else { // C753
       Say(name,
           "A length specifier cannot be used to declare the non-character entity '%s'"_err_en_US);
     }
   }
+  if (auto *proc{symbol.detailsIf<ProcEntityDetails>()}) {
+    if (proc->procInterface()) {
+      Say(name,
+          "'%s' has an explicit interface and may not also have a type"_err_en_US);
+      context().SetError(symbol);
+      return;
+    }
+  }
   auto *prevType{symbol.GetType()};
   if (!prevType) {
     symbol.SetType(type);
   } else if (symbol.has<UseDetails>()) {
     // error recovery case, redeclaration of use-associated name
   } else if (HadForwardRef(symbol)) {
     // error recovery after use of host-associated name
   } else if (!symbol.test(Symbol::Flag::Implicit)) {

 static bool NeedsExplicitType(const Symbol &symbol) {
   if (symbol.has<UnknownDetails>()) {
     return true;
   } else if (const auto *details{symbol.detailsIf<EntityDetails>()}) {
     return !details->type();
   } else if (const auto *details{symbol.detailsIf<ObjectEntityDetails>()}) {
     return !details->type();
   } else if (const auto *details{symbol.detailsIf<ProcEntityDetails>()}) {
-    return !details->interface().symbol() && !details->interface().type();
+    return !details->procInterface() && !details->type();
   } else {
     return false;
   }
 }
 
 bool ResolveNamesVisitor::Pre(const parser::SpecificationPart &x) {
   const auto &[accDecls, ompDecls, compilerDirectives, useStmts, importStmts,
       implicitPart, decls] = x.t;

flang/lib/Semantics/symbol.cpp

void EntityDetails::set_type(const DeclTypeSpec &type) {
   CHECK(!type_);
   type_ = &type;
 }
 
 void AssocEntityDetails::set_rank(int rank) { rank_ = rank; }
 void EntityDetails::ReplaceType(const DeclTypeSpec &type) { type_ = &type; }
 
 ObjectEntityDetails::ObjectEntityDetails(EntityDetails &&d)
-    : EntityDetails(d) {}
+    : EntityDetails(std::move(d)) {}
 
 void ObjectEntityDetails::set_shape(const ArraySpec &shape) {
   CHECK(shape_.empty());
   for (const auto &shapeSpec : shape) {
     shape_.push_back(shapeSpec);
   }
 }
 void ObjectEntityDetails::set_coshape(const ArraySpec &coshape) {
   CHECK(coshape_.empty());
   for (const auto &shapeSpec : coshape) {
     coshape_.push_back(shapeSpec);
   }
 }
 
-ProcEntityDetails::ProcEntityDetails(EntityDetails &&d) : EntityDetails(d) {
-  if (type()) {
-    interface_.set_type(*type());
-  }
-}
+ProcEntityDetails::ProcEntityDetails(EntityDetails &&d)
+    : EntityDetails(std::move(d)) {}
 
 UseErrorDetails::UseErrorDetails(const UseDetails &useDetails) {
   add_occurrence(useDetails.location(), *GetUsedModule(useDetails).scope());
 }
 UseErrorDetails &UseErrorDetails::add_occurrence(
     const SourceName &location, const Scope &module) {
   occurrences_.push_back(std::make_pair(location, &module));
   return *this;
void Symbol::ReplaceName(const SourceName &name) {
   name_ = name;
 }
 
 void Symbol::SetType(const DeclTypeSpec &type) {
   common::visit(common::visitors{
                     [&](EntityDetails &x) { x.set_type(type); },
                     [&](ObjectEntityDetails &x) { x.set_type(type); },
                     [&](AssocEntityDetails &x) { x.set_type(type); },
-                    [&](ProcEntityDetails &x) { x.interface().set_type(type); },
+                    [&](ProcEntityDetails &x) { x.set_type(type); },
                     [&](TypeParamDetails &x) { x.set_type(type); },
                     [](auto &) {},
                 },
       details_);
 }
 
 template <typename T>
 constexpr bool HasBindName{std::is_convertible_v<T, const WithBindName *>};
if (auto assocRank{x.rank()}) {
     os << " rank: " << *assocRank;
   }
   DumpExpr(os, "expr", x.expr());
   return os;
 }
 
 llvm::raw_ostream &operator<<(
     llvm::raw_ostream &os, const ProcEntityDetails &x) {
-  if (auto *symbol{x.interface_.symbol()}) {
-    os << ' ' << symbol->name();
+  if (x.procInterface_) {
+    os << ' ' << x.procInterface_->name();
   } else {
-    DumpType(os, x.interface_.type());
+    DumpType(os, x.type());
   }
   DumpOptional(os, "bindName", x.bindName());
   DumpOptional(os, "passName", x.passName());
   if (x.init()) {
     if (const Symbol * target{*x.init()}) {
       os << " => " << target->name();
     } else {
       os << " => NULL()";

flang/lib/Semantics/tools.cpp

 }
 
 bool IsPointerDummy(const Symbol &symbol) {
   return IsPointer(symbol) && IsDummy(symbol);
 }
 
 bool IsBindCProcedure(const Symbol &symbol) {
   if (const auto *procDetails{symbol.detailsIf<ProcEntityDetails>()}) {
-    if (const Symbol * procInterface{procDetails->interface().symbol()}) {
+    if (procDetails->procInterface()) {
       // procedure component with a BIND(C) interface
-      return IsBindCProcedure(*procInterface);
+      return IsBindCProcedure(*procDetails->procInterface());
     }
   }
   return symbol.attrs().test(Attr::BIND_C) && IsProcedure(symbol);
 }
 
 bool IsBindCProcedure(const Scope &scope) {
   if (const Symbol * symbol{scope.GetSymbol()}) {
     return IsBindCProcedure(*symbol);
const evaluate::Assignment *GetAssignment(
   return x.typedAssignment ? common::GetPtrFromOptional(x.typedAssignment->v)
                            : nullptr;
 }
 
 const Symbol *FindInterface(const Symbol &symbol) {
   return common::visit(
       common::visitors{
           [](const ProcEntityDetails &details) {
-            const Symbol *interface { details.interface().symbol() };
+            const Symbol *interface {
+              details.procInterface()
+            };
             return interface ? FindInterface(*interface) : nullptr;
           },
           [](const ProcBindingDetails &details) {
             return FindInterface(details.symbol());
           },
           [&](const SubprogramDetails &) { return &symbol; },
           [](const UseDetails &details) {
             return FindInterface(details.symbol());
return common::visit(
       },
       symbol.details());
 }
 
 const Symbol *FindSubprogram(const Symbol &symbol) {
   return common::visit(
       common::visitors{
           [&](const ProcEntityDetails &details) -> const Symbol * {
-            if (const Symbol * interface{details.interface().symbol()}) {
-              return FindSubprogram(*interface);
+            if (details.procInterface()) {
+              return FindSubprogram(*details.procInterface());
             } else {
               return &symbol;
             }
           },
           [](const ProcBindingDetails &details) {
             return FindSubprogram(details.symbol());
           },
           [&](const SubprogramDetails &) { return &symbol; },

flang/lib/Semantics/type.cpp

if (MaybeExpr & init{details->init()}) {
       init = IsPointer(newSymbol)
           ? Fold(std::move(*init))
           : evaluate::NonPointerInitializationExpr(
                 newSymbol, std::move(*init), foldingContext());
     }
   } else if (auto *procDetails{newSymbol.detailsIf<ProcEntityDetails>()}) {
     // We have a procedure pointer.  Instantiate its return type
     if (const DeclTypeSpec * returnType{InstantiateType(newSymbol)}) {
-      ProcInterface &interface{procDetails->interface()};
-      if (!interface.symbol()) {
-        // Don't change the type for interfaces based on symbols
-        interface.set_type(*returnType);
+      if (!procDetails->procInterface()) {
+        procDetails->ReplaceType(*returnType);
       }
     }
   }
 }
 
 const DeclTypeSpec *InstantiateHelper::InstantiateType(const Symbol &symbol) {
   const DeclTypeSpec *type{symbol.GetType()};
   if (!type) {
case ClassStar:
     return "CLASS(*)";
   }
 }
 
 llvm::raw_ostream &operator<<(llvm::raw_ostream &o, const DeclTypeSpec &x) {
   return o << x.AsFortran();
 }
 
-void ProcInterface::set_symbol(const Symbol &symbol) {
-  CHECK(!type_);
-  symbol_ = &symbol;
-}
-void ProcInterface::set_type(const DeclTypeSpec &type) {
-  CHECK(!symbol_);
-  type_ = &type;
-}
-
 } // namespace Fortran::semantics

flang/test/Semantics/procinterface03.f90

+! RUN: %python %S/test_errors.py %s %flang_fc1
+procedure(sin), pointer :: pp
+!ERROR: 'pp' has an explicit interface and may not also have a type
+real :: pp
+end