Relax constraints on duplicated members in metadata buffers

src/AsmResolver.DotNet/Builder/DotNetDirectoryBuffer.TokenProvider.cs

@@ -38,7 +38,7 @@ public MetadataToken AddTypeReference(TypeReference? type, bool allowDuplicates,
                 Metadata.StringsStream.GetStringIndex(type.Name),
                 Metadata.StringsStream.GetStringIndex(type.Namespace));
 
-            var token = preserveRid
+            var token = preserveRid && type.MetadataToken.Rid != 0
                 ? table.Insert(type.MetadataToken.Rid, row, allowDuplicates)
                 : table.Add(row, allowDuplicates);
 
@@ -205,7 +205,7 @@ public MetadataToken AddAssemblyReference(AssemblyReference? assembly, bool allo
                 Metadata.StringsStream.GetStringIndex(assembly.Culture),
                 Metadata.BlobStream.GetBlobIndex(assembly.HashValue));
 
-            var token = preserveRid
+            var token = preserveRid && assembly.MetadataToken.Rid != 0
                 ? table.Insert(assembly.MetadataToken.Rid, row, allowDuplicates)
                 : table.Add(row, allowDuplicates);
 
@@ -243,7 +243,7 @@ public MetadataToken AddModuleReference(ModuleReference? reference, bool allowDu
             var table = Metadata.TablesStream.GetDistinctTable<ModuleReferenceRow>(TableIndex.ModuleRef);
 
             var row = new ModuleReferenceRow(Metadata.StringsStream.GetStringIndex(reference.Name));
-            var token = preserveRid
+            var token = preserveRid && reference.MetadataToken.Rid != 0
                 ? table.Insert(reference.MetadataToken.Rid, row, allowDuplicates)
                 : table.Add(row, allowDuplicates);
 

src/AsmResolver.DotNet/Builder/DotNetDirectoryFactory.cs

@@ -215,9 +215,6 @@ private IMetadataBuffer CreateMetadataBuffer(ModuleDefinition module)
 
         private void ImportBasicTablesIfSpecified(ModuleDefinition module, DotNetDirectoryBuffer buffer)
         {
-            if (module.DotNetDirectory is null)
-                return;
-
             // NOTE: The order of this table importing is crucial.
             //
             // Assembly refs should always be imported prior to importing type refs, which should be imported before
@@ -246,9 +243,6 @@ private void ImportBasicTablesIfSpecified(ModuleDefinition module, DotNetDirecto
 
         private void ImportTypeSpecsIfSpecified(ModuleDefinition module, DotNetDirectoryBuffer buffer)
         {
-            if (module.DotNetDirectory is null)
-                return;
-
             if ((MetadataBuilderFlags & MetadataBuilderFlags.PreserveTypeSpecificationIndices) != 0)
             {
                 ImportTables<TypeSpecification>(module, TableIndex.TypeSpec,
@@ -258,9 +252,6 @@ private void ImportTypeSpecsIfSpecified(ModuleDefinition module, DotNetDirectory
 
         private void ImportMemberRefsIfSpecified(ModuleDefinition module, DotNetDirectoryBuffer buffer)
         {
-            if (module.DotNetDirectory is null)
-                return;
-
             if ((MetadataBuilderFlags & MetadataBuilderFlags.PreserveMemberReferenceIndices) != 0)
             {
                 ImportTables<MemberReference>(module, TableIndex.MemberRef,
@@ -270,9 +261,6 @@ private void ImportMemberRefsIfSpecified(ModuleDefinition module, DotNetDirector
 
         private void ImportRemainingTablesIfSpecified(ModuleDefinition module, DotNetDirectoryBuffer buffer)
         {
-            if (module.DotNetDirectory is null)
-                return;
-
             if ((MetadataBuilderFlags & MetadataBuilderFlags.PreserveStandAloneSignatureIndices) != 0)
             {
                 ImportTables<StandAloneSignature>(module, TableIndex.StandAloneSig,
@@ -289,10 +277,10 @@ private void ImportRemainingTablesIfSpecified(ModuleDefinition module, DotNetDir
         private static void ImportTables<TMember>(ModuleDefinition module, TableIndex tableIndex,
             Func<TMember, MetadataToken> importAction)
         {
-            int count = module.DotNetDirectory!.Metadata
-                !.GetStream<TablesStream>()
+            int count = module.DotNetDirectory?.Metadata?
+                .GetStream<TablesStream>()
                 .GetTable(tableIndex)
-                .Count;
+                .Count ?? 0;
 
             for (uint rid = 1; rid <= count; rid++)
                 importAction((TMember) module.LookupMember(new MetadataToken(tableIndex, rid)));

src/AsmResolver.DotNet/Builder/TokenMapping.cs

@@ -64,12 +64,14 @@ public void Register(IMetadataMember member, MetadataToken newToken)
             if (member.MetadataToken.Table != newToken.Table)
                 throw new ArgumentException($"Cannot assign a {newToken.Table} metadata token to a {member.MetadataToken.Table}.");
 
-            if (TryGetNewToken(member, out var existingToken))
-            {
-                if (existingToken.Rid != newToken.Rid)
-                    throw new ArgumentException($"Member {member.SafeToString()} was already assigned a metadata token.");
+            // We allow for members to be duplicated in the mapping, but we will only keep track of the first token that
+            // was registered for this member. This may result in a slightly different binary if token preservation is
+            // enabled (e.g., a member may originally have referenced a duplicated member as opposed to the first one,
+            // and this would always make it reference the first one), but since both members are semantically equivalent,
+            // referencing one or the other should also be semantics-preserving. Note that both duplicated members will
+            // still be present in the final binary with their original RIDs.
+            if (TryGetNewToken(member, out _))
                 return;
-            }
 
             switch (member.MetadataToken.Table)
             {

src/AsmResolver/Collections/BitList.cs

@@ -46,15 +46,15 @@ public bool this[int index]
         {
             get
             {
-                if (index >= Count)
+                if (index < 0 || index >= Count)
                     throw new IndexOutOfRangeException();
 
                 (int wordIndex, int bitIndex) = SplitWordBitIndex(index);
                 return (_words[wordIndex] >> bitIndex & 1) != 0;
             }
             set
             {
-                if (index >= Count)
+                if (index < 0 || index >= Count)
                     throw new IndexOutOfRangeException();
 
                 (int wordIndex, int bitIndex) = SplitWordBitIndex(index);
@@ -119,7 +119,7 @@ public int IndexOf(bool item)
         /// <inheritdoc />
         public void Insert(int index, bool item)
         {
-            if (index > Count)
+            if (index < 0 || index > Count)
                 throw new IndexOutOfRangeException();
 
             EnsureCapacity(Count++);

test/AsmResolver.DotNet.Tests/Builder/TokenPreservation/TypeRefTokenPreservationTest.cs

@@ -100,6 +100,36 @@ public void PreserveDuplicatedTypeRefs()
                 newObjectReferences.Select(r => r.MetadataToken).ToHashSet());
         }
 
+        [Fact]
+        public void PreserveDuplicatedTypeRefsInBaseType()
+        {
+            // Prepare temp module with two references to System.Object
+            var module = new ModuleDefinition("Test");
+            var assembly = new AssemblyDefinition("Test", new Version(1, 0, 0, 0));
+            assembly.Modules.Add(module);
+
+            var ref1 = (TypeReference) module.CorLibTypeFactory.CorLibScope
+                .CreateTypeReference("System", "Object")
+                .ImportWith(module.DefaultImporter);
+            var ref2 = (TypeReference) module.CorLibTypeFactory.CorLibScope
+                .CreateTypeReference("System", "Object")
+                .ImportWith(module.DefaultImporter);
+
+            // Force assign new tokens to instruct builder that both type references need to be added.
+            module.TokenAllocator.AssignNextAvailableToken(ref1);
+            module.TokenAllocator.AssignNextAvailableToken(ref2);
+
+            module.TopLevelTypes.Add(new TypeDefinition(null, "A", TypeAttributes.Public, ref1));
+            module.TopLevelTypes.Add(new TypeDefinition(null, "B", TypeAttributes.Public, ref2));
+
+            // Rebuild.
+            var image = module.ToPEImage(new ManagedPEImageBuilder(MetadataBuilderFlags.PreserveTypeReferenceIndices));
+
+            // Verify that both object references are still there.
+            var newModule = ModuleDefinition.FromImage(image);
+            Assert.Equal(2, newModule.GetImportedTypeReferences().Count(t => t.Name == "Object"));
+        }
+
         [Fact]
         public void PreserveNestedTypeRefOrdering()
         {
@@ -113,5 +143,6 @@ public void PreserveNestedTypeRefOrdering()
 
             Assert.Equal(originalTypeRefs, newTypeRefs.Take(originalTypeRefs.Count), Comparer);
         }
+
     }
 }