[flang] Fix use-associated false-positive error

[unterumarmung]

Summary

For the program provided as the test case flang fired the following
error:

error: Semantic errors in main.f90
error: 'foo' is not a procedure

This change fixes the error by postponing handling of UseErrorDetails
from CharacterizeProcedure to a later stage.

[kiranchandramohan]

Can you add an error test to ensure that if the function foo is called then the Ambiguous error message is preserved?

[unterumarmung]

Added a test case with error & rebased

[unterumarmung]

Hi, @kiranchandramohan! I addressed your review comment, could you please re-review the patch?

[kiranchandramohan]

LGTM. Please wait a day before submitting in case others have comments or concerns.

flang/test/Semantics/resolve112.f90

2

Nit: Just add a comment about what this test is testing.

[unterumarmung]

Added comment to the test and rebased

flang/lib/Evaluate/characteristics.cpp

return common::visit(
               return result;
             } else {
               return std::optional<Procedure>{};
             }
           },
           [&](const semantics::UseDetails &use) {
             return CharacterizeProcedure(use.symbol(), context, seenProcs);
           },
+          [](const semantics::UseErrorDetails &) {
+            // Ambiguous use-association will be handled later during symbol
+            // checks, ignore UseErrorDetails here without actual symbol usage.
+            return std::optional<Procedure>{};
+          },
           [&](const semantics::HostAssocDetails &assoc) {
             return CharacterizeProcedure(assoc.symbol(), context, seenProcs);
           },
           [&](const semantics::EntityDetails &) {
             context.messages().Say(
                 "Procedure '%s' is referenced before being sufficiently defined in a context where it must be so"_err_en_US,
                 symbol.name());
             return std::optional<Procedure>{};

flang/test/Semantics/resolve112.f90

+! RUN: %python %S/test_errors.py %s %flang_fc1
+
+! If there are 2 or more use-associated symbols
+! from different modules with the same name,
+! the error should be generated only if
+! the name is actually used.
+module a
+  contains
+    function foo()
+      foo = 42
+    end function foo
+end module a
+
+module b
+  contains
+    function foo()
+      foo = 42
+    end function foo
+end module b
+
+subroutine without_error
+  use a
+  use b
+end subroutine without_error
+
+subroutine with_error
+  use a
+  use b
+  integer :: res
+  ! ERROR: Reference to 'foo' is ambiguous
+  res = foo()
+end subroutine with_error