[flang] Fix crashes on calls to non-procedures

[klausler]

Summary

When a procedure reference is attempted to an entity that just
isn't a procedure, say so.

[PeteSteinfeld]

All builds, tests, and looks good.

flang/lib/Semantics/expression.cpp

auto ExpressionAnalyzer::AnalyzeProcedureComponentRef(
     const parser::ProcComponentRef &pcr, ActualArguments &&arguments)
     -> std::optional<CalleeAndArguments> {
   const parser::StructureComponent &sc{pcr.v.thing};
   if (MaybeExpr base{Analyze(sc.base)}) {
     if (const Symbol * sym{sc.component.symbol}) {
       if (context_.HasError(sym)) {
         return std::nullopt;
       }
+      if (!IsProcedure(*sym)) {
+        AttachDeclaration(
+            Say(sc.component.source, "'%s' is not a procedure"_err_en_US,
+                sc.component.source),
+            *sym);
+      }
       if (auto *dtExpr{UnwrapExpr<Expr<SomeDerived>>(*base)}) {
         if (sym->has<semantics::GenericDetails>()) {
           AdjustActuals adjustment{
               [&](const Symbol &proc, ActualArguments &actuals) {
                 if (!proc.attrs().test(semantics::Attr::NOPASS)) {
                   AddPassArg(actuals, std::move(*dtExpr), proc);
                 }
                 return true;
if (ultimate.has<semantics::GenericDetails>()) {
           *symbol, arguments, noAdjustment, mightBeStructureConstructor);
     }
     if (symbol) {
       if (symbol->GetUltimate().has<semantics::DerivedTypeDetails>()) {
         if (mightBeStructureConstructor) {
           return CalleeAndArguments{
               semantics::SymbolRef{*symbol}, std::move(arguments)};
         }
-      } else {
+      } else if (IsProcedure(*symbol)) {
         return CalleeAndArguments{
             ProcedureDesignator{*symbol}, std::move(arguments)};
       }
+      if (!context_.HasError(*symbol)) {
+        AttachDeclaration(
+            Say(name.source, "'%s' is not a callable procedure"_err_en_US,
+                name.source),
+            *symbol);
+      }
     } else if (std::optional<SpecificCall> specificCall{
                    context_.intrinsics().Probe(
                        CallCharacteristics{
                            ultimate.name().ToString(), isSubroutine},
                        arguments, GetFoldingContext())}) {
       // Generics can extend intrinsics
       return CalleeAndArguments{
           ProcedureDesignator{std::move(specificCall->specificIntrinsic)},

flang/lib/Semantics/resolve-names.cpp

void ResolveNamesVisitor::HandleProcedureName(
   if (!symbol) {
     if (IsIntrinsic(name.source, flag)) {
       symbol =
           &MakeSymbol(InclusiveScope(), name.source, Attrs{Attr::INTRINSIC});
     } else {
       symbol = &MakeSymbol(context().globalScope(), name.source, Attrs{});
     }
     Resolve(name, *symbol);
-    if (symbol->has<ModuleDetails>()) {
-      SayWithDecl(name, *symbol,
-          "Use of '%s' as a procedure conflicts with its declaration"_err_en_US);
-      return;
-    }
     if (!symbol->attrs().test(Attr::INTRINSIC)) {
-      if (!CheckImplicitNoneExternal(name.source, *symbol)) {
-        return;
-      }
+      if (CheckImplicitNoneExternal(name.source, *symbol)) {
         MakeExternal(*symbol);
       }
+    }
     ConvertToProcEntity(*symbol);
     SetProcFlag(name, *symbol, flag);
   } else if (CheckUseError(name)) {
     // error was reported
   } else {
     symbol = &Resolve(name, symbol)->GetUltimate();
     bool convertedToProcEntity{ConvertToProcEntity(*symbol)};
     if (convertedToProcEntity && !symbol->attrs().test(Attr::EXTERNAL) &&

flang/test/Semantics/call19.f90

+! RUN: %S/test_errors.sh %s %t %flang_fc1
+! Ensures that things that aren't procedures aren't allowed to be called.
+module m
+  integer :: i
+  integer, pointer :: ip
+  type :: t
+  end type
+  type :: pdt(k,len)
+    integer, kind :: k
+    integer, len :: len
+  end type
+  type(pdt(1,2)) :: x
+  namelist /nml/i
+ contains
+  subroutine s(d)
+    real d
+    !ERROR: 'm' is not a callable procedure
+    call m
+    !ERROR: Cannot call function 'i' like a subroutine
+    call i
+    !ERROR: Cannot call function 'ip' like a subroutine
+    call ip
+    !ERROR: 't' is not a callable procedure
+    call t
+    !ERROR: 'k' is not a procedure
+    call x%k
+    !ERROR: 'len' is not a procedure
+    call x%len
+    !ERROR: Use of 'nml' as a procedure conflicts with its declaration
+    call nml
+    !ERROR: Cannot call function 'd' like a subroutine
+    call d
+  end subroutine
+end

flang/test/Semantics/resolve09.f90

contains
   end
 end
 
 ! Call to entity in global scope, even with IMPORT, NONE
 subroutine s4
   block
     import, none
     integer :: i
-    !ERROR: Use of 'm' as a procedure conflicts with its declaration
+    !ERROR: 'm' is not a callable procedure
     i = m()
-    !ERROR: Use of 'm' as a procedure conflicts with its declaration
+    !ERROR: 'm' is not a callable procedure
     call m()
   end block
 end
 
 ! Call to entity in global scope, even with IMPORT, NONE
 subroutine s5
   block
     import, none