Fix getting scope for type references

- Code to figure out scope has been improved so it doesn't rely solely on DeclaringType. Now performs a true check if the type is defined in the same assembly or not.
- WriteItem now can handle nested types, by writting the full type name (this has to be processed accordingly in type resolution in nanoCLR).
- Update class in test app to declare a local with an enum from amother assembly and an enum from another assembly declared as a nested type.

Author: josesimoes

MetadataProcessor.Shared/Tables/nanoTypeReferenceTable.cs

@@ -4,9 +4,10 @@
 // See LICENSE file in the project root for full license information.
 //
 
-using Mono.Cecil;
+using System;
 using System.Collections.Generic;
 using System.Diagnostics;
+using Mono.Cecil;
 
 namespace nanoFramework.Tools.MetadataProcessor
 {
@@ -69,7 +70,11 @@ protected override void WriteSingleItem(
         {
             var writerStartPosition = writer.BaseStream.Position;
 
-            WriteStringReference(writer, item.Name);
+
+            // Get the full name for nested types
+            string fullName = nanoTypeReferenceTable.GetFullName(item);
+
+            WriteStringReference(writer, fullName);
             WriteStringReference(writer, item.Namespace);
 
             writer.WriteUInt16(GetScope(item)); // scope - TBL_AssemblyRef | TBL_TypeRef // 0x8000
@@ -90,17 +95,45 @@ protected override void AllocateSingleItemStrings(
         internal ushort GetScope(
             TypeReference typeReference)
         {
-            // TODO need to review this to use TypeRefOrAssemblyRef
-            if (typeReference.DeclaringType == null)
+            // Check if the type is defined in the same assembly
+            if (typeReference.Scope is ModuleDefinition moduleDefinition
+                && moduleDefinition.Assembly == _context.AssemblyDefinition)
+            {
+                // The type is defined in the same assembly
+                if (_context.TypeReferencesTable.TryGetTypeReferenceId(
+                    typeReference.DeclaringType,
+                    out ushort referenceId))
+                {
+                    return (ushort)(0x8000 | referenceId);
+                }
+                else
+                {
+                    // unknown scope
+                    throw new InvalidOperationException($"Unknown scope for type reference '{typeReference.FullName}'");
+                }
+            }
+            else if (typeReference.Scope is AssemblyNameReference assemblyNameReference)
             {
-                return _context.AssemblyReferenceTable.GetReferenceId(typeReference.Scope as AssemblyNameReference);
+                // The type is defined in a referenced assembly
+                return _context.AssemblyReferenceTable.GetReferenceId(assemblyNameReference);
             }
             else
             {
-                ushort referenceId;
-                _context.TypeReferencesTable.TryGetTypeReferenceId(typeReference.DeclaringType, out referenceId);
-                return (ushort)(0x8000 | referenceId);
+                // unknown scope
+                throw new InvalidOperationException($"Unknown scope for type reference '{typeReference.FullName}'");
             }
+
+        }
+
+        private static string GetFullName(TypeReference typeReference)
+        {
+            if (typeReference.DeclaringType == null)
+            {
+                return typeReference.Name;
+            }
+
+            // return the full name of the declaring type
+            return typeReference.FullName;
         }
     }
 }

MetadataProcessor.Tests/TestNFApp/TestEnumInAnotherAssembly.cs

@@ -10,11 +10,23 @@ public class TestEnumInAnotherAssembly
         public void CallTestEnumInAnotherAssembly()
         {
             // This test checks if MDP can minimize the assembly using an enum that is defined in another assembly
-            // and the class calling it is in a different assembly BUT in the same namespace.
-            var ioException = new IOException(
+            // as a nested type
+            IOException.IOExceptionErrorCode dummyEnum = IOException.IOExceptionErrorCode.DirectoryNotFound;
+
+            _ = new IOException(
                     string.Empty,
-                    (int)IOException.IOExceptionErrorCode.DirectoryNotFound);
+                    (int)dummyEnum);
+
+            // This test checks if MDP can minimize the assembly using an enum that is defined in another assembly
+            Base64FormattingOptions formattingOptions = Base64FormattingOptions.InsertLineBreaks;
+
+            byte[] testBytes = new byte[] {0x01, 0x03, 0x05, 0x07, 0x09 };
+
+            _ = Convert.ToBase64String(
+                testBytes,
+                0,
+                testBytes.Length,
+                formattingOptions);
         }
     }
-
 }