Allow casts between pointers and constant 0 with any integer type

These were already allowed:
	        0 => ptr
	       0l => ptr, but on 32bit only (matching the pointer size)
	      0ll => ptr, but on 64bit only (matching the pointer size)
	 cbyte(0) => ptr
	cshort(0) => ptr

Additionally, the following are now allowed too:
	       0l => ptr on 64bit
	      0ll => ptr on 32bit
	any 0 ptr => any integer type (opposite direction)

Updating hCalcTypesDiff() (overload resolution) accordingly is not
necessary, because it re-uses the code from ast-node-conv since db40150.

Author: dkl

changelog.txt

@@ -7,6 +7,8 @@ Version 1.01.0
 [added]
 - On Linux/*BSD, the FB runtime will now respect the __fb_enable_vt100_escapes global variable (also see examples/console/disable-vt100-escapes.bas). FB programs can set it to 0 (FALSE) in order to manually disable the use of hard-coded VT100-specific escape sequences by FB's console I/O commands. This can help getting FB programs to run on older terminals which don't accept these escape sequences. However, it may also cause FB's console I/O commands and functions to behave differently. For example, if the use of the escape sequence for querying cursor position is disabled, then the FB runtime will assume that the cursor starts out at position 1,1 even if that is not actually true.
 - WITH compounds now also accept type<UDT>(...) and UDT(...) expressions
+- Constant 0 integers can now be assigned to pointers no matter what integer type it is. Previously it didn't work with [U]LongInts on 32bit and [U]Longs on 64bit.
+- Constant 0 pointers can now be assigned to any integer type. Previously this was only allowed with integer types matching the pointer size (32bit or 64bit).
 - Bindings (new/updated, including 64bit support):
 	Allegro 4.4.2 (allegro.bi)
 	algif 1.3 (allegro/algif.bi)

src/compiler/ast-node-conv.bas

@@ -115,26 +115,19 @@ function astCheckConvNonPtrToPtr _
 	assert( typeIsPtr( to_dtype ) )
 	assert( typeIsPtr( expr_dtype ) = FALSE )
 
-	select case as const( typeGetDtAndPtrOnly( expr_dtype ) )
-	case FB_DATATYPE_INTEGER, FB_DATATYPE_UINT, FB_DATATYPE_ENUM, _
-	     FB_DATATYPE_LONG, FB_DATATYPE_ULONG, _
-	     FB_DATATYPE_LONGINT, FB_DATATYPE_ULONGINT
-		'' Allow integer-to-pointer casts if same size
-		if( typeGetSize( expr_dtype ) = env.pointersize ) then
-			return FB_ERRMSG_OK
-		end if
-
-	'' only allow other int dtypes if it's 0 (due QB's INTEGER = short)
-	case FB_DATATYPE_BYTE, FB_DATATYPE_UBYTE, _
-	     FB_DATATYPE_SHORT, FB_DATATYPE_USHORT
+	if( typeGetClass( expr_dtype ) = FB_DATACLASS_INTEGER ) then
+		'' Allow converting literal 0 with any integer type to any pointer type
 		if( astIsCONST( expr ) ) then
 			if( astConstEqZero( expr ) ) then
-				'' Allow 0-to-pointer casts
 				return FB_ERRMSG_OK
 			end if
 		end if
 
-	end select
+		'' Allow integer-to-pointer casts only if same size
+		if( typeGetSize( expr_dtype ) = env.pointersize ) then
+			return FB_ERRMSG_OK
+		end if
+	end if
 
 	function = hGetTypeMismatchErrMsg( options )
 end function
@@ -160,15 +153,19 @@ private function hCheckPtr _
 
 	'' from pointer? only allow integers of same size and pointers
 	elseif( typeIsPtr( expr_dtype ) ) then
-		select case as const( typeGetDtAndPtrOnly( to_dtype ) )
-		case FB_DATATYPE_INTEGER, FB_DATATYPE_UINT, FB_DATATYPE_ENUM, _
-		     FB_DATATYPE_LONG, FB_DATATYPE_ULONG, _
-		     FB_DATATYPE_LONGINT, FB_DATATYPE_ULONGINT
+		if( typeGetClass( to_dtype ) = FB_DATACLASS_INTEGER ) then
+			'' Allow converting literal 0 with any pointer type to any integer type
+			if( astIsCONST( expr ) ) then
+				if( astConstEqZero( expr ) ) then
+					exit function
+				end if
+			end if
+
 			'' Allow pointer-to-integer casts if same size
 			if( typeGetSize( to_dtype ) = env.pointersize ) then
 				exit function
 			end if
-		end select
+		end if
 
 		return hGetTypeMismatchErrMsg( options )
 	else

tests/numbers/cast-nullptr.bas

@@ -0,0 +1,98 @@
+# include "fbcu.bi"
+
+namespace fbc_tests.numbers.cast_nullptr
+
+private sub f_b   ( byval i as byte     ) : end sub
+private sub f_sh  ( byval i as short    ) : end sub
+private sub f_l   ( byval i as long     ) : end sub
+private sub f_ll  ( byval i as longint  ) : end sub
+private sub f_i   ( byval i as integer  ) : end sub
+private sub f_ub  ( byval i as ubyte    ) : end sub
+private sub f_ush ( byval i as ushort   ) : end sub
+private sub f_ul  ( byval i as ulong    ) : end sub
+private sub f_ull ( byval i as ulongint ) : end sub
+private sub f_ui  ( byval i as uinteger ) : end sub
+
+sub test cdecl( )
+	dim p as any ptr
+	p = 0l
+	p = 0ul
+	p = 0ll
+	p = 0ull
+	p = 0
+	p = 0u
+	p = cbyte   ( 0 )
+	p = cshort  ( 0 )
+	p = clng    ( 0 )
+	p = clngint ( 0 )
+	p = cint    ( 0 )
+	p = cubyte  ( 0 )
+	p = cushort ( 0 )
+	p = culng   ( 0 )
+	p = culngint( 0 )
+	p = cuint   ( 0 )
+	p = cptr( integer ptr, 0 )
+	p = cptr( any ptr, 0 )
+
+	dim b as byte
+	dim sh as short
+	dim l as long
+	dim ll as longint
+	dim i as integer
+	dim ub as ubyte
+	dim ush as ushort
+	dim ul as ulong
+	dim ull as ulongint
+	dim ui as uinteger
+
+	b   = cptr( any ptr, 0 )
+	sh  = cptr( any ptr, 0 )
+	l   = cptr( any ptr, 0 )
+	ll  = cptr( any ptr, 0 )
+	i   = cptr( any ptr, 0 )
+	ub  = cptr( any ptr, 0 )
+	ush = cptr( any ptr, 0 )
+	ul  = cptr( any ptr, 0 )
+	ull = cptr( any ptr, 0 )
+	ui  = cptr( any ptr, 0 )
+
+	b   = cptr( integer ptr, 0 )
+	sh  = cptr( integer ptr, 0 )
+	l   = cptr( integer ptr, 0 )
+	ll  = cptr( integer ptr, 0 )
+	i   = cptr( integer ptr, 0 )
+	ub  = cptr( integer ptr, 0 )
+	ush = cptr( integer ptr, 0 )
+	ul  = cptr( integer ptr, 0 )
+	ull = cptr( integer ptr, 0 )
+	ui  = cptr( integer ptr, 0 )
+
+	f_b  ( cptr( any ptr, 0 ) )
+	f_sh ( cptr( any ptr, 0 ) )
+	f_l  ( cptr( any ptr, 0 ) )
+	f_ll ( cptr( any ptr, 0 ) )
+	f_i  ( cptr( any ptr, 0 ) )
+	f_ub ( cptr( any ptr, 0 ) )
+	f_ush( cptr( any ptr, 0 ) )
+	f_ul ( cptr( any ptr, 0 ) )
+	f_ull( cptr( any ptr, 0 ) )
+	f_ui ( cptr( any ptr, 0 ) )
+
+	f_b  ( cptr( integer ptr, 0 ) )
+	f_sh ( cptr( integer ptr, 0 ) )
+	f_l  ( cptr( integer ptr, 0 ) )
+	f_ll ( cptr( integer ptr, 0 ) )
+	f_i  ( cptr( integer ptr, 0 ) )
+	f_ub ( cptr( integer ptr, 0 ) )
+	f_ush( cptr( integer ptr, 0 ) )
+	f_ul ( cptr( integer ptr, 0 ) )
+	f_ull( cptr( integer ptr, 0 ) )
+	f_ui ( cptr( integer ptr, 0 ) )
+end sub
+
+private sub ctor( ) constructor
+	fbcu.add_suite( "tests/numbers/cast-nullptr" )
+	fbcu.add_test( "test", @test )
+end sub
+
+end namespace

tests/overload/pointers.bas

@@ -814,26 +814,23 @@ namespace const0
 	makeFunction1( ui, uinteger )
 
 	private sub test cdecl( )
-		a( cptr( any ptr, 0 ) )
+		a( 0l )
+		a( 0ul )
+		a( 0ll )
+		a( 0ull )
 		a( 0 )
 		a( 0u )
-		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
 		a( cbyte( 0 ) )
 		a( cubyte( 0 ) )
 		a( cshort( 0 ) )
 		a( cushort( 0 ) )
+		a( clng( 0 ) )
+		a( culng( 0 ) )
+		a( clngint( 0 ) )
+		a( culngint( 0 ) )
+		a( cint( 0 ) )
+		a( cuint( 0 ) )
+		a( cptr( any ptr, 0 ) )
 
 		#macro makeTest1( suffix, result )
 			CU_ASSERT( f1_##suffix( cptr( any ptr, 0 ) ) = "any ptr" )