[flang-commits] [flang] [Flang] Interface vs explicit intrinsics priority (PR #215355)

[via flang-commits]

llvmorg-github-actions[bot] wrote:


<!--LLVM PR SUMMARY COMMENT-->

@llvm/pr-subscribers-flang-semantics

Author: Ali Bahrani (mrbahrani)

<details>
<summary>Changes</summary>

This PR addresses the issue #<!-- -->212683 
I updated `ExpressionAnalyzer::ResolveGeneric` method to prioritize internal interface definition over explicit intrinsic in symbol resolution.
`symbol34.f90` is also added to verify the changes made to the system. The changed flang binary passes both check-flang and check-flang unit.

---
Full diff: https://github.com/llvm/llvm-project/pull/215355.diff


2 Files Affected:

- (modified) flang/lib/Semantics/expression.cpp (+4-4) 
- (added) flang/test/Semantics/symbol34.f90 (+40) 


``````````diff
diff --git a/flang/lib/Semantics/expression.cpp b/flang/lib/Semantics/expression.cpp
index fc57cc43e981c..6bf1bda749745 100644
--- a/flang/lib/Semantics/expression.cpp
+++ b/flang/lib/Semantics/expression.cpp
@@ -3204,7 +3204,7 @@ auto ExpressionAnalyzer::ResolveGeneric(const Symbol &symbol,
   const Symbol *elemental{nullptr}; // matching elemental specific proc
   const Symbol *nonElemental{nullptr}; // matching non-elemental specific
   const auto *genericDetails{ultimate.detailsIf<semantics::GenericDetails>()};
-  if (genericDetails && !explicitIntrinsic) {
+  if (genericDetails) {
     std::optional<CudaMatchingDistance> crtMatchingDistance;
     for (const Symbol &specific0 : genericDetails->specificProcs()) {
       const Symbol &specific1{BypassGeneric(specific0)};
@@ -3276,12 +3276,12 @@ auto ExpressionAnalyzer::ResolveGeneric(const Symbol &symbol,
   // Return the right resolution, if there is one.  Explicit intrinsics
   // are preferred, then non-elements specifics, then elementals, and
   // lastly structure constructors.
-  if (explicitIntrinsic) {
-    return {explicitIntrinsic, false};
-  } else if (nonElemental) {
+  if (nonElemental) {
     return {&AccessSpecific(symbol, *nonElemental), false};
   } else if (elemental) {
     return {&AccessSpecific(symbol, *elemental), false};
+  } else if (explicitIntrinsic) {
+    return {explicitIntrinsic, false};
   }
   // Check parent derived type
   if (const auto *parentScope{symbol.owner().GetDerivedTypeParent()}) {
diff --git a/flang/test/Semantics/symbol34.f90 b/flang/test/Semantics/symbol34.f90
new file mode 100644
index 0000000000000..7ba122a5b74c9
--- /dev/null
+++ b/flang/test/Semantics/symbol34.f90
@@ -0,0 +1,40 @@
+! RUN: %python %S/test_symbols.py %s %flang_fc1
+!DEF: /mod Module
+module mod
+contains
+    !DEF: /mod/internal_definition_sin_real4 PUBLIC (Function) Subprogram REAL(4)
+    !DEF: /mod/internal_definition_sin_real4/r4 ObjectEntity REAL(4)
+    function internal_definition_sin_real4(r4)
+        !REF: /mod/internal_definition_sin_real4/r4
+        real r4
+        !DEF: /mod/internal_definition_sin_real4/internal_definition_sin_real4 ObjectEntity REAL(4)
+        real internal_definition_sin_real4
+        !REF: /mod/internal_definition_sin_real4/internal_definition_sin_real4
+        !REF: /mod/internal_definition_sin_real4/r4
+        internal_definition_sin_real4 = r4+100
+    end function
+end module
+!DEF: /MAIN MainProgram
+program MAIN
+    !REF: /mod
+    use :: mod
+    !DEF: /MAIN/sin ELEMENTAL, INTRINSIC, PURE (Function) Generic
+    intrinsic :: sin
+    !REF: /MAIN/sin
+    interface sin
+        !DEF: /MAIN/internal_definition_sin_real4 (Function) Use REAL(4)
+        procedure :: internal_definition_sin_real4
+    end interface
+    !DEF: /MAIN/a ObjectEntity REAL(4)
+    real a
+    !DEF: /MAIN/b ObjectEntity REAL(8)
+    real(kind=8) b
+    !REF: /MAIN/a
+    !REF: /MAIN/internal_definition_sin_real4
+    a = sin(1.0)
+    !REF: /MAIN/a
+    print *, a
+    !REF: /MAIN/b
+    !REF: /MAIN/sin
+    b = sin(1.0_8)
+end program

``````````

</details>


https://github.com/llvm/llvm-project/pull/215355