Add IsReferenceOrContainsReferences runtime helper (#252)

***NO_CI***

Author: josesimoes

Tests/NFUnitTestSystemLib/NFUnitTestSystemLib.nfproj

@@ -21,9 +21,11 @@
     <IsTestProject>true</IsTestProject>
     <TestProjectType>UnitTest</TestProjectType>
     <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
+    <LangVersion>13.0</LangVersion>
   </PropertyGroup>
   <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
   <ItemGroup>
+    <Compile Include="RuntimeHelpersTests.cs" />
     <Compile Include="UnitTestNullable.cs" />
     <Compile Include="UnitTestUInt64.cs" />
     <Compile Include="UnitTestUInt32.cs" />
@@ -62,4 +64,4 @@
       <ProjectConfigurationsDeclaredAsItems />
     </ProjectCapabilities>
   </ProjectExtensions>
-</Project>
+</Project>

Tests/NFUnitTestSystemLib/RuntimeHelpersTests.cs

@@ -0,0 +1,68 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Runtime.CompilerServices;
+using nanoFramework.TestFramework;
+
+namespace NFUnitTestSystemLib
+{
+    [TestClass]
+    class RuntimeHelpersTests
+    {
+        [TestMethod]
+        public static void IsReferenceOrContainsReferences()
+        {
+            Assert.IsFalse(RuntimeHelpers.IsReferenceOrContainsReferences<int>());
+            Assert.IsTrue(RuntimeHelpers.IsReferenceOrContainsReferences<string>());
+            Assert.IsFalse(RuntimeHelpers.IsReferenceOrContainsReferences<Guid>());
+            Assert.IsFalse(RuntimeHelpers.IsReferenceOrContainsReferences<StructWithoutReferences>());
+            Assert.IsTrue(RuntimeHelpers.IsReferenceOrContainsReferences<StructWithReferences>());
+            Assert.IsFalse(RuntimeHelpers.IsReferenceOrContainsReferences<RefStructWithoutReferences>());
+            Assert.IsTrue(RuntimeHelpers.IsReferenceOrContainsReferences<RefStructWithReferences>());
+            Assert.IsTrue(RuntimeHelpers.IsReferenceOrContainsReferences<Span<char>>());
+            Assert.IsTrue(RuntimeHelpers.IsReferenceOrContainsReferences<ReadOnlySpan<char>>());
+            //Assert.IsTrue(RuntimeHelpers.IsReferenceOrContainsReferences<RefStructWithRef>());
+            Assert.IsTrue(RuntimeHelpers.IsReferenceOrContainsReferences<RefStructWithNestedRef>());
+        }
+
+        private struct StructWithoutReferences
+        {
+            public int a, b, c;
+        }
+
+        private struct StructWithReferences
+        {
+            public int a, b, c;
+            public object d;
+        }
+
+        private ref struct RefStructWithoutReferences
+        {
+            public int a;
+            public long b;
+        }
+
+        private ref struct RefStructWithReferences
+        {
+            public int a;
+            public object b;
+        }
+
+        // TODO: add after checking viability of ref fields in ref structs
+        //private ref struct RefStructWithRef
+        //{
+        //    public ref int a;
+
+        //    internal RefStructWithRef(ref int aVal)
+        //    {
+        //        a = ref aVal;
+        //    }
+        //}
+
+        private ref struct RefStructWithNestedRef
+        {
+            public Span<char> a;
+        }
+    }
+}

nanoFramework.CoreLibrary/System/Runtime/CompilerServices/RuntimeHelpers.cs

@@ -1,8 +1,10 @@
-// Licensed to the .NET Foundation under one or more agreements.
+// Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
 namespace System.Runtime.CompilerServices
 {
+#pragma warning disable S4200 // Native methods should be wrapped
+
     /// <summary>
     /// Provides a set of static methods and properties that provide support for compilers. This class cannot be inherited.
     /// </summary>
@@ -43,5 +45,20 @@ public static extern int OffsetToStringData
             [MethodImpl(MethodImplOptions.InternalCall)]
             get;
         }
+
+#if NANOCLR_REFLECTION
+
+        /// <summary>
+        /// Returns a value that indicates whether the specified type is a reference type or a value type that contains references or by-refs.
+        /// </summary>
+        /// <typeparam name="T">The type.</typeparam>
+        /// <returns><see langword="true"/> if the given type is a reference type or a value type that contains references or by-refs; otherwise, <see langword="false"/>.</returns>
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        public static extern bool IsReferenceOrContainsReferences<T>() where T : allows ref struct;
+
+#endif
+
     }
+
+#pragma warning restore S4200 // Native methods should be wrapped
 }