[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

       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{

           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{

flang/lib/Semantics/resolve-names.cpp

       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);
       }
-      MakeExternal(*symbol);
     }
     ConvertToProcEntity(*symbol);
     SetProcFlag(name, *symbol, flag);

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

   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