overload: Prefer passing literal 0 to ints instead of ptrs

hCalcTypesDiff() used to just return a FB_OVLPROC_HALFMATCH score when
passing a literal zero with some integer type to a pointer parameter.
This meant that such matches would have higher scores than any
int-to-int matches (e.g. passing a literal zero of some integer type to
some integer parameter), because those are scored via
FB_OVLPROC_HALFMATCH - symb_dtypeMatchTB..., which will always produce
lower values than FB_OVLPROC_HALFMATCH.

However, I think that integer parameters should be preferred over pointer
parameters when passing in an integer argument (even if it's a literal 0).
Thus hCalcTypesDiff() now returns 1 instead of FB_OVLPROC_HALFMATCH when
passing a literal 0 to a pointer. This case should still be allowed, but
just rated lower than normal integer-to-integer matches. Thus it will only
be the last resort, not the first choice.

Author: dkl

changelog.txt

@@ -58,6 +58,7 @@ Version 1.01.0
 - BLOAD was misreading bitfields in BMP files with undocumented BITMAPV3HEADER format (56-byte headers)
 - PRINT now disallows commas/newlines after SPC/TAB, instead of silently ignoring them
 - 0.90.0 regression: Compiler crash during error recovery for expressions like 'type<UDT>().field' where initializer values are missing
+- When passing a constant zero of some integer to an overloaded procedure, overloads with integer parameters will now be preferred over overloads with pointers (literal 0 can still be passed to pointer parameters in this case though, by casting it to the pointer type)
 
 
 Version 1.00.0 (former 0.91.0):

src/compiler/symb-proc.bas

@@ -1718,7 +1718,13 @@ private function hCalcTypesDiff _
 						return 0
 					end if
 
-					return FB_OVLPROC_HALFMATCH
+					'' Allow passing a literal 0 integer to a pointer parameter,
+					'' but give it a very low score, such that we will prefer passing
+					'' the literal 0 integer to actual integer parameters (which are
+					'' scored based on FB_OVLPROC_HALFMATCH - symb_dtypeMatchTB...,
+					'' which is why we have to choose something that's hopefully lower
+					'' but still > 0 here).
+					return 1
 				end if
 
 				'' Both are pointers (but they're different,

tests/overload/integer_width.bas

@@ -11,11 +11,11 @@ namespace fbc_tests.overloads.integer_width
 	end function
 
 	sub zee_test cdecl( )
-#ifdef __FB_64BIT__
-		CU_ASSERT_EQUAL( hexa(0ull), 1 )
-#else
 		CU_ASSERT_EQUAL( hexa(0ull), 2 )
-#endif
+		CU_ASSERT_EQUAL( hexa(1ull), 2 )
+		CU_ASSERT_EQUAL( hexa(&hFFFFFFFFull), 2 )
+		CU_ASSERT_EQUAL( hexa(&hFFFFFFFF00000000ull), 2 )
+		CU_ASSERT_EQUAL( hexa(&hFFFFFFFFFFFFFFFFull), 2 )
 		CU_ASSERT_EQUAL( hexa(1ull shl 32), 2 )
 	end sub
 

tests/overload/pointers.bas

@@ -791,6 +791,72 @@ namespace integerPointers
 	end namespace
 end namespace
 
+namespace const0
+	'' It's possible to pass constant zero to pointer parameters
+
+	sub a overload( byval p as any ptr ) :            : end sub
+	sub a overload( byref s as string  ) : CU_FAIL( ) : end sub
+
+	#macro makeFunction1( suffix, inttype )
+		function f1_##suffix overload( byval p as any ptr ) as string : function = "any ptr" : end function
+		function f1_##suffix overload( byval i as inttype ) as string : function = #inttype  : end function
+	#endmacro
+
+	makeFunction1( b, byte )
+	makeFunction1( ub, ubyte )
+	makeFunction1( sh, short )
+	makeFunction1( ush, ushort )
+	makeFunction1( l, long )
+	makeFunction1( ul, ulong )
+	makeFunction1( ll, longint )
+	makeFunction1( ull, ulongint )
+	makeFunction1( i, integer )
+	makeFunction1( ui, uinteger )
+
+	private sub test cdecl( )
+		a( cptr( any ptr, 0 ) )
+		a( 0 )
+		a( cint( 0 ) )
+		a( cuint( 0 ) )
+		#ifdef __FB_64BIT__
+			a( 0ll )
+			a( 0ull )
+			a( clngint( 0 ) )
+			a( culngint( 0 ) )
+		#else
+			a( 0l )
+			a( 0ul )
+			a( clng( 0 ) )
+			a( culng( 0 ) )
+		#endif
+
+		#macro makeTest1( suffix, result )
+			CU_ASSERT( f1_##suffix( cptr( any ptr, 0 ) ) = "any ptr" )
+			CU_ASSERT( f1_##suffix( cbyte  ( 0 ) ) = #result )
+			CU_ASSERT( f1_##suffix( cubyte ( 0 ) ) = #result )
+			CU_ASSERT( f1_##suffix( cshort ( 0 ) ) = #result )
+			CU_ASSERT( f1_##suffix( cushort( 0 ) ) = #result )
+			CU_ASSERT( f1_##suffix( 0l   ) = #result )
+			CU_ASSERT( f1_##suffix( 0ul  ) = #result )
+			CU_ASSERT( f1_##suffix( 0ll  ) = #result )
+			CU_ASSERT( f1_##suffix( 0ull ) = #result )
+			CU_ASSERT( f1_##suffix( 0    ) = #result )
+			CU_ASSERT( f1_##suffix( 0u   ) = #result )
+		#endmacro
+
+		makeTest1( b, byte )
+		makeTest1( ub, ubyte )
+		makeTest1( sh, short )
+		makeTest1( ush, ushort )
+		makeTest1( l, long )
+		makeTest1( ul, ulong )
+		makeTest1( ll, longint )
+		makeTest1( ull, ulongint )
+		makeTest1( i, integer )
+		makeTest1( ui, uinteger )
+	end sub
+end namespace
+
 private sub ctor( ) constructor
 	fbcu.add_suite( "tests/overload/pointers" )
 	fbcu.add_test( "pointers", @pointers.test )
@@ -832,6 +898,8 @@ private sub ctor( ) constructor
 	fbcu.add_test( "integerPointers.uinteger_longint" , @integerPointers.uinteger_longint.test )
 	fbcu.add_test( "integerPointers.uinteger_ulongint", @integerPointers.uinteger_ulongint.test )
 	fbcu.add_test( "integerPointers.uinteger_integer" , @integerPointers.uinteger_integer.test )
+
+	fbcu.add_test( "const0", @const0.test )
 end sub
 
 end namespace