[flang] Fix interpretation of intrinsic names as arguments

[tskeith]

Summary

If an unrestricted specific intrinsic function name is first encountered
as an actual argument, it should be interpreted as an object entity,
not a procedure entity.

Fix some tests that depended on the previous interpretation by adding
explicit INTRINSIC statements.

flang/lib/Semantics/resolve-names.cpp

public:
   void Post(const parser::AllocateObject &);
   bool Pre(const parser::PointerAssignmentStmt &);
   void Post(const parser::Designator &);
   template <typename A, typename B>
   void Post(const parser::LoopBounds<A, B> &x) {
     ResolveName(*parser::Unwrap<parser::Name>(x.name));
   }
   void Post(const parser::ProcComponentRef &);
-  bool Pre(const parser::ActualArg &);
   bool Pre(const parser::FunctionReference &);
   bool Pre(const parser::CallStmt &);
   bool Pre(const parser::ImportStmt &);
   void Post(const parser::TypeGuardStmt &);
   bool Pre(const parser::StmtFunctionStmt &);
   bool Pre(const parser::DefinedOpName &);
   bool Pre(const parser::ProgramUnit &);
   void Post(const parser::AssignStmt &);
if (length) {
     return currScope().MakeCharacterType(
         ParamValue::Deferred(common::TypeParamAttr::Len),
         KindExpr{type.kind()});
   }
 }
 
 // ResolveNamesVisitor implementation
 
-// Ensures that bare undeclared intrinsic procedure names passed as actual
-// arguments get recognized as being intrinsics.
-bool ResolveNamesVisitor::Pre(const parser::ActualArg &arg) {
-  if (const auto *expr{std::get_if<Indirection<parser::Expr>>(&arg.u)}) {
-    if (const auto *designator{
-            std::get_if<Indirection<parser::Designator>>(&expr->value().u)}) {
-      if (const auto *dataRef{
-              std::get_if<parser::DataRef>(&designator->value().u)}) {
-        if (const auto *name{std::get_if<parser::Name>(&dataRef->u)}) {
-          NameIsKnownOrIntrinsic(*name);
-        }
-      }
-    }
-  }
-  return true;
-}
-
 bool ResolveNamesVisitor::Pre(const parser::FunctionReference &x) {
   HandleCall(Symbol::Flag::Function, x.v);
   return false;
 }
 bool ResolveNamesVisitor::Pre(const parser::CallStmt &x) {
   HandleCall(Symbol::Flag::Subroutine, x.v);
   return false;
 }

flang/test/Semantics/call02.f90

subroutine subr(dummy)
       procedure(sin) :: dummy
     end subroutine
     subroutine badsubr(dummy)
       import :: elem
       !ERROR: A dummy procedure may not be ELEMENTAL
       procedure(elem) :: dummy
     end subroutine
   end interface
+  intrinsic :: cos
   call subr(cos) ! not an error
   !ERROR: Non-intrinsic ELEMENTAL procedure 'elem' may not be passed as an actual argument
   call subr(elem) ! C1533
 end subroutine
 
 module m01
   procedure(sin) :: elem01
   interface
     elemental real function elem02(x)
       real, value :: x
     end function
     subroutine callme(f)
       external f
     end subroutine
   end interface
  contains
   elemental real function elem03(x)
     real, value :: x
   end function
   subroutine test
+    intrinsic :: cos
     call callme(cos) ! not an error
     !ERROR: Non-intrinsic ELEMENTAL procedure 'elem01' may not be passed as an actual argument
     call callme(elem01) ! C1533
     !ERROR: Non-intrinsic ELEMENTAL procedure 'elem02' may not be passed as an actual argument
     call callme(elem02) ! C1533
     !ERROR: Non-intrinsic ELEMENTAL procedure 'elem03' may not be passed as an actual argument
     call callme(elem03) ! C1533
     !ERROR: Non-intrinsic ELEMENTAL procedure 'elem04' may not be passed as an actual argument
contains
   subroutine callee(x)
     type(t), intent(in) :: x
   end subroutine
   subroutine test
     !ERROR: Coindexed object 'coarray' with POINTER ultimate component '%ptr' cannot be associated with dummy argument 'x='
     call callee(coarray[1]) ! C1537
   end subroutine
 end module
+
+program p03
+  logical :: l
+  call s1(index)
+  l = index .eq. 0  ! index is an object entity, not an intrinsic
+  call s2(sin)
+  !ERROR: Actual argument associated with procedure dummy argument 'p=' is not a procedure
+  call s3(cos)
+contains
+  subroutine s2(x)
+    real :: x
+  end
+  subroutine s3(p)
+    procedure(real) :: p
+  end
+end
+
+program p04
+  implicit none
+  !ERROR: No explicit type declared for 'index'
+  call s1(index)
+end

flang/test/Semantics/call09.f90

function procptr()
     procptr => realfunc
   end function
   function intprocptr()
     procedure(intfunc), pointer :: intprocptr
     intprocptr => intfunc
   end function
 
   subroutine test1 ! 15.5.2.9(5)
+    intrinsic :: sin
     procedure(realfunc), pointer :: p
     procedure(intfunc), pointer :: ip
     p => realfunc
     ip => intfunc
     call s01(realfunc) ! ok
     !ERROR: Actual argument procedure has interface incompatible with dummy argument 'p='
     call s01(intfunc)
     call s01(p) ! ok