Fix ambiguous type comparisons from variants to real types

`Variant` -> `Double` and `Variant` -> `Extended` were being treated as
equally good conversions on toolchains where `Double` and `Extended` are
the same size, such as `DCC64`.

Author: cirras

CHANGELOG.md

@@ -7,6 +7,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Fixed
+
+- Ambiguous type comparisons from variants to real types.
+
 ## [1.17.1] - 2025-06-10
 
 ### Fixed

delphi-frontend/src/main/java/au/com/integradev/delphi/symbol/resolve/InvocationResolver.java

@@ -530,7 +530,7 @@ private static int isBetterVariantConversion(Type current, Type best) {
         .compare(current, best, Comparator.comparing(InvocationResolver::isIInterface))
         .compare(current, best, Comparator.comparing(Type::isUntyped))
         .compare(current, best, InvocationResolver::compareNumericType)
-        .compare(current, best, InvocationResolver::compareRealSize)
+        .compare(current, best, InvocationResolver::compareRealTypes)
         .compare(current, best, InvocationResolver::compareIntegerRange)
         .compare(current, best, InvocationResolver::compareStringType)
         .result();
@@ -550,14 +550,30 @@ private static int compareNumericType(Type a, Type b) {
     }
   }
 
-  private static int compareRealSize(Type a, Type b) {
+  private static int compareRealTypes(Type a, Type b) {
     if (!a.isReal() || !b.isReal()) {
       return 0;
     }
+
     if (isCurrencyCompConflict(a, b) || isCurrencyCompConflict(b, a)) {
       return 0;
     }
-    return Objects.compare(a, b, Comparator.comparingInt(Type::size));
+
+    return Comparator.<Type>comparingInt(
+            type -> {
+              type = TypeUtils.findBaseType(type);
+              if (type.is(IntrinsicType.EXTENDED)) {
+                return 1;
+              } else if (type.is(IntrinsicType.DOUBLE)) {
+                return 2;
+              } else if (type.is(IntrinsicType.REAL48)) {
+                return 3;
+              } else {
+                return 4;
+              }
+            })
+        .reversed()
+        .compare(a, b);
   }
 
   private static boolean isCurrencyCompConflict(Type currencyComp, Type real) {

delphi-frontend/src/test/java/au/com/integradev/delphi/symbol/resolve/InvocationResolverTest.java

@@ -365,9 +365,7 @@ void testVariantTypes(Toolchain toolchain) {
     assertResolved(type(VARIANT), TypeFactory.untypedType(), type(UNICODESTRING));
     assertResolved(type(VARIANT), TypeFactory.untypedType(), type(BOOLEAN));
 
-    assertResolved(type(VARIANT), type(EXTENDED), type(CURRENCY));
     assertResolved(type(VARIANT), type(CURRENCY), type(UINT64));
-    assertResolved(type(VARIANT), type(EXTENDED), type(COMP));
     assertResolved(type(VARIANT), type(COMP), type(UINT64));
 
     assertAmbiguous(type(VARIANT), type(CURRENCY), type(DOUBLE));
@@ -418,6 +416,19 @@ void testVariantTypes(Toolchain toolchain) {
     assertIncompatible(type(VARIANT), type(ANSICHAR));
   }
 
+  @Test
+  void testVariantToExtendedCurrencyShouldResolveOnDcc32() {
+    assertResolved(type(VARIANT), type(EXTENDED), type(CURRENCY));
+    assertResolved(type(VARIANT), type(EXTENDED), type(COMP));
+  }
+
+  @Test
+  void testVariantToExtendedCurrencyShouldBeAmbiguousOnDcc64() {
+    factory = new TypeFactoryImpl(Toolchain.DCC64, DelphiProperties.COMPILER_VERSION_DEFAULT);
+    assertAmbiguous(type(VARIANT), type(EXTENDED), type(CURRENCY));
+    assertAmbiguous(type(VARIANT), type(EXTENDED), type(COMP));
+  }
+
   @Test
   void testInheritedTypes() {
     Type grandparent = TypeMocker.struct("Grandparent", CLASS);