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

[Ali Bahrani via flang-commits]

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

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.

>From a8fe3119d5c40af505f68b93e3146d53c63cb656 Mon Sep 17 00:00:00 2001
From: Ubuntu <ubuntu at ip-172-31-16-239.ec2.internal>
Date: Thu, 6 Aug 2026 07:46:13 +0000
Subject: [PATCH 1/3] update ResolveGeneric to prioritize interface over
 explicit intrinsic

---
 flang/lib/Semantics/expression.cpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

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()}) {

>From 4cbb115804629a2c0dc464035d64ca7b6e27084c Mon Sep 17 00:00:00 2001
From: Ubuntu <ubuntu at ip-172-31-16-239.ec2.internal>
Date: Mon, 10 Aug 2026 17:19:56 +0000
Subject: [PATCH 2/3] add first explicit intrinc or interface resolution
 Semantic test

In this test, sin function\'s definition is overridden by an internal interface for type Real4. As the results demonstrate, by calling sin function with R4 argument, the function is resolved into internal_definition_sin_real4
---
 flang/test/Semantics/symbol34.f90 | 35 +++++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)
 create mode 100644 flang/test/Semantics/symbol34.f90

diff --git a/flang/test/Semantics/symbol34.f90 b/flang/test/Semantics/symbol34.f90
new file mode 100644
index 0000000000000..0f4fb57e29b61
--- /dev/null
+++ b/flang/test/Semantics/symbol34.f90
@@ -0,0 +1,35 @@
+! 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
+    !REF: /MAIN/a
+    !REF: /MAIN/internal_definition_sin_real4
+    a = sin(1.0)
+    !REF: /MAIN/a
+    print *, a
+end program

>From 465f6910f6cc01c4a67859ac0c129a52f4afc33b Mon Sep 17 00:00:00 2001
From: Ubuntu <ubuntu at ip-172-31-16-239.ec2.internal>
Date: Mon, 10 Aug 2026 17:25:00 +0000
Subject: [PATCH 3/3] add real8 instance to use explicit intrinsic in presense
 of interface for real4 type

---
 flang/test/Semantics/symbol34.f90 | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/flang/test/Semantics/symbol34.f90 b/flang/test/Semantics/symbol34.f90
index 0f4fb57e29b61..7ba122a5b74c9 100644
--- a/flang/test/Semantics/symbol34.f90
+++ b/flang/test/Semantics/symbol34.f90
@@ -27,9 +27,14 @@ program MAIN
     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