Update Cecil submodule to latest

KirillOsenkov · KirillOsenkov · commit 15d48eff12c8 · 2023-12-28T19:32:01.000-08:00
Read embedded pdbs Copy debug information for scopes and imports Taken from Alexx999#3 Make the output assembly MVID deterministic Fix test locking dlls Add .ToArray() to flush the Linq expression so that it is not evaluated more than once. Better error if the pdb doesn't exist Use cecil from https://github.com/KirillOsenkov/cecil/tree/ilrepack
diff --git a/.gitmodules b/.gitmodules
@@ -1,3 +1,4 @@
 [submodule "cecil"]
 	path = cecil
-	url = https://github.com/gluck/cecil.git
+	url = https://github.com/KirillOsenkov/cecil
+	branch = ilrepack
diff --git a/Directory.Build.props b/Directory.Build.props
@@ -1,5 +1,9 @@
 <Project>
 
+  <PropertyGroup>
+    <LangVersion>latest</LangVersion>
+  </PropertyGroup>
+
   <ItemGroup>
     <PackageReference Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.3" />
   </ItemGroup>
diff --git a/ILRepack.IntegrationTests/NuGet/RepackNuGetTests.cs b/ILRepack.IntegrationTests/NuGet/RepackNuGetTests.cs
@@ -136,7 +136,7 @@ public void VerifiesMergedPdbUnchangedSourceIndexationForTfsIndexation()
         {
             // This test requires Mono.Cecil.Pdb.dll. Indicate a dependency such that
             // the reference is not accidentally removed.
-            _ = typeof(Mono.Cecil.Pdb.PdbReader);
+            _ = typeof(Mono.Cecil.Pdb.PdbReaderProvider);
 
             var platform = Platform.From(
                 Package.From("TfsIndexer", "1.2.4"),
diff --git a/ILRepack.IntegrationTests/NuGet/TestHelpers.cs b/ILRepack.IntegrationTests/NuGet/TestHelpers.cs
@@ -38,12 +38,20 @@ public static void DoRepackForCmd(IEnumerable<string> args)
 
         private static void ReloadAndCheckReferences(RepackOptions repackOptions)
         {
-            var outputFile = AssemblyDefinition.ReadAssembly(repackOptions.OutputFile, new ReaderParameters(ReadingMode.Immediate));
-            var mergedFiles = repackOptions.ResolveFiles().Select(f => AssemblyDefinition.ReadAssembly(f, new ReaderParameters(ReadingMode.Deferred)));
+            using var ar = new DefaultAssemblyResolver();
+            using var outputFile = AssemblyDefinition.ReadAssembly(repackOptions.OutputFile, new ReaderParameters(ReadingMode.Immediate));
+            var mergedFiles = repackOptions
+                .ResolveFiles()
+                .Select(f => AssemblyDefinition.ReadAssembly(f, new ReaderParameters(ReadingMode.Deferred)))
+                .ToArray();
             foreach (var a in outputFile.MainModule.AssemblyReferences.Where(x => mergedFiles.Any(y => repackOptions.KeepOtherVersionReferences ? x.FullName == y.FullName : x.Name == y.Name.Name)))
             {
                 Assert.Fail($"Merged assembly retains a reference to one (or more) of the merged files: {a.FullName}");
             }
+            foreach (var a in mergedFiles)
+            {
+                a.Dispose();
+            }
         }
 
         public static void SaveAs(Stream input, string directory, string fileName)
diff --git a/ILRepack/IKVMLineIndexer.cs b/ILRepack/IKVMLineIndexer.cs
@@ -17,7 +17,6 @@ internal class IKVMLineIndexer
     {
         private readonly IRepackContext repack;
         private bool enabled;
-        private LineNumberWriter lineNumberWriter;
         private string fileName;
         private TypeReference sourceFileAttributeTypeReference;
         private TypeReference lineNumberTableAttributeTypeReference;
@@ -41,29 +40,29 @@ public IKVMLineIndexer(IRepackContext ilRepack, bool doLineIndexing)
 
         public void Reset()
         {
-            lineNumberWriter = null;
             fileName = null;
         }
 
         public void PreMethodBodyRepack(MethodBody body, MethodDefinition parent)
         {
-            if (!enabled)
+            if (!enabled || !parent.DebugInformation.HasSequencePoints)
                 return;
 
             Reset();
             if (!parent.CustomAttributes.Any(x => x.Constructor.DeclaringType.Name == "LineNumberTableAttribute"))
             {
-                lineNumberWriter = new LineNumberWriter(body.Instructions.Count / 4);
+                var lineNumberWriter = new LineNumberWriter(body.Instructions.Count / 4);
+                foreach (var sp in parent.DebugInformation.SequencePoints)
+                {
+                    AddSeqPoint(sp, lineNumberWriter);
+                }
+                PostMethodBodyRepack(parent, lineNumberWriter);
             }
         }
 
-        public void ProcessMethodBodyInstruction(Instruction instr)
+        private void AddSeqPoint(SequencePoint currentSeqPoint, LineNumberWriter lineNumberWriter)
         {
-            if (!enabled)
-                return;
-
-            var currentSeqPoint = instr.SequencePoint;
-            if (lineNumberWriter != null && currentSeqPoint != null)
+            if (currentSeqPoint != null)
             {
                 if (fileName == null && currentSeqPoint.Document != null)
                 {
@@ -84,25 +83,22 @@ public void ProcessMethodBodyInstruction(Instruction instr)
                 {
                     if (lineNumberWriter.LineNo > 0)
                     {
-                        lineNumberWriter.AddMapping(instr.Offset, -1);
+                        lineNumberWriter.AddMapping(currentSeqPoint.Offset, -1);
                     }
                 }
                 else
                 {
                     if (lineNumberWriter.LineNo != currentSeqPoint.StartLine)
                     {
-                        lineNumberWriter.AddMapping(instr.Offset, currentSeqPoint.StartLine);
+                        lineNumberWriter.AddMapping(currentSeqPoint.Offset, currentSeqPoint.StartLine);
                     }
                 }
             }
         }
 
-        public void PostMethodBodyRepack(MethodDefinition parent)
+        private void PostMethodBodyRepack(MethodDefinition parent, LineNumberWriter lineNumberWriter)
         {
-            if (!enabled)
-                return;
-
-            if (lineNumberWriter != null && lineNumberWriter.Count > 0)
+            if (lineNumberWriter.Count > 0)
             {
                 CustomAttribute ca;
                 if (lineNumberWriter.Count == 1)
@@ -155,7 +151,7 @@ public void PostRepackReferences()
             IMetadataScope ikvmRuntimeReference = repack.TargetAssemblyMainModule.AssemblyReferences.FirstOrDefault(r => r.Name == "IKVM.Runtime");
             if (ikvmRuntimeReference == null)
             {
-                ikvmRuntimeReference = repack.MergeScope(repack.GlobalAssemblyResolver.Resolve("IKVM.Runtime").Name);
+                ikvmRuntimeReference = repack.MergeScope(repack.GlobalAssemblyResolver.Resolve(new AssemblyNameReference("IKVM.Runtime", null)).Name);
             }
             if (ikvmRuntimeReference == null)
             {
diff --git a/ILRepack/ILRepack.cs b/ILRepack/ILRepack.cs
@@ -21,6 +21,7 @@
 using System.Text.RegularExpressions;
 using ILRepacking.Steps;
 using Mono.Cecil;
+using Mono.Cecil.Cil;
 using Mono.Cecil.PE;
 using Mono.Unix.Native;
 using ILRepacking.Mixins;
@@ -112,9 +113,10 @@ private AssemblyDefinitionContainer ReadInputAssembly(string assembly, bool isPr
             {
                 ReaderParameters rp = new ReaderParameters(ReadingMode.Immediate) { AssemblyResolver = GlobalAssemblyResolver };
                 // read PDB/MDB?
-                if (Options.DebugInfo && (File.Exists(Path.ChangeExtension(assembly, "pdb")) || File.Exists(assembly + ".mdb")))
+                if (Options.DebugInfo)
                 {
                     rp.ReadSymbols = true;
+                    rp.SymbolReaderProvider = new DefaultSymbolReaderProvider(throwIfNoSymbol: false);
                 }
                 AssemblyDefinition mergeAsm;
                 try
@@ -144,6 +146,7 @@ private AssemblyDefinitionContainer ReadInputAssembly(string assembly, bool isPr
 
                 if (!Options.AllowZeroPeKind && (mergeAsm.MainModule.Attributes & ModuleAttributes.ILOnly) == 0)
                     throw new ArgumentException("Failed to load assembly with Zero PeKind: " + assembly);
+                GlobalAssemblyResolver.RegisterAssembly(mergeAsm);
 
                 return new AssemblyDefinitionContainer
                 {
@@ -264,7 +267,6 @@ public void Repack()
 
             // Read input assemblies only after all properties are set.
             ReadInputAssemblies();
-            GlobalAssemblyResolver.RegisterAssemblies(MergedAssemblies);
 
             _platformFixer = new PlatformFixer(this, PrimaryAssemblyMainModule.Runtime);
             _mappingHandler = new MappingHandler();
@@ -309,7 +311,7 @@ public void Repack()
             }
             // set the main module attributes
             TargetAssemblyMainModule.Attributes = PrimaryAssemblyMainModule.Attributes;
-            TargetAssemblyMainModule.Win32ResourceDirectory = MergeWin32Resources(PrimaryAssemblyMainModule.Win32ResourceDirectory);
+            TargetAssemblyMainModule.Win32ResourceDirectory = MergeWin32Resources();
 
             if (Options.Version != null)
                 TargetAssemblyDefinition.Name.Version = Options.Version;
@@ -337,10 +339,17 @@ public void Repack()
                     step.Perform();
                 }
 
+                var anySymbolReader = MergedAssemblies
+                    .Select(m => m.MainModule.SymbolReader)
+                    .Where(r => r != null)
+                    .FirstOrDefault();
+                var symbolWriterProvider = anySymbolReader?.GetWriterProvider();
                 var parameters = new WriterParameters
                 {
                     StrongNameKeyPair = signingStep.KeyPair,
-                    WriteSymbols = Options.DebugInfo
+                    WriteSymbols = Options.DebugInfo && symbolWriterProvider != null,
+                    SymbolWriterProvider = symbolWriterProvider,
+                    DeterministicMvid = true
                 };
                 // create output directory if it does not exist
                 var outputDir = Path.GetDirectoryName(Options.OutputFile);
@@ -350,11 +359,19 @@ public void Repack()
                     Directory.CreateDirectory(outputDir);
                 }
 
+                Logger.Info("Writing output assembly to disk");
                 TargetAssemblyDefinition.Write(Options.OutputFile, parameters);
 
                 sourceServerDataStep.Write();
 
-                Logger.Info("Writing output assembly to disk");
+                foreach (var assembly in MergedAssemblies)
+                {
+                    assembly.Dispose();
+                }
+
+                TargetAssemblyDefinition.Dispose();
+                GlobalAssemblyResolver.Dispose();
+
                 // If this is an executable and we are on linux/osx we should copy file permissions from
                 // the primary assembly
                 if (isUnixEnvironment && (kind == ModuleKind.Console || kind == ModuleKind.Windows))
@@ -405,13 +422,17 @@ private void ResolveSearchDirectories()
             }
         }
 
-        private ResourceDirectory MergeWin32Resources(ResourceDirectory primary)
+        private ResourceDirectory MergeWin32Resources()
         {
-            if (primary == null)
-                return null;
+            var primary = PrimaryAssemblyMainModule.ReadWin32ResourceDirectory() ?? new ResourceDirectory();
+
             foreach (var ass in OtherAssemblies)
             {
-                MergeDirectory(new List<ResourceEntry>(), primary, ass, ass.MainModule.Win32ResourceDirectory);
+                var directory = ass.MainModule.ReadWin32ResourceDirectory();
+                if (directory != null)
+                {
+                    MergeDirectory(new List<ResourceEntry>(), primary, ass, directory);
+                }
             }
             return primary;
         }
diff --git a/ILRepack/Mixins/Mixins.cs b/ILRepack/Mixins/Mixins.cs
@@ -0,0 +1,16 @@
+using System.Collections.Generic;
+using Mono.Collections.Generic;
+
+namespace ILRepacking.Mixins
+{
+    static class CollectionMixins
+    {
+        public static void AddRange<T>(this Collection<T> destination, IEnumerable<T> source)
+        {
+            foreach (var item in source)
+            {
+                destination.Add(item);
+            }
+        }
+    }
+}
diff --git a/ILRepack/PlatformFixer.cs b/ILRepack/PlatformFixer.cs
@@ -192,7 +192,7 @@ private void FixPlatformVersion(ParameterDefinition pd)
         private void FixPlatformVersion(GenericParameter gp)
         {
             if (gp.HasConstraints)
-                foreach (TypeReference tr in gp.Constraints)
+                foreach (var tr in gp.Constraints)
                     FixPlatformVersion(tr);
             if (gp.HasCustomAttributes)
                 foreach (CustomAttribute ca in gp.CustomAttributes)
@@ -202,6 +202,11 @@ private void FixPlatformVersion(GenericParameter gp)
                     FixPlatformVersion(gp1);
         }
 
+        private void FixPlatformVersion(GenericParameterConstraint gp)
+        {
+            FixPlatformVersion(gp.ConstraintType);
+        }
+
         private void FixPlatformVersion(CustomAttribute ca)
         {
             FixPlatformVersion(ca.Constructor);
diff --git a/ILRepack/ReferenceFixator.cs b/ILRepack/ReferenceFixator.cs
@@ -111,14 +111,27 @@ internal void FixMethodVisibility(TypeDefinition type)
                 FixOverridenMethodDef(meth);
         }
 
+        private void FixReferences(Collection<GenericParameterConstraint> constraints)
+        {
+            foreach (var constraint in constraints)
+            {
+                constraint.ConstraintType = Fix(constraint.ConstraintType);
+                FixReferences(constraint.CustomAttributes);
+            }
+        }
+
         internal void FixReferences(TypeDefinition type)
         {
             FixReferences(type.GenericParameters);
 
             type.BaseType = Fix(type.BaseType);
 
             // interfaces before methods, because methods will have to go through them
-            FixReferences(type.Interfaces);
+            foreach (InterfaceImplementation nested in type.Interfaces)
+            {
+                nested.InterfaceType = Fix(nested.InterfaceType);
+                FixReferences(nested.CustomAttributes);
+            }
 
             // nested types first
             foreach (TypeDefinition nested in type.NestedTypes)
@@ -332,7 +345,7 @@ private bool IsAnnotation(TypeDefinition typeAttribute)
         {
             if (typeAttribute == null)
                 return false;
-            if (typeAttribute.Interfaces.Any(@interface => @interface.FullName == "java.lang.annotation.Annotation"))
+            if (typeAttribute.Interfaces.Any(@interface => @interface.InterfaceType.FullName == "java.lang.annotation.Annotation"))
                 return true;
             return typeAttribute.BaseType != null && IsAnnotation(typeAttribute.BaseType.Resolve());
         }
diff --git a/ILRepack/RepackAssemblyResolver.cs b/ILRepack/RepackAssemblyResolver.cs
@@ -1,16 +1,12 @@
 using Mono.Cecil;
-using System.Collections.Generic;
 
 namespace ILRepacking
 {
     public class RepackAssemblyResolver : DefaultAssemblyResolver
     {
-        public void RegisterAssemblies(IList<AssemblyDefinition> mergedAssemblies)
+        public new void RegisterAssembly(AssemblyDefinition assembly)
         {
-            foreach (var assemblyDefinition in mergedAssemblies)
-            {
-                RegisterAssembly(assemblyDefinition);
-            }
+            base.RegisterAssembly(assembly);
         }
     }
 }
diff --git a/ILRepack/RepackImporter.cs b/ILRepack/RepackImporter.cs
diff --git a/ILRepack/Steps/SourceServerData/PdbStr.cs b/ILRepack/Steps/SourceServerData/PdbStr.cs
diff --git a/ILRepack/Steps/XamlResourcePathPatcherStep.cs b/ILRepack/Steps/XamlResourcePathPatcherStep.cs
diff --git a/cecil b/cecil

Original file line number	Diff line number	Diff line change
`@@ -136,7 +136,7 @@ public void VerifiesMergedPdbUnchangedSourceIndexationForTfsIndexation()`
`136`	`136`	`{`
`137`	`137`	`// This test requires Mono.Cecil.Pdb.dll. Indicate a dependency such that`
`138`	`138`	`// the reference is not accidentally removed.`
`139`		`- _ = typeof(Mono.Cecil.Pdb.PdbReader);`
	`139`	`+ _ = typeof(Mono.Cecil.Pdb.PdbReaderProvider);`
`140`	`140`
`141`	`141`	`var platform = Platform.From(`
`142`	`142`	`Package.From("TfsIndexer", "1.2.4"),`
Original file line number	Diff line number	Diff line change
`@@ -38,12 +38,20 @@ public static void DoRepackForCmd(IEnumerable<string> args)`
`38`	`38`
`39`	`39`	`private static void ReloadAndCheckReferences(RepackOptions repackOptions)`
`40`	`40`	`{`
`41`		`- var outputFile = AssemblyDefinition.ReadAssembly(repackOptions.OutputFile, new ReaderParameters(ReadingMode.Immediate));`
`42`		`- var mergedFiles = repackOptions.ResolveFiles().Select(f => AssemblyDefinition.ReadAssembly(f, new ReaderParameters(ReadingMode.Deferred)));`
	`41`	`+ using var ar = new DefaultAssemblyResolver();`
	`42`	`+ using var outputFile = AssemblyDefinition.ReadAssembly(repackOptions.OutputFile, new ReaderParameters(ReadingMode.Immediate));`
	`43`	`+ var mergedFiles = repackOptions`
	`44`	`+ .ResolveFiles()`
	`45`	`+ .Select(f => AssemblyDefinition.ReadAssembly(f, new ReaderParameters(ReadingMode.Deferred)))`
	`46`	`+ .ToArray();`
`43`	`47`	`foreach (var a in outputFile.MainModule.AssemblyReferences.Where(x => mergedFiles.Any(y => repackOptions.KeepOtherVersionReferences ? x.FullName == y.FullName : x.Name == y.Name.Name)))`
`44`	`48`	`{`
`45`	`49`	`Assert.Fail($"Merged assembly retains a reference to one (or more) of the merged files: {a.FullName}");`
`46`	`50`	`}`
	`51`	`+ foreach (var a in mergedFiles)`
	`52`	`+ {`
	`53`	`+ a.Dispose();`
	`54`	`+ }`
`47`	`55`	`}`
`48`	`56`
`49`	`57`	`public static void SaveAs(Stream input, string directory, string fileName)`
Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,6 @@ internal class IKVMLineIndexer`
`17`	`17`	`{`
`18`	`18`	`private readonly IRepackContext repack;`
`19`	`19`	`private bool enabled;`
`20`		`- private LineNumberWriter lineNumberWriter;`
`21`	`20`	`private string fileName;`
`22`	`21`	`private TypeReference sourceFileAttributeTypeReference;`
`23`	`22`	`private TypeReference lineNumberTableAttributeTypeReference;`
`@@ -41,29 +40,29 @@ public IKVMLineIndexer(IRepackContext ilRepack, bool doLineIndexing)`
`41`	`40`
`42`	`41`	`public void Reset()`
`43`	`42`	`{`
`44`		`- lineNumberWriter = null;`
`45`	`43`	`fileName = null;`
`46`	`44`	`}`
`47`	`45`
`48`	`46`	`public void PreMethodBodyRepack(MethodBody body, MethodDefinition parent)`
`49`	`47`	`{`
`50`		`- if (!enabled)`
	`48`	`+ if (!enabled \|\| !parent.DebugInformation.HasSequencePoints)`
`51`	`49`	`return;`
`52`	`50`
`53`	`51`	`Reset();`
`54`	`52`	`if (!parent.CustomAttributes.Any(x => x.Constructor.DeclaringType.Name == "LineNumberTableAttribute"))`
`55`	`53`	`{`
`56`		`- lineNumberWriter = new LineNumberWriter(body.Instructions.Count / 4);`
	`54`	`+ var lineNumberWriter = new LineNumberWriter(body.Instructions.Count / 4);`
	`55`	`+ foreach (var sp in parent.DebugInformation.SequencePoints)`
	`56`	`+ {`
	`57`	`+ AddSeqPoint(sp, lineNumberWriter);`
	`58`	`+ }`
	`59`	`+ PostMethodBodyRepack(parent, lineNumberWriter);`
`57`	`60`	`}`
`58`	`61`	`}`
`59`	`62`
`60`		`- public void ProcessMethodBodyInstruction(Instruction instr)`
	`63`	`+ private void AddSeqPoint(SequencePoint currentSeqPoint, LineNumberWriter lineNumberWriter)`
`61`	`64`	`{`
`62`		`- if (!enabled)`
`63`		`- return;`
`64`		`-`
`65`		`- var currentSeqPoint = instr.SequencePoint;`
`66`		`- if (lineNumberWriter != null && currentSeqPoint != null)`
	`65`	`+ if (currentSeqPoint != null)`
`67`	`66`	`{`
`68`	`67`	`if (fileName == null && currentSeqPoint.Document != null)`
`69`	`68`	`{`
`@@ -84,25 +83,22 @@ public void ProcessMethodBodyInstruction(Instruction instr)`
`84`	`83`	`{`
`85`	`84`	`if (lineNumberWriter.LineNo > 0)`
`86`	`85`	`{`
`87`		`- lineNumberWriter.AddMapping(instr.Offset, -1);`
	`86`	`+ lineNumberWriter.AddMapping(currentSeqPoint.Offset, -1);`
`88`	`87`	`}`
`89`	`88`	`}`
`90`	`89`	`else`
`91`	`90`	`{`
`92`	`91`	`if (lineNumberWriter.LineNo != currentSeqPoint.StartLine)`
`93`	`92`	`{`
`94`		`- lineNumberWriter.AddMapping(instr.Offset, currentSeqPoint.StartLine);`
	`93`	`+ lineNumberWriter.AddMapping(currentSeqPoint.Offset, currentSeqPoint.StartLine);`
`95`	`94`	`}`
`96`	`95`	`}`
`97`	`96`	`}`
`98`	`97`	`}`
`99`	`98`
`100`		`- public void PostMethodBodyRepack(MethodDefinition parent)`
	`99`	`+ private void PostMethodBodyRepack(MethodDefinition parent, LineNumberWriter lineNumberWriter)`
`101`	`100`	`{`
`102`		`- if (!enabled)`
`103`		`- return;`
`104`		`-`
`105`		`- if (lineNumberWriter != null && lineNumberWriter.Count > 0)`
	`101`	`+ if (lineNumberWriter.Count > 0)`
`106`	`102`	`{`
`107`	`103`	`CustomAttribute ca;`
`108`	`104`	`if (lineNumberWriter.Count == 1)`
`@@ -155,7 +151,7 @@ public void PostRepackReferences()`
`155`	`151`	`IMetadataScope ikvmRuntimeReference = repack.TargetAssemblyMainModule.AssemblyReferences.FirstOrDefault(r => r.Name == "IKVM.Runtime");`
`156`	`152`	`if (ikvmRuntimeReference == null)`
`157`	`153`	`{`
`158`		`- ikvmRuntimeReference = repack.MergeScope(repack.GlobalAssemblyResolver.Resolve("IKVM.Runtime").Name);`
	`154`	`+ ikvmRuntimeReference = repack.MergeScope(repack.GlobalAssemblyResolver.Resolve(new AssemblyNameReference("IKVM.Runtime", null)).Name);`
`159`	`155`	`}`
`160`	`156`	`if (ikvmRuntimeReference == null)`
`161`	`157`	`{`
Original file line number	Diff line number	Diff line change
`@@ -192,7 +192,7 @@ private void FixPlatformVersion(ParameterDefinition pd)`
`192`	`192`	`private void FixPlatformVersion(GenericParameter gp)`
`193`	`193`	`{`
`194`	`194`	`if (gp.HasConstraints)`
`195`		`- foreach (TypeReference tr in gp.Constraints)`
	`195`	`+ foreach (var tr in gp.Constraints)`
`196`	`196`	`FixPlatformVersion(tr);`
`197`	`197`	`if (gp.HasCustomAttributes)`
`198`	`198`	`foreach (CustomAttribute ca in gp.CustomAttributes)`
`@@ -202,6 +202,11 @@ private void FixPlatformVersion(GenericParameter gp)`
`202`	`202`	`FixPlatformVersion(gp1);`
`203`	`203`	`}`
`204`	`204`
	`205`	`+ private void FixPlatformVersion(GenericParameterConstraint gp)`
	`206`	`+ {`
	`207`	`+ FixPlatformVersion(gp.ConstraintType);`
	`208`	`+ }`
	`209`	`+`
`205`	`210`	`private void FixPlatformVersion(CustomAttribute ca)`
`206`	`211`	`{`
`207`	`212`	`FixPlatformVersion(ca.Constructor);`
Original file line number	Diff line number	Diff line change
`@@ -1,16 +1,12 @@`
`1`	`1`	`using Mono.Cecil;`
`2`		`-using System.Collections.Generic;`
`3`	`2`
`4`	`3`	`namespace ILRepacking`
`5`	`4`	`{`
`6`	`5`	`public class RepackAssemblyResolver : DefaultAssemblyResolver`
`7`	`6`	`{`
`8`		`- public void RegisterAssemblies(IList<AssemblyDefinition> mergedAssemblies)`
	`7`	`+ public new void RegisterAssembly(AssemblyDefinition assembly)`
`9`	`8`	`{`
`10`		`- foreach (var assemblyDefinition in mergedAssemblies)`
`11`		`- {`
`12`		`- RegisterAssembly(assemblyDefinition);`
`13`		`- }`
	`9`	`+ base.RegisterAssembly(assembly);`
`14`	`10`	`}`
`15`	`11`	`}`
`16`	`12`	`}`