refactor: update to enforce mostly safe casts

This commit aligns `ndarray/base/fill` behavior with
`ndarray/base/slice-assign` where we also enforce mostly safe casts.

---
type: pre_commit_static_analysis_report
description: Results of running static analysis checks when committing changes.
report:
  - task: lint_filenames
    status: passed
  - task: lint_editorconfig
    status: passed
  - task: lint_markdown
    status: passed
  - task: lint_package_json
    status: na
  - task: lint_repl_help
    status: passed
  - task: lint_javascript_src
    status: passed
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: na
  - task: lint_javascript_tests
    status: passed
  - task: lint_javascript_benchmarks
    status: na
  - task: lint_python
    status: na
  - task: lint_r
    status: na
  - task: lint_c_src
    status: na
  - task: lint_c_examples
    status: na
  - task: lint_c_benchmarks
    status: na
  - task: lint_c_tests_fixtures
    status: na
  - task: lint_shell
    status: na
  - task: lint_typescript_declarations
    status: passed
  - task: lint_typescript_tests
    status: na
  - task: lint_license_headers
    status: passed
---

Author: kgryte

lib/node_modules/@stdlib/ndarray/base/fill/README.md

@@ -96,6 +96,7 @@ A provided ndarray should be an object with the following properties:
 ## Notes
 
 -   If `value` is a number and `x` has a complex [data type][@stdlib/ndarray/dtypes], the function fills an input ndarray with a complex number whose real component equals the provided scalar `value` and whose imaginary component is zero.
+-   A `value` must be able to safely cast to the input ndarray [data type][@stdlib/ndarray/dtypes]. Scalar values having floating-point data types (both real and complex) are allowed to downcast to a lower precision data type of the same kind (e.g., a scalar double-precision floating-point number can be used to fill a 'float32' input ndarray).
 -   The function **mutates** the input ndarray.
 
 </section>

lib/node_modules/@stdlib/ndarray/base/fill/docs/repl.txt

@@ -14,7 +14,11 @@
         Input ndarray-like object.
 
     value: any
-        Scalar value.
+        Scalar value. Must be able to safely cast to the input ndarray data
+        type. Scalar values having floating-point data types (both real and
+        complex) are allowed to downcast to a lower precision data type of the
+        same kind (e.g., a scalar double-precision floating-point number can be
+        used to fill a 'float32' input ndarray).
 
     Examples
     --------

lib/node_modules/@stdlib/ndarray/base/fill/docs/types/index.d.ts

@@ -29,6 +29,7 @@ import { ComplexLike } from '@stdlib/types/complex';
 * ## Notes
 *
 * -   If `value` is a number, the function fills an input ndarray with a complex number whose real component equals the provided scalar value and whose imaginary component is zero.
+* -   A `value` must be able to safely cast to the input ndarray data type. Scalar values having floating-point data types (both real and complex) are allowed to downcast to a lower precision data type of the same kind (e.g., a scalar double-precision floating-point number can be used to fill a 'float32' input ndarray).
 *
 * @param x - input ndarray
 * @param value - scalar value
@@ -68,6 +69,10 @@ declare function fill( x: complexndarray, value: number | ComplexLike ): void;
 /**
 * Fills an input ndarray with a specified value.
 *
+* ## Notes
+*
+* -   A `value` must be able to safely cast to the input ndarray data type. Scalar values having floating-point data types (both real and complex) are allowed to downcast to a lower precision data type of the same kind (e.g., a scalar double-precision floating-point number can be used to fill a 'float32' input ndarray).
+*
 * @param x - input ndarray
 * @param value - scalar value
 *

lib/node_modules/@stdlib/ndarray/base/fill/lib/main.js

@@ -20,11 +20,13 @@
 
 // MODULES //
 
+var isScalarMostlySafeCompatible = require( '@stdlib/ndarray/base/assert/is-scalar-mostly-safe-compatible' ); // eslint-disable-line id-length
 var broadcastScalar = require( '@stdlib/ndarray/base/broadcast-scalar' );
 var getDtype = require( '@stdlib/ndarray/base/dtype' );
 var getShape = require( '@stdlib/ndarray/base/shape' );
 var getOrder = require( '@stdlib/ndarray/base/order' );
 var assign = require( '@stdlib/ndarray/base/assign' );
+var format = require( '@stdlib/string/format' );
 
 
 // MAIN //
@@ -40,6 +42,7 @@ var assign = require( '@stdlib/ndarray/base/assign' );
 * @param {NonNegativeInteger} x.offset - index offset
 * @param {string} x.order - specifies whether `x` is row-major (C-style) or column-major (Fortran-style)
 * @param {*} value - scalar value
+* @throws {TypeError} second argument cannot be safely cast to the input array data type
 * @returns {void}
 *
 * @example
@@ -73,10 +76,17 @@ var assign = require( '@stdlib/ndarray/base/assign' );
 * // => <Float64Array>[ 10.0, 10.0, 10.0, 10.0, 10.0, 10.0 ]
 */
 function fill( x, value ) {
+	var dt;
 	var v;
 
+	dt = getDtype( x );
+
+	// Safe casts are always allowed and allow same kind casts (i.e., downcasts) only when the output data type is floating-point...
+	if ( !isScalarMostlySafeCompatible( value, dt ) ) {
+		throw new TypeError( format( 'invalid argument. The second argument cannot be safely cast to the input array data type. Data type: %s. Value: `%s`.', dt, value ) );
+	}
 	// Broadcast the fill value to an ndarray of same shape and data type as the input ndarray:
-	v = broadcastScalar( value, getDtype( x ), getShape( x ), getOrder( x ) );
+	v = broadcastScalar( value, dt, getShape( x ), getOrder( x ) );
 
 	// Assign the fill value to each element of the input ndarray:
 	assign( [ v, x ] ); // TODO: consider replacing with ndarray/base/assign-scalar in order to avoid zero-dimensional ndarray creation and subsequent broadcasting

lib/node_modules/@stdlib/ndarray/base/fill/test/test.js

@@ -43,6 +43,39 @@ tape( 'main export is a function', function test( t ) {
 	t.end();
 });
 
+tape( 'the function throws an error if provided a second argument which cannot be safely cast to the input ndarray data type', function test( t ) {
+	var values;
+	var x;
+	var i;
+
+	x = scalar2ndarray( 0.0, {
+		'dtype': 'int32'
+	});
+
+	values = [
+		'5',
+		3.14,
+		NaN,
+		true,
+		false,
+		null,
+		void 0,
+		[],
+		{},
+		function noop() {}
+	];
+	for ( i = 0; i < values.length; i++ ) {
+		t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] );
+	}
+	t.end();
+
+	function badValue( value ) {
+		return function badValue() {
+			fill( x, value );
+		};
+	}
+});
+
 tape( 'the function fills a 0-dimensional input ndarray with a specified value', function test( t ) {
 	var expected;
 	var x;