refactor: update boolean array indexing implementation and add tests

Author: kgryte

lib/node_modules/@stdlib/array/to-fancy/lib/set_elements.js

@@ -26,6 +26,7 @@ var scalar2array = require( '@stdlib/array/from-scalar' );
 var dtype = require( '@stdlib/array/dtype' );
 var put = require( '@stdlib/array/put' );
 var where = require( '@stdlib/array/base/where' ).assign;
+var place = require( '@stdlib/array/base/place' );
 var format = require( '@stdlib/string/format' );
 var prop2array = require( './prop2array.js' );
 var errMessage = require( './error_message.js' );
@@ -53,20 +54,20 @@ var errMessage = require( './error_message.js' );
 * @returns {boolean} boolean indicating whether assignment succeeded
 */
 function setElements( target, property, value, ctx ) {
+	var tdt;
+	var vdt;
 	var idx;
 	var err;
-	var dt;
 	var v;
 
 	idx = prop2array( property, ctx.cache );
+	tdt = ctx.dtype || 'generic';
 	if ( isCollection( value ) ) {
 		// When handling collections, we delegate to implementation APIs (see below) to perform argument validation (e.g., ensuring a (mostly) safe cast, broadcast compatibility, etc), so we just reassign the value here:
 		v = value;
-		dt = dtype( value ) || 'generic';
 	} else {
 		// When provided a "scalar", we need to check whether the value can be safely cast to the target array data type:
-		dt = ctx.dtype;
-		err = ctx.validator( value, dt );
+		err = ctx.validator( value, tdt );
 		if ( err ) {
 			throw err;
 		}
@@ -76,7 +77,8 @@ function setElements( target, property, value, ctx ) {
 			v = value;
 		}
 		// As the scalar can be safely cast, convert the scalar to an array having the same data type as the target array to allow for broadcasting during assignment:
-		v = scalar2array( v, dt );
+		v = scalar2array( v, tdt );
+		vdt = tdt;
 	}
 	if ( idx.type === 'int' ) {
 		try {
@@ -86,16 +88,27 @@ function setElements( target, property, value, ctx ) {
 		}
 		return true;
 	}
+	if ( vdt === void 0 ) {
+		vdt = dtype( value ) || 'generic';
+	}
 	// Safe casts are always allowed and allow same kind casts (i.e., downcasts) only when the target array data type is floating-point...
-	if ( !isMostlySafeCast( dt, ctx.dtype ) ) {
-		throw new TypeError( format( 'invalid operation. Assigned value cannot be safely cast to the target array data type. Data types: [%s, %s].', dt, ctx.dtype ) );
+	if ( !isMostlySafeCast( vdt, tdt ) ) {
+		throw new TypeError( format( 'invalid operation. Assigned value cannot be safely cast to the target array data type. Data types: [%s, %s].', vdt, tdt ) );
 	}
 	if ( idx.type === 'bool' ) {
-		where( idx.data, v, target, target, 1, 0 );
+		try {
+			place( target, idx.data, v, 'strict_broadcast' );
+		} catch ( err ) {
+			throw new err.constructor( errMessage( err.message ) );
+		}
 		return true;
 	}
 	if ( idx.type === 'mask' ) {
-		where( idx.data, target, v, target, 1, 0 );
+		try {
+			where( idx.data, target, v, target, 1, 0 ); // note: intentionally deviate from boolean array indexing here and interpret the mask as applying to both the target and values array, thus requiring that the assigned value array be broadcast compatible with the target array and NOT just the selected elements as in boolean array indexing
+		} catch ( err ) {
+			throw new err.constructor( errMessage( err.message ) );
+		}
 		return true;
 	}
 	throw new Error( format( 'invalid operation. Unrecognized array index type. Value: `%s`.', idx.type ) );

lib/node_modules/@stdlib/array/to-fancy/lib/set_slice.js

@@ -68,7 +68,7 @@ function setSlice( target, property, value, receiver, ctx ) {
 			throw err;
 		}
 		// As the scalar can be safely cast, convert the scalar to an array having the same data type as the target array to allow for broadcasting during slice assignment:
-		v = scalar2array( value, ctx.dtype );
+		v = scalar2array( value, ctx.dtype || 'generic' );
 	}
 	try {
 		sliceAssign( v, receiver, s, ctx.strict );