Update to C# 8 and add nullability analysis

Author: ThadHouse

src/FRC-Utilities/DisposableNativeString.cs

@@ -20,7 +20,7 @@ public unsafe struct DisposableNativeString : IDisposable
         /// </summary>
         public UIntPtr Length;
 
-        private string m_string;
+        private readonly string m_string;
 
         /// <summary>
         /// Creates a new UTF8 string from a managed string
@@ -49,7 +49,6 @@ public DisposableNativeString(string vStr)
         public unsafe void Dispose()
         {
             Marshal.FreeHGlobal((IntPtr)Buffer);
-            m_string = null;
         }
 
         /// <summary>

src/FRC-Utilities/FRC-Utilities.csproj

@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <Description>FRC Utility Library</Description>
-    <Copyright>Copyright 2016-2017 RobotDotNet</Copyright>
+    <Copyright>Copyright 2016-2019 RobotDotNet</Copyright>
     <AssemblyTitle>FRC Utilities</AssemblyTitle>
     <Title>FRC Utilities</Title>
     <Authors>RobotDotNet</Authors>
@@ -20,10 +20,18 @@
     <GenerateAssemblyProductAttribute>false</GenerateAssemblyProductAttribute>
     <RootNamespace>FRC</RootNamespace>
     <AllowUnsafeBlocks>True</AllowUnsafeBlocks>
+    <LangVersion>8.0</LangVersion>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <PropertyGroup>
+    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+    <WarningsAsErrors />
+    <Version>3.0.0</Version>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="System.Reflection.Emit" Version="4.3.0" />
-    <PackageReference Include="System.Reflection.Emit.ILGeneration" Version="4.3.0" />
+    <PackageReference Include="System.Reflection.Emit" Version="4.6.0" />
+    <PackageReference Include="System.Reflection.Emit.ILGeneration" Version="4.6.0" />
   </ItemGroup>
 </Project>

src/FRC-Utilities/ILGeneration/CalliILGenerator.cs

@@ -8,10 +8,17 @@
 
 namespace FRC.ILGeneration
 {
+    /// <summary>
+    /// Generator for generating CallI IL calls
+    /// </summary>
     public class CalliILGenerator : IILGenerator
     {
-        private readonly object[] invokeArgs = new object[4];
+        private readonly object?[] invokeArgs = new object?[4];
         private readonly MethodInfo methodInfo;
+
+        /// <summary>
+        /// Construct a new Calli il generator
+        /// </summary>
         public CalliILGenerator()
         {
             var emitMethod = typeof(ILGenerator).GetMethod(nameof(ILGenerator.EmitCalli), new Type[] { typeof(OpCode), typeof(CallingConvention), typeof(Type), typeof(Type[]) });
@@ -20,7 +27,15 @@ public CalliILGenerator()
             invokeArgs[1] = CallingConvention.Cdecl;
         }
 
-        public unsafe void GenerateMethod(ILGenerator generator, Type returnType, Type[] parameters, IntPtr nativeFp, bool isInstance = false)
+        /// <summary>
+        /// Generate a native calling method
+        /// </summary>
+        /// <param name="generator"></param>
+        /// <param name="returnType"></param>
+        /// <param name="parameters"></param>
+        /// <param name="nativeFp"></param>
+        /// <param name="isInstance"></param>
+        public unsafe void GenerateMethod(ILGenerator generator, Type? returnType, Type[]? parameters, IntPtr nativeFp, bool isInstance = false)
         {
             ILHelpers.VerifyBlittableParameters(returnType, parameters);
             if (isInstance)

src/FRC-Utilities/ILGeneration/IFunctionPointerLoader.cs

@@ -1,7 +1,15 @@
 using System;
 
 namespace FRC.ILGeneration {
-  public interface IFunctionPointerLoader {
-    IntPtr GetProcAddress(string name);
-  }
+    /// <summary>
+    /// Interface for loading a function pointer
+    /// </summary>
+    public interface IFunctionPointerLoader {
+        /// <summary>
+        /// Get a function pointer for a function name
+        /// </summary>
+        /// <param name="name"></param>
+        /// <returns></returns>
+        IntPtr GetProcAddress(string name);
+    }
 }

src/FRC-Utilities/ILGeneration/ILHelpers.cs

@@ -5,26 +5,34 @@
 
 namespace FRC.ILGeneration
 {
+    /// <summary>
+    /// Helpers for IL testing
+    /// </summary>
     public static class ILHelpers
     {
-        public static void VerifyBlittableParameters(Type returnType, Type[] parameters)
+        /// <summary>
+        /// Test if parameters are blittable
+        /// </summary>
+        /// <param name="returnType"></param>
+        /// <param name="parameters"></param>
+        public static void VerifyBlittableParameters(Type? returnType, Type[]? parameters)
         {
             return;
-            if (returnType != null && !returnType.IsValueType)
-            {
-                throw new InvalidOperationException("Cannot generate for returning a non blittable type");
-            }
-            if (parameters == null)
-            {
-                return;
-            }
-            foreach(var param in parameters)
-            {
-                if (!param.IsValueType)
-                {
-                    throw new InvalidOperationException("Cannot generate parameter for a non blittable type");
-                }
-            }
+            //if (returnType != null && !returnType.IsValueType)
+            //{
+            //    throw new InvalidOperationException("Cannot generate for returning a non blittable type");
+            //}
+            //if (parameters == null)
+            //{
+            //    return;
+            //}
+            //foreach(var param in parameters)
+            //{
+            //    if (!param.IsValueType)
+            //    {
+            //        throw new InvalidOperationException("Cannot generate parameter for a non blittable type");
+            //    }
+            //}
         }
     }
 }

src/FRC-Utilities/ILGeneration/InterfaceGenerator.cs

@@ -8,7 +8,7 @@
 
 namespace FRC.ILGeneration
 {
-    internal class InterfaceGenerator<T>
+    internal class InterfaceGenerator<T> where T : class
     {
         private readonly IFunctionPointerLoader functionPointerLoader;
         private readonly IILGenerator ilGenerator;
@@ -19,7 +19,7 @@ public InterfaceGenerator(IFunctionPointerLoader functionPointerLoader, IILGener
             this.ilGenerator = ilGenerator;
         }
 
-        public T GenerateImplementation()
+        public T? GenerateImplementation()
         {
             Console.WriteLine("Generating Impl");
             AssemblyBuilder asmBuilder = AssemblyBuilder.DefineDynamicAssembly(new AssemblyName(typeof(T).Name + "Asm"), AssemblyBuilderAccess.Run);
@@ -33,7 +33,7 @@ public T GenerateImplementation()
             {
                 var parameters = method.GetParameters().Select(x => x.ParameterType).ToArray();
                 var methodBuilder = typeBuilder.DefineMethod(method.Name, MethodAttributes.Virtual | MethodAttributes.Public, method.ReturnType, parameters);
-                var nativeCallAttribute = method.GetCustomAttribute<NativeCallAtrribute>();
+                var nativeCallAttribute = method.GetCustomAttribute<NativeCallAttribute>();
                 string nativeName = method.Name;
                 if (nativeCallAttribute != null && nativeCallAttribute.NativeName != null)
                 {
@@ -44,7 +44,7 @@ public T GenerateImplementation()
 
             var typeInfo = typeBuilder.CreateTypeInfo();
 
-            return (T)typeInfo.GetConstructor(new Type[0]).Invoke(null);
+            return (T?)typeInfo?.GetConstructor(new Type[0]).Invoke(null);
         }
     }
 }

src/FRC-Utilities/NativeLibraryUtilities/ILibraryInformation.cs

@@ -8,11 +8,11 @@ public interface ILibraryInformation
         /// <summary>
         /// The LibraryLoader used to load this library
         /// </summary>
-        ILibraryLoader LibraryLoader { get; }
+        ILibraryLoader? LibraryLoader { get; }
         /// <summary>
         /// The location on disk of the native library
         /// </summary>
-        string LibraryLocation { get; }
+        string? LibraryLocation { get; }
         /// <summary>
         /// The OS Type of the loaded system.
         /// </summary>

src/FRC-Utilities/NativeLibraryUtilities/NativeCallAttribute.cs

@@ -6,28 +6,28 @@ namespace FRC.NativeLibraryUtilities
     /// Specifies that the attributed field should be considered a target for native initialization
     /// </summary>
     [AttributeUsage(AttributeTargets.Field)]
-    public class NativeCallAtrribute : Attribute
+    public class NativeCallAttribute : Attribute
     {
         /// <summary>
         /// Gets the native name for this field if set.
         /// </summary>
-        public string NativeName { get; }
+        public string? NativeName { get; }
 
         /// <summary>
-        /// Initializes a new instance of <see cref="NativeCallAtrribute"/>,
+        /// Initializes a new instance of <see cref="NativeCallAttribute"/>,
         /// using the name of the field as the native name.
         /// </summary>
-        public NativeCallAtrribute()
+        public NativeCallAttribute()
         {
             NativeName = null;
         }
 
         /// <summary>
-        /// Initializes a new instance of <see cref="NativeCallAtrribute"/>,
+        /// Initializes a new instance of <see cref="NativeCallAttribute"/>,
         /// with the name of the native method passed in.
         /// </summary>
         /// <param name="nativeName"></param>
-        public NativeCallAtrribute(string nativeName)
+        public NativeCallAttribute(string nativeName)
         {
             NativeName = nativeName;
         }

src/FRC-Utilities/NativeLibraryUtilities/NativeLibraryLoader.cs

@@ -15,14 +15,14 @@ public class NativeLibraryLoader : ILibraryInformation
         private readonly Dictionary<OsType, string> m_nativeLibraryName = new Dictionary<OsType, string>();
 
         /// <inheritdoc/>
-        public ILibraryLoader LibraryLoader { get; private set; }
+        public ILibraryLoader? LibraryLoader { get; private set; }
         /// <inheritdoc/>
         public OsType OsType { get; } = GetOsType();
         /// <inheritdoc/>
         public bool UsingTempFile { get; private set; }
 
         /// <inheritdoc/>
-        public string LibraryLocation { get; private set; }
+        public string? LibraryLocation { get; private set; }
 
         /// <summary>
         /// Checks if the current system is a roboRIO
@@ -51,7 +51,7 @@ public void AddLibraryLocation(OsType osType, string libraryName)
         /// <param name="location">The file location. Can be either an embedded resource, or a direct file location</param>
         /// <param name="directLoad">True to load the file directly from disk, otherwise false to extract from embedded</param>
         /// <param name="extractLocation">The location to extract to if the file is embedded. On null, it extracts to a temp file</param>
-        public void LoadNativeLibrary<T>(ILibraryLoader loader, string location, bool directLoad = false, string extractLocation = null)
+        public void LoadNativeLibrary<T>(ILibraryLoader? loader, string location, bool directLoad = false, string? extractLocation = null)
         {
             if (loader == null)
                 throw new ArgumentNullException(nameof(loader), "Library loader cannot be null");
@@ -75,9 +75,9 @@ public void LoadNativeLibrary<T>(ILibraryLoader loader, string location, bool di
             else
             // If we are loading from extraction, extract then load
             {
-                ExtractNativeLibrary(location, extractLocation, typeof(T));
+                ExtractNativeLibrary(location, extractLocation!, typeof(T));
                 LibraryLoader = loader;
-                loader.LoadLibrary(extractLocation);
+                loader.LoadLibrary(extractLocation!);
                 LibraryLocation = extractLocation;
             }
         }
@@ -89,7 +89,7 @@ public void LoadNativeLibrary<T>(ILibraryLoader loader, string location, bool di
         /// <param name="location">The file location. Can be either an embedded resource, or a direct file location</param>
         /// <param name="directLoad">True to load the file directly from disk, otherwise false to extract from embedded</param>
         /// <param name="extractLocation">The location to extract to if the file is embedded. On null, it extracts to a temp file</param>
-        public void LoadNativeLibrary<T>(string location, bool directLoad = false, string extractLocation = null)
+        public void LoadNativeLibrary<T>(string location, bool directLoad = false, string? extractLocation = null)
         {
             if (location == null)
                 throw new ArgumentNullException(nameof(location), "Library location cannot be null");
@@ -133,7 +133,7 @@ public void LoadNativeLibrary<T>(string location, bool directLoad = false, strin
         /// <typeparam name="T">The type containing the native resource, if it is embedded.</typeparam>
         /// <param name="directLoad">True to load the file directly from disk, otherwise false to extract from embedded</param>
         /// <param name="extractLocation">The location to extract to if the file is embedded. On null, it extracts to a temp file</param>
-        public void LoadNativeLibrary<T>(bool directLoad = false, string extractLocation = null)
+        public void LoadNativeLibrary<T>(bool directLoad = false, string? extractLocation = null)
         {
             OsType osType = OsType;
 
@@ -235,7 +235,12 @@ public void LoadNativeLibraryFromReflectedAssembly(string assemblyName, bool loc
             LibraryLocation = extractLocation;
         }
 
-        public T LoadNativeInterface<T>() where T : class {
+        /// <summary>
+        /// Load a native interface
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <returns></returns>
+        public T? LoadNativeInterface<T>() where T : class {
             if (!typeof(T).IsInterface) {
                 throw new InvalidOperationException($"{typeof(T).Name} must be an interface");
             }

src/FRC-Utilities/NativeLibraryUtilities/Uname.cs

@@ -7,12 +7,22 @@ namespace FRC.NativeLibraryUtilities
     internal sealed class Utsname
         : IEquatable<Utsname>
     {
-        public string sysname;
-        public string nodename;
-        public string release;
-        public string version;
-        public string machine;
-        public string domainname;
+        private readonly string sysname;
+        private readonly string nodename;
+        private readonly string release;
+        private readonly string version;
+        private readonly string machine;
+        private readonly string domainname;
+
+        public Utsname(string sysname, string nodename, string release, string version, string machine, string domainname)
+        {
+            this.sysname = sysname;
+            this.nodename = nodename;
+            this.release = release;
+            this.version = version;
+            this.machine = machine;
+            this.domainname = domainname;
+        }
 
         public override int GetHashCode()
         {
@@ -33,7 +43,6 @@ public override bool Equals(object obj)
 
         public bool Equals(Utsname value)
         {
-            if (value == null) return false;
             return value.sysname == sysname && value.nodename == nodename &&
                 value.release == release && value.version == version &&
                 value.machine == machine && value.domainname == domainname;
@@ -70,19 +79,18 @@ internal struct _Utsname
 
     internal class Uname
     {
-        private static void CopyUtsname(ref Utsname to, ref _Utsname from)
+        private static void CopyUtsname(out Utsname to, ref _Utsname from)
         {
             try
             {
-                to = new Utsname
-                {
-                    sysname = Marshal.PtrToStringAnsi(from.sysname),
-                    nodename = Marshal.PtrToStringAnsi(from.nodename),
-                    release = Marshal.PtrToStringAnsi(from.release),
-                    version = Marshal.PtrToStringAnsi(from.version),
-                    machine = Marshal.PtrToStringAnsi(from.machine),
-                    domainname = Marshal.PtrToStringAnsi(from.domainname)
-                };
+                to = new Utsname(
+                    Marshal.PtrToStringAnsi(from.sysname),
+                    Marshal.PtrToStringAnsi(from.nodename),
+                    Marshal.PtrToStringAnsi(from.release),
+                    Marshal.PtrToStringAnsi(from.version),
+                    Marshal.PtrToStringAnsi(from.machine),
+                    Marshal.PtrToStringAnsi(from.domainname)
+               );
             }
             finally
             {
@@ -101,14 +109,14 @@ private static void CopyUtsname(ref Utsname to, ref _Utsname from)
              EntryPoint = "Mono_Posix_Syscall_uname")]
         private static extern int sys_uname(out _Utsname buf);
 
-        public static int uname(out Utsname buf)
+        public static int uname(out Utsname? buf)
         {
             _Utsname _buf;
             int r = sys_uname(out _buf);
-            buf = new Utsname();
+            buf = null;
             if (r == 0)
             {
-                CopyUtsname(ref buf, ref _buf);
+                CopyUtsname(out buf, ref _buf);
             }
             return r;
         }