Fix processing of typedef flags (#114)

***UPDATE_DEPENDENTS***

Author: josesimoes

MetadataProcessor.Core/Tables/nanoMethodDefinitionTable.cs

@@ -120,8 +120,7 @@ protected override void WriteSingleItem(
             writer.WriteUInt16(methodSignature);
         }
 
-        public static uint GetFlags(
-            MethodDefinition method)
+        public static uint GetFlags(MethodDefinition method)
         {
             const uint MD_Scope_Private =           0x00000001; // Accessible only by the parent type.
             const uint MD_Scope_FamANDAssem =       0x00000002; // Accessible by sub-types only in this Assembly.
@@ -277,17 +276,6 @@ public static uint GetFlags(
                 }
             }
 
-            var methodName = method.Name;
-            if (methodName == "Finalize" &&
-                method.ReturnType.FullName == "System.Void" &&
-                !method.HasParameters)
-            {
-                flag |= MD_Finalizer;
-                
-                // TODO
-                // missing setting tdDst->flags |= CLR_RECORD_TYPEDEF::TD_HasFinalizer;
-            }
-
             return flag;
         }
     }

MetadataProcessor.Core/Tables/nanoTypeDefinitionTable.cs

@@ -151,7 +151,11 @@ protected override void WriteSingleItem(
                 }
             }
 
-            writer.WriteUInt16((ushort)GetFlags(item)); // flags
+            // write flags
+            writer.WriteUInt16(
+                (ushort)GetFlags(
+                    item,
+                    _context.MethodDefinitionTable));
         }
 
         private void WriteClassFields(
@@ -295,8 +299,18 @@ private ushort GetTypeReferenceOrDefinitionId(
             return 0xFFFF;
         }
 
+        /// <summary>
+        /// Get flags for the Type definition.
+        /// </summary>
+        /// <param name="definition"><see cref="TypeDefinition"/> to get the flags</param>
+        /// <param name="methodDefinitioTable">List with type definitions that have finalizers, if this check is required.</param>
+        /// <returns></returns>
+        /// <remarks>
+        /// If the <paramref name="typesWithFinalizers"/> is null, the check for finalizer won't be checked.
+        /// </remarks>
         internal static nanoTypeDefinitionFlags GetFlags(
-            TypeDefinition definition)
+            TypeDefinition definition,
+            nanoMethodDefinitionTable methodDefinitioTable = null)
         {
             var flags = nanoTypeDefinitionFlags.TD_Scope_None;
 
@@ -389,6 +403,27 @@ internal static nanoTypeDefinitionFlags GetFlags(
                 flags |= nanoTypeDefinitionFlags.TD_Delegate;
             }
 
+            // need to check for finalizers methods
+            if (methodDefinitioTable != null)
+            {
+                foreach (var m in definition.Methods)
+                {
+                    if (methodDefinitioTable.Items.Contains(m))
+                    {
+                        var methodName = m.Name;
+                        if (methodName == "Finalize" &&
+                            m.ReturnType.FullName == "System.Void" &&
+                            !m.HasParameters)
+                        {
+                            if (m.DeclaringType.FullName != "System.Object")
+                            {
+                                flags |= nanoTypeDefinitionFlags.TD_HasFinalizer;
+                            }
+                        }
+                    }
+                }
+            }
+
             return flags;
         }
 

MetadataProcessor.Core/nanoDumperGenerator.cs

@@ -198,7 +198,10 @@ private void DumpTypeDefinitions(DumpAllTable dumpTable)
                     typeDef.Name = t.FullName;
                 }
 
-                var typeFlags = (uint)nanoTypeDefinitionTable.GetFlags(t);
+                var typeFlags = (uint)nanoTypeDefinitionTable.GetFlags(
+                    t,
+                    _tablesContext.MethodDefinitionTable);
+
                 typeDef.Flags = typeFlags.ToString("x8");
 
                 if (t.BaseType != null)