.editorconfig

@@ -8,4 +8,16 @@ csharp_space_between_method_call_name_and_opening_parenthesis = true
 csharp_space_before_open_square_brackets = true
 csharp_new_line_before_open_brace = methods
 csharp_new_line_before_else = false
-csharp_indent_switch_labels = false
+csharp_indent_switch_labels = false
+
+trim_trailing_whitespace = false
+
+dotnet_naming_symbols.fields_locals_and_parameters.applicable_kinds = field, local, parameter
+dotnet_naming_symbols.fields_locals_and_parameters.applicable_accessibilities = *
+
+dotnet_naming_style.snake_case.capitalization = all_lower
+dotnet_naming_style.snake_case.word_separator = _
+
+dotnet_naming_rule.fields_locals_and_parameters_use_snake_case.symbols = fields_locals_and_parameters
+dotnet_naming_rule.fields_locals_and_parameters_use_snake_case.style = snake_case
+dotnet_naming_rule.fields_locals_and_parameters_use_snake_case.severity = suggestion

.github/workflows/main.yml

@@ -20,7 +20,7 @@ jobs:
     - name: Test
       run: dotnet test --no-build -c Debug Mono.Cecil.sln
   linux:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-20.04
     steps:
     - uses: actions/checkout@v1
     - name: Build

Directory.Build.props

@@ -7,14 +7,14 @@
     <PublicSign Condition=" '$(OS)' != 'Windows_NT' ">true</PublicSign>
     <SignAssembly>true</SignAssembly>
     <AssemblyOriginatorKeyFile>$(MSBuildThisFileDirectory)\cecil.snk</AssemblyOriginatorKeyFile>
-    <DefineConstants Condition=" '$(TargetFramework)' == 'netstandard2.0' OR '$(TargetFramework)' == 'netcoreapp2.1' ">$(DefineConstants);NET_CORE</DefineConstants>
+    <DefineConstants Condition=" '$(TargetFramework)' == 'netstandard2.0' OR '$(TargetFramework)' == 'netcoreapp3.1' ">$(DefineConstants);NET_CORE</DefineConstants>
     <RootNamespace></RootNamespace>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(TargetFramework)' == 'net40' ">
     <DisableImplicitFrameworkReferences>true</DisableImplicitFrameworkReferences>
   </PropertyGroup>
   <ItemGroup Condition=" '$(TargetFramework)' == 'net40' ">
-    <PackageReference Include="Microsoft.NETFramework.ReferenceAssemblies.net40" Version="1.0.0" />
+    <PackageReference Include="Microsoft.NETFramework.ReferenceAssemblies.net40" Version="1.0.2" />
   </ItemGroup>
   <ItemGroup>
     <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.0.0" PrivateAssets="All" />

Mono.Cecil.Cil/CodeWriter.cs

@@ -32,7 +32,7 @@ sealed class CodeWriter : ByteBuffer {
 		public CodeWriter (MetadataBuilder metadata)
 			: base (0)
 		{
-			this.code_base = metadata.text_map.GetNextRVA (TextSegment.CLIHeader);
+			this.code_base = metadata.text_map.GetRVA (TextSegment.Code);
 			this.metadata = metadata;
 			this.standalone_signatures = new Dictionary<uint, MetadataToken> ();
 			this.tiny_method_bodies = new Dictionary<ByteBuffer, RVA> (new ByteBufferEqualityComparer ());

Mono.Cecil.Cil/Instruction.cs

@@ -9,6 +9,7 @@
 //
 
 using System;
+using System.Globalization;
 using System.Text;
 
 namespace Mono.Cecil.Cil {
@@ -126,7 +127,7 @@ public override string ToString ()
 				instruction.Append ('\"');
 				break;
 			default:
-				instruction.Append (operand);
+				instruction.Append (Convert.ToString(operand, CultureInfo.InvariantCulture));
 				break;
 			}
 

Mono.Cecil.Cil/MethodBody.cs

@@ -258,7 +258,7 @@ protected override void OnInsert (Instruction item, int index)
 				item.next = current;
 			}
 
-			UpdateLocalScopes (null, null);
+			UpdateDebugInformation (null, null);
 		}
 
 		protected override void OnSet (Instruction item, int index)
@@ -271,7 +271,7 @@ protected override void OnSet (Instruction item, int index)
 			current.previous = null;
 			current.next = null;
 
-			UpdateLocalScopes (item, current);
+			UpdateDebugInformation (item, current);
 		}
 
 		protected override void OnRemove (Instruction item, int index)
@@ -285,7 +285,7 @@ protected override void OnRemove (Instruction item, int index)
 				next.previous = item.previous;
 
 			RemoveSequencePoint (item);
-			UpdateLocalScopes (item, next ?? previous);
+			UpdateDebugInformation (item, next ?? previous);
 
 			item.previous = null;
 			item.next = null;
@@ -306,122 +306,190 @@ void RemoveSequencePoint (Instruction instruction)
 			}
 		}
 
-		void UpdateLocalScopes (Instruction removedInstruction, Instruction existingInstruction)
+		void UpdateDebugInformation (Instruction removedInstruction, Instruction existingInstruction)
 		{
-			var debug_info = method.debug_info;
-			if (debug_info == null)
-				return;
-
-			// Local scopes store start/end pair of "instruction offsets". Instruction offset can be either resolved, in which case it 
+			// Various bits of debug information store instruction offsets (as "pointers" to the IL)
+			// Instruction offset can be either resolved, in which case it
 			// has a reference to Instruction, or unresolved in which case it stores numerical offset (instruction offset in the body).
-			// Typically local scopes loaded from PE/PDB files will be resolved, but it's not a requirement.
+			// Depending on where the InstructionOffset comes from (loaded from PE/PDB or constructed) it can be in either state.
 			// Each instruction has its own offset, which is populated on load, but never updated (this would be pretty expensive to do).
 			// Instructions created during the editting will typically have offset 0 (so incorrect).
-			// Local scopes created during editing will also likely be resolved (so no numerical offsets).
-			// So while local scopes which are unresolved are relatively rare if they appear, manipulating them based
-			// on the offsets allone is pretty hard (since we can't rely on correct offsets of instructions).
-			// On the other hand resolved local scopes are easy to maintain, since they point to instructions and thus inserting
+			// Manipulating unresolved InstructionOffsets is pretty hard (since we can't rely on correct offsets of instructions).
+			// On the other hand resolved InstructionOffsets are easy to maintain, since they point to instructions and thus inserting
 			// instructions is basically a no-op and removing instructions is as easy as changing the pointer.
 			// For this reason the algorithm here is:
 			//  - First make sure that all instruction offsets are resolved - if not - resolve them
-			//     - First time this will be relatively expensinve as it will walk the entire method body to convert offsets to instruction pointers
-			//       Almost all local scopes are stored in the "right" order (sequentially per start offsets), so the code uses a simple one-item
-			//       cache instruction<->offset to avoid walking instructions multiple times (that would only happen for scopes which are out of order).
-			//     - Subsequent calls should be cheap as it will only walk all local scopes without doing anything
-			//     - If there was an edit on local scope which makes some of them unresolved, the cost is proportional
+			//     - First time this will be relatively expensive as it will walk the entire method body to convert offsets to instruction pointers
+			//       Within the same debug info, IL offsets are typically stored in the "right" order (sequentially per start offsets),
+			//       so the code uses a simple one-item cache instruction<->offset to avoid walking instructions multiple times
+			//       (that would only happen for scopes which are out of order).
+			//     - Subsequent calls should be cheap as it will only walk all local scopes without doing anything (as it checks that they're resolved)
+			//     - If there was an edit which adds some unresolved, the cost is proportional (the code will only resolve those)
 			//  - Then update as necessary by manipulaitng instruction references alone
 
-			InstructionOffsetCache cache = new InstructionOffsetCache () {
-				Offset = 0,
-				Index = 0,
-				Instruction = items [0]
-			};
+			InstructionOffsetResolver resolver = new InstructionOffsetResolver (items, removedInstruction, existingInstruction);
+
+			if (method.debug_info != null)
+				UpdateLocalScope (method.debug_info.Scope, ref resolver);
+
+			var custom_debug_infos = method.custom_infos ?? method.debug_info?.custom_infos;
+			if (custom_debug_infos != null) {
+				foreach (var custom_debug_info in custom_debug_infos) {
+					switch (custom_debug_info) {
+					case StateMachineScopeDebugInformation state_machine_scope:
+						UpdateStateMachineScope (state_machine_scope, ref resolver);
+						break;
+
+					case AsyncMethodBodyDebugInformation async_method_body:
+						UpdateAsyncMethodBody (async_method_body, ref resolver);
+						break;
 
-			UpdateLocalScope (debug_info.Scope, removedInstruction, existingInstruction, ref cache);
+					default:
+						// No need to update the other debug info as they don't store instruction references
+						break;
+					}
+				}
+			}
 		}
 
-		void UpdateLocalScope (ScopeDebugInformation scope, Instruction removedInstruction, Instruction existingInstruction, ref InstructionOffsetCache cache)
+		void UpdateLocalScope (ScopeDebugInformation scope, ref InstructionOffsetResolver resolver)
 		{
 			if (scope == null)
 				return;
 
-			if (!scope.Start.IsResolved)
-				scope.Start = ResolveInstructionOffset (scope.Start, ref cache);
-
-			if (!scope.Start.IsEndOfMethod && scope.Start.ResolvedInstruction == removedInstruction)
-				scope.Start = new InstructionOffset (existingInstruction);
+			scope.Start = resolver.Resolve (scope.Start);
 
 			if (scope.HasScopes) {
 				foreach (var subScope in scope.Scopes)
-					UpdateLocalScope (subScope, removedInstruction, existingInstruction, ref cache);
+					UpdateLocalScope (subScope, ref resolver);
 			}
 
-			if (!scope.End.IsResolved)
-				scope.End = ResolveInstructionOffset (scope.End, ref cache);
-
-			if (!scope.End.IsEndOfMethod && scope.End.ResolvedInstruction == removedInstruction)
-				scope.End = new InstructionOffset (existingInstruction);
+			scope.End = resolver.Resolve (scope.End);
 		}
 
-		struct InstructionOffsetCache {
-			public int Offset;
-			public int Index;
-			public Instruction Instruction;
+		void UpdateStateMachineScope (StateMachineScopeDebugInformation debugInfo, ref InstructionOffsetResolver resolver)
+		{
+			resolver.Restart ();
+			foreach (var scope in debugInfo.Scopes) {
+				scope.Start = resolver.Resolve (scope.Start);
+				scope.End = resolver.Resolve (scope.End);
+			}
 		}
 
-		InstructionOffset ResolveInstructionOffset(InstructionOffset inputOffset, ref InstructionOffsetCache cache)
+		void UpdateAsyncMethodBody (AsyncMethodBodyDebugInformation debugInfo, ref InstructionOffsetResolver resolver)
 		{
-			if (inputOffset.IsResolved)
-				return inputOffset;
+			if (!debugInfo.CatchHandler.IsResolved) {
+				resolver.Restart ();
+				debugInfo.CatchHandler = resolver.Resolve (debugInfo.CatchHandler);
+			}
+
+			resolver.Restart ();
+			for (int i = 0; i < debugInfo.Yields.Count; i++) {
+				debugInfo.Yields [i] = resolver.Resolve (debugInfo.Yields [i]);
+			}
+
+			resolver.Restart ();
+			for (int i = 0; i < debugInfo.Resumes.Count; i++) {
+				debugInfo.Resumes [i] = resolver.Resolve (debugInfo.Resumes [i]);
+			}
+		}
 
-			int offset = inputOffset.Offset;
+		struct InstructionOffsetResolver {
+			readonly Instruction [] items;
+			readonly Instruction removed_instruction;
+			readonly Instruction existing_instruction;
 
-			if (cache.Offset == offset)
-				return new InstructionOffset (cache.Instruction);
+			int cache_offset;
+			int cache_index;
+			Instruction cache_instruction;
 
-			if (cache.Offset > offset) {
-				// This should be rare - we're resolving offset pointing to a place before the current cache position
-				// resolve by walking the instructions from start and don't cache the result.
-				int size = 0;
-				for (int i = 0; i < items.Length; i++) {
-					if (size == offset)
-						return new InstructionOffset (items [i]);
+			public int LastOffset { get => cache_offset; }
 
-					if (size > offset)
-						return new InstructionOffset (items [i - 1]);
+			public InstructionOffsetResolver (Instruction[] instructions, Instruction removedInstruction, Instruction existingInstruction)
+			{
+				items = instructions;
+				removed_instruction = removedInstruction;
+				existing_instruction = existingInstruction;
+				cache_offset = 0;
+				cache_index = 0;
+				cache_instruction = items [0];
+			}
 
-					size += items [i].GetSize ();
-				}
+			public void Restart ()
+			{
+				cache_offset = 0;
+				cache_index = 0;
+				cache_instruction = items [0];
+			}
 
-				// Offset is larger than the size of the body - so it points after the end
-				return new InstructionOffset ();
-			} else {
-				// The offset points after the current cache position - so continue counting and update the cache
-				int size = cache.Offset;
-				for (int i = cache.Index; i < items.Length; i++) {
-					cache.Index = i;
-					cache.Offset = size;
+			public InstructionOffset Resolve (InstructionOffset inputOffset)
+			{
+				var result = ResolveInstructionOffset (inputOffset);
+				if (!result.IsEndOfMethod && result.ResolvedInstruction == removed_instruction)
+					result = new InstructionOffset (existing_instruction);
 
-					var item = items [i];
+				return result;
+			}
 
-					// Allow for trailing null values in the case of
-					// instructions.Size < instructions.Capacity
-					if (item == null)
-						break;
+			InstructionOffset ResolveInstructionOffset (InstructionOffset inputOffset)
+			{
+				if (inputOffset.IsResolved)
+					return inputOffset;
 
-					cache.Instruction = item;
+				int offset = inputOffset.Offset;
 
-					if (cache.Offset == offset)
-						return new InstructionOffset (cache.Instruction);
+				if (cache_offset == offset)
+					return new InstructionOffset (cache_instruction);
 
-					if (cache.Offset > offset)
-						return new InstructionOffset (items [i - 1]);
+				if (cache_offset > offset) {
+					// This should be rare - we're resolving offset pointing to a place before the current cache position
+					// resolve by walking the instructions from start and don't cache the result.
+					int size = 0;
+					for (int i = 0; i < items.Length; i++) {
+						// The array can be larger than the actual size, in which case its padded with nulls at the end
+						// so when we reach null, treat it as an end of the IL.
+						if (items [i] == null)
+							return new InstructionOffset (i == 0 ? items [0] : items [i - 1]);
 
-					size += item.GetSize ();
-				}
+						if (size == offset)
+							return new InstructionOffset (items [i]);
+
+						if (size > offset)
+							return new InstructionOffset (i == 0 ? items [0] : items [i - 1]);
+
+						size += items [i].GetSize ();
+					}
+
+					// Offset is larger than the size of the body - so it points after the end
+					return new InstructionOffset ();
+				} else {
+					// The offset points after the current cache position - so continue counting and update the cache
+					int size = cache_offset;
+					for (int i = cache_index; i < items.Length; i++) {
+						cache_index = i;
+						cache_offset = size;
+
+						var item = items [i];
+
+						// Allow for trailing null values in the case of
+						// instructions.Size < instructions.Capacity
+						if (item == null)
+							return new InstructionOffset (i == 0 ? items [0] : items [i - 1]);
+
+						cache_instruction = item;
 
-				return new InstructionOffset ();
+						if (cache_offset == offset)
+							return new InstructionOffset (cache_instruction);
+
+						if (cache_offset > offset)
+							return new InstructionOffset (i == 0 ? items [0] : items [i - 1]);
+
+						size += item.GetSize ();
+					}
+
+					return new InstructionOffset ();
+				}
 			}
 		}
 	}
-}
+}