[wasm] improve memory access and marshaling range checks

src/libraries/System.Private.Runtime.InteropServices.JavaScript/src/System/Runtime/InteropServices/JavaScript/Runtime.cs

@@ -154,12 +154,12 @@ internal static MarshalType GetMarshalTypeFromType(Type? type)
 
             switch (typeCode)
             {
-                case TypeCode.Byte:
                 case TypeCode.SByte:
                 case TypeCode.Int16:
-                case TypeCode.UInt16:
                 case TypeCode.Int32:
                     return MarshalType.INT;
+                case TypeCode.Byte:
+                case TypeCode.UInt16:
                 case TypeCode.UInt32:
                     return MarshalType.UINT32;
                 case TypeCode.Boolean:
@@ -232,11 +232,14 @@ internal static char GetCallSignatureCharacterForMarshalType(MarshalType t, char
             switch (t)
             {
                 case MarshalType.BOOL:
-                case MarshalType.INT:
+                    return 'b';
                 case MarshalType.UINT32:
                 case MarshalType.POINTER:
+                    return 'I';
+                case MarshalType.INT:
                     return 'i';
                 case MarshalType.UINT64:
+                    return 'L';
                 case MarshalType.INT64:
                     return 'l';
                 case MarshalType.FP32:
@@ -250,9 +253,9 @@ internal static char GetCallSignatureCharacterForMarshalType(MarshalType t, char
                 case MarshalType.SAFEHANDLE:
                     return 'h';
                 case MarshalType.ENUM:
-                    return 'j';
+                    return 'j'; // this is wrong for uint enums
                 case MarshalType.ENUM64:
-                    return 'k';
+                    return 'k'; // this is wrong for ulong enums
                 case MarshalType.TASK:
                 case MarshalType.DELEGATE:
                 case MarshalType.OBJECT:

src/libraries/System.Private.Runtime.InteropServices.JavaScript/tests/System.Private.Runtime.InteropServices.JavaScript.Tests.csproj

@@ -8,6 +8,7 @@
   <ItemGroup>
     <Compile Include="System\Runtime\InteropServices\JavaScript\JavaScriptTests.cs" />
     <Compile Include="System\Runtime\InteropServices\JavaScript\DataViewTests.cs" />
+    <Compile Include="System\Runtime\InteropServices\JavaScript\MemoryTests.cs" />
     <Compile Include="System\Runtime\InteropServices\JavaScript\TypedArrayTests.cs" />
     <Compile Include="System\Runtime\InteropServices\JavaScript\ArrayTests.cs" />
     <Compile Include="System\Runtime\InteropServices\JavaScript\MarshalTests.cs" />

src/libraries/System.Private.Runtime.InteropServices.JavaScript/tests/System/Runtime/InteropServices/JavaScript/DelegateTests.cs

@@ -99,12 +99,13 @@ public static void InvokeActionIntInt()
         public static void InvokeActionFloatIntToIntInt()
         {
             HelperMarshal._actionResultValue = 0;
-            Runtime.InvokeJS(@"
+            var ex = Assert.Throws<JSException>(()=>Runtime.InvokeJS(@"
                 var actionDelegate = App.call_test_method (""CreateActionDelegate"", [  ]);
                 actionDelegate(3.14,40);
-            ");
+            "));
 
-            Assert.Equal(43, HelperMarshal._actionResultValue);
+            Assert.Contains("Value is not integer but float", ex.Message);
+            Assert.Equal(0, HelperMarshal._actionResultValue);
         }
 
         [Fact]

src/libraries/System.Private.Runtime.InteropServices.JavaScript/tests/System/Runtime/InteropServices/JavaScript/HelperMarshal.cs

@@ -105,6 +105,21 @@ private static object InvokeReturnMarshalObj()
             return _marshaledObject;
         }
 
+        private static int InvokeReturnInt()
+        {
+            return 42;
+        }
+
+        private static long InvokeReturnLong()
+        {
+            return 42L;
+        }
+
+        private static double InvokeReturnDouble()
+        {
+            return double.Pi;
+        }
+
         internal static int _valOne, _valTwo;
         private static void ManipulateObject(JSObject obj)
         {

src/libraries/System.Private.Runtime.InteropServices.JavaScript/tests/System/Runtime/InteropServices/JavaScript/MarshalTests.cs

@@ -160,6 +160,35 @@ public static void InvokeUnboxNumber(object o, object expected = null)
             Assert.Equal(expected ?? o, HelperMarshal._object1);
         }
 
+        [Fact]
+        public static void InvokeUnboxInt()
+        {
+            Runtime.InvokeJS(@"
+                var obj = App.call_test_method (""InvokeReturnInt"");
+                var res = App.call_test_method (""InvokeObj1"", [ obj ]);
+            ");
+
+            Assert.Equal(42, HelperMarshal._object1);
+        }
+
+        [Fact]
+        public static void InvokeUnboxDouble()
+        {
+            Runtime.InvokeJS(@"
+                var obj = App.call_test_method (""InvokeReturnDouble"");
+                var res = App.call_test_method (""InvokeObj1"", [ obj ]);
+            ");
+
+            Assert.Equal(double.Pi, HelperMarshal._object1);
+        }
+
+        [Fact]
+        public static void InvokeUnboxLongFail()
+        {
+            var ex = Assert.Throws<JSException>(() => Runtime.InvokeJS(@"App.call_test_method (""InvokeReturnLong"");"));
+            Assert.Contains("int64 not available", ex.Message);
+        }
+
         [Theory]
         [InlineData(byte.MinValue, 0)]
         [InlineData(byte.MaxValue, 255)]
@@ -421,16 +450,13 @@ public static void TestFunctionApply()
         [Fact]
         public static void BoundStaticMethodMissingArgs()
         {
-            // TODO: We currently have code that relies on this behavior (missing args default to 0) but
-            //  it would be better if it threw an exception about the missing arguments. This test is here
-            //  to ensure we do not break things by accidentally changing this behavior -kg
-
             HelperMarshal._intValue = 1;
-            Runtime.InvokeJS(@$"
+            var ex = Assert.Throws<JSException>(() => Runtime.InvokeJS(@$"
                 var invoke_int = INTERNAL.mono_bind_static_method (""{HelperMarshal.INTEROP_CLASS}InvokeInt"");
                 invoke_int ();
-            ");
-            Assert.Equal(0, HelperMarshal._intValue);
+            "));
+            Assert.Contains("Value is not integer but undefined", ex.Message);
+            Assert.Equal(1, HelperMarshal._intValue);
         }
 
         [Fact]
@@ -445,40 +471,41 @@ public static void BoundStaticMethodExtraArgs()
         }
 
         [Fact]
-        public static void BoundStaticMethodArgumentTypeCoercion()
+        public static void RangeCheckInt()
         {
-            // TODO: As above, the type coercion behavior on display in this test is not ideal, but
-            //  changing it risks breakage in existing code so for now it is verified by a test -kg
-
             HelperMarshal._intValue = 0;
-            Runtime.InvokeJS(@$"
+            // no numbers bigger than 32 bits
+            var ex = Assert.Throws<JSException>(() => Runtime.InvokeJS(@$"
                 var invoke_int = INTERNAL.mono_bind_static_method (""{HelperMarshal.INTEROP_CLASS}InvokeInt"");
-                invoke_int (""200"");
-            ");
-            Assert.Equal(200, HelperMarshal._intValue);
-
-            Runtime.InvokeJS(@$"
-                var invoke_int = INTERNAL.mono_bind_static_method (""{HelperMarshal.INTEROP_CLASS}InvokeInt"");
-                invoke_int (400.5);
-            ");
-            Assert.Equal(400, HelperMarshal._intValue);
+                invoke_int (Number.MAX_SAFE_INTEGER);
+            "));
+            Assert.Contains("Overflow: value 9007199254740991 is out of -2147483648 2147483647 range", ex.Message);
+            Assert.Equal(0, HelperMarshal._intValue);
         }
 
         [Fact]
-        public static void BoundStaticMethodUnpleasantArgumentTypeCoercion()
+        public static void IntegerCheckInt()
         {
-            HelperMarshal._intValue = 100;
-            Runtime.InvokeJS(@$"
+            HelperMarshal._intValue = 0;
+            // no floating point rounding
+            var ex = Assert.Throws<JSException>(() => Runtime.InvokeJS(@$"
                 var invoke_int = INTERNAL.mono_bind_static_method (""{HelperMarshal.INTEROP_CLASS}InvokeInt"");
-                invoke_int (""hello"");
-            ");
+                invoke_int (3.14);
+            "));
+            Assert.Contains("Value is not integer but float", ex.Message);
             Assert.Equal(0, HelperMarshal._intValue);
+        }
 
-            // In this case at the very least, the leading "7" is not turned into the number 7
-            Runtime.InvokeJS(@$"
+        [Fact]
+        public static void TypeCheckInt()
+        {
+            HelperMarshal._intValue = 0;
+            // no string conversion
+            var ex = Assert.Throws<JSException>(() => Runtime.InvokeJS(@$"
                 var invoke_int = INTERNAL.mono_bind_static_method (""{HelperMarshal.INTEROP_CLASS}InvokeInt"");
-                invoke_int (""7apples"");
-            ");
+                invoke_int (""200"");
+            "));
+            Assert.Contains("Value is not integer but string", ex.Message);
             Assert.Equal(0, HelperMarshal._intValue);
         }
 
@@ -519,19 +546,6 @@ public static void PassUintEnumByValue()
             Assert.Equal(TestEnum.BigValue, HelperMarshal._enumValue);
         }
 
-        [Fact]
-        public static void PassUintEnumByValueMasqueradingAsInt()
-        {
-            HelperMarshal._enumValue = TestEnum.Zero;
-            // HACK: We're explicitly telling the bindings layer to pass an int here, not an enum
-            // Because we know the enum is : uint, this is compatible, so it works.
-            Runtime.InvokeJS(@$"
-                var set_enum = INTERNAL.mono_bind_static_method (""{HelperMarshal.INTEROP_CLASS}SetEnumValue"", ""i"");
-                set_enum (0xFFFFFFFE);
-            ");
-            Assert.Equal(TestEnum.BigValue, HelperMarshal._enumValue);
-        }
-
         [Fact]
         public static void PassUintEnumByNameIsNotImplemented()
         {

src/libraries/System.Private.Runtime.InteropServices.JavaScript/tests/System/Runtime/InteropServices/JavaScript/MemoryTests.cs

@@ -0,0 +1,128 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Runtime.CompilerServices;
+using Xunit;
+
+namespace System.Runtime.InteropServices.JavaScript.Tests
+{
+    public class MemoryTests
+    {
+        [Theory]
+        [InlineData(-1L)]
+        [InlineData(-42L)]
+        [InlineData(int.MinValue)]
+        [InlineData(-9007199254740991L)]//MIN_SAFE_INTEGER
+        [InlineData(1L)]
+        [InlineData(0L)]
+        [InlineData(42L)]
+        [InlineData(int.MaxValue)]
+        [InlineData(0xF_FFFF_FFFFL)]
+        [InlineData(9007199254740991L)]//MAX_SAFE_INTEGER 
+        public static unsafe void Int52TestOK(long value)
+        {
+            long expected = value;
+            long actual2 = value;
+            var bagFn = new Function("ptr", "ptr2", @"
+                const value=globalThis.App.MONO.getI52(ptr);
+                globalThis.App.MONO.setI52(ptr2, value);
+                return value;");
+
+            uint ptr = (uint)Unsafe.AsPointer(ref expected);
+            uint ptr2 = (uint)Unsafe.AsPointer(ref actual2);
+
+            object o = bagFn.Call(null, ptr, ptr2);
+            if (value < int.MaxValue && value > int.MinValue)
+            {
+                Assert.IsType<int>(o);
+                long actual = (int)o;
+                Assert.Equal(expected, actual);
+            }
+            Assert.Equal(expected, actual2);
+        }
+
+        [Theory]
+        [InlineData(uint.MinValue)]
+        [InlineData(1L)]
+        [InlineData(0L)]
+        [InlineData(42L)]
+        [InlineData(uint.MaxValue)]
+        [InlineData(0xF_FFFF_FFFFL)]
+        [InlineData(9007199254740991L)]//MAX_SAFE_INTEGER 
+        public static unsafe void UInt52TestOK(ulong value)
+        {
+            ulong expected = value;
+            ulong actual2 = value;
+            var bagFn = new Function("ptr", "ptr2", @"
+                const value=globalThis.App.MONO.getI52(ptr);
+                globalThis.App.MONO.setU52(ptr2, value);
+                return value;");
+
+            uint ptr = (uint)Unsafe.AsPointer(ref expected);
+            uint ptr2 = (uint)Unsafe.AsPointer(ref actual2);
+
+            object o = bagFn.Call(null, ptr, ptr2);
+            if (value < int.MaxValue)
+            {
+                Assert.IsType<int>(o);
+                ulong actual = (ulong)(long)(int)o;
+                Assert.Equal(expected, actual);
+            }
+            Assert.Equal(expected, actual2);
+        }
+
+        [Theory]
+        [InlineData(double.NegativeInfinity)]
+        [InlineData(double.PositiveInfinity)]
+        [InlineData(double.MinValue)]
+        [InlineData(double.MaxValue)]
+        [InlineData(double.Pi)]
+        [InlineData(9007199254740993.0)]//MAX_SAFE_INTEGER +2
+        public static unsafe void Int52TestRange(double value)
+        {
+            long actual = 0;
+            uint ptr = (uint)Unsafe.AsPointer(ref actual);
+            var bagFn = new Function("ptr", "value", @"
+                globalThis.App.MONO.setI52(ptr, value);");
+            var ex=Assert.Throws<JSException>(() => bagFn.Call(null, ptr, value));
+            Assert.Contains("Overflow: value out of Number.isSafeInteger range", ex.Message);
+
+            double expectedD = value;
+            uint ptrD = (uint)Unsafe.AsPointer(ref expectedD);
+            var bagFnD = new Function("ptr", "value", @"
+                globalThis.App.MONO.getI52(ptr);");
+            var exD = Assert.Throws<JSException>(() => bagFn.Call(null, ptr, value));
+            Assert.Contains("Overflow: value out of Number.isSafeInteger range", ex.Message);
+        }
+
+        [Theory]
+        [InlineData(-1.0)]
+        public static unsafe void UInt52TestRange(double value)
+        {
+            long actual = 0;
+            uint ptr = (uint)Unsafe.AsPointer(ref actual);
+            var bagFn = new Function("ptr", "value", @"
+                globalThis.App.MONO.setU52(ptr, value);");
+            var ex=Assert.Throws<JSException>(() => bagFn.Call(null, ptr, value));
+            Assert.Contains("Can't convert negative Number into UInt64", ex.Message);
+
+            double expectedD = value;
+            uint ptrD = (uint)Unsafe.AsPointer(ref expectedD);
+            var bagFnD = new Function("ptr", "value", @"
+                globalThis.App.MONO.getU52(ptr);");
+            var exD = Assert.Throws<JSException>(() => bagFn.Call(null, ptr, value));
+            Assert.Contains("Can't convert negative Number into UInt64", ex.Message);
+        }
+
+        [Fact]
+        public static unsafe void Int52TestNaN()
+        {
+            long actual = 0;
+            uint ptr = (uint)Unsafe.AsPointer(ref actual);
+            var bagFn = new Function("ptr", "value", @"
+                globalThis.App.MONO.setI52(ptr, value);");
+            var ex=Assert.Throws<JSException>(() => bagFn.Call(null, ptr, double.NaN));
+            Assert.Contains("Can't convert Number.Nan into Int64", ex.Message);
+        }
+    }
+}

src/mono/wasm/runtime/cjs/dotnet.cjs.lib.js

@@ -10,11 +10,12 @@ const DotnetSupportLib = {
     // we replace implementation of readAsync and fetch
     // replacement of require is there for consistency with ES6 code
     $DOTNET__postset: `
-let __dotnet_replacements = {readAsync, fetch: globalThis.fetch, require};
+let __dotnet_replacements = {readAsync, fetch: globalThis.fetch, require, updateGlobalBufferAndViews};
 let __dotnet_exportedAPI = __dotnet_runtime.__initializeImportsAndExports(
     { isESM:false, isGlobal:ENVIRONMENT_IS_GLOBAL, isNode:ENVIRONMENT_IS_NODE, isShell:ENVIRONMENT_IS_SHELL, isWeb:ENVIRONMENT_IS_WEB, locateFile, quit_, ExitStatus, requirePromise:Promise.resolve(require)},
     { mono:MONO, binding:BINDING, internal:INTERNAL, module:Module },
     __dotnet_replacements);
+updateGlobalBufferAndViews = __dotnet_replacements.updateGlobalBufferAndViews;
 readAsync = __dotnet_replacements.readAsync;
 var fetch = __dotnet_replacements.fetch;
 require = __dotnet_replacements.requireOut;

src/mono/wasm/runtime/cwraps.ts

@@ -2,7 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 import {
-    assert,
+    mono_assert,
     MonoArray, MonoAssembly, MonoClass,
     MonoMethod, MonoObject, MonoString,
     MonoType, MonoObjectRef, MonoStringRef
@@ -197,7 +197,7 @@ export default wrapped_c_functions;
 export function wrap_c_function(name: string): Function {
     const wf: any = wrapped_c_functions;
     const sig = fn_signatures.find(s => s[0] === name);
-    assert(sig, () => `Function ${name} not found`);
+    mono_assert(sig, () => `Function ${name} not found`);
     const fce = Module.cwrap(sig[0], sig[1], sig[2], sig[3]);
     wf[sig[0]] = fce;
     return fce;