Imported Upstream version 5.2.0.175

Former-commit-id: bb0468d0f257ff100aa895eb5fe583fb5dfbf900

external/linker/cecil/Test/Mono.Cecil.Tests/Formatter.cs

@@ -83,6 +83,11 @@ namespace Mono.Cecil.Tests {
 
 		static void WriteSequencePoint (TextWriter writer, SequencePoint sequence_point)
 		{
+			if (sequence_point.IsHidden) {
+				writer.Write (".line hidden '{0}'", sequence_point.Document.Url);
+				return;
+			}
+
 			writer.Write (".line {0},{1}:{2},{3} '{4}'",
 				sequence_point.StartLine,
 				sequence_point.EndLine,

external/linker/cecil/Test/Mono.Cecil.Tests/ImageReadTests.cs

@@ -1,7 +1,9 @@
 using System;
 using System.IO;
+using System.Linq;
 
 using Mono.Cecil;
+using Mono.Cecil.Cil;
 using Mono.Cecil.PE;
 using Mono.Cecil.Metadata;
 
@@ -179,5 +181,47 @@ namespace Mono.Cecil.Tests {
 				Assert.IsTrue (module.Assembly.Name.IsWindowsRuntime);
 			}, verify: false, assemblyResolver: resolver);
 		}
+
+		[Test]
+		public void DeterministicAssembly ()
+		{
+			TestModule ("Deterministic.dll", module => {
+				Assert.IsTrue (module.HasDebugHeader);
+
+				var header = module.GetDebugHeader ();
+
+				Assert.AreEqual (1, header.Entries.Length);
+				Assert.IsTrue (header.Entries.Any (e => e.Directory.Type == ImageDebugType.Deterministic));
+			});
+		}
+
+		[Test]
+		public void ExternalPdbDeterministicAssembly ()
+		{
+			TestModule ("ExternalPdbDeterministic.dll", module => {
+				Assert.IsTrue (module.HasDebugHeader);
+
+				var header = module.GetDebugHeader ();
+
+				Assert.AreEqual (2, header.Entries.Length);
+				Assert.IsTrue (header.Entries.Any (e => e.Directory.Type == ImageDebugType.CodeView));
+				Assert.IsTrue (header.Entries.Any (e => e.Directory.Type == ImageDebugType.Deterministic));
+			}, symbolReaderProvider: typeof (PortablePdbReaderProvider), symbolWriterProvider: typeof (PortablePdbWriterProvider));
+		}
+
+		[Test]
+		public void EmbeddedPdbDeterministicAssembly ()
+		{
+			TestModule ("EmbeddedPdbDeterministic.dll", module => {
+				Assert.IsTrue (module.HasDebugHeader);
+
+				var header = module.GetDebugHeader ();
+
+				Assert.AreEqual (3, header.Entries.Length);
+				Assert.IsTrue (header.Entries.Any (e => e.Directory.Type == ImageDebugType.CodeView));
+				Assert.IsTrue (header.Entries.Any (e => e.Directory.Type == ImageDebugType.Deterministic));
+				Assert.IsTrue (header.Entries.Any (e => e.Directory.Type == ImageDebugType.EmbeddedPortablePdb));
+			}, symbolReaderProvider: typeof (EmbeddedPortablePdbReaderProvider), symbolWriterProvider: typeof (EmbeddedPortablePdbWriterProvider));
+		}
 	}
 }

external/linker/cecil/Test/Mono.Cecil.Tests/MethodBodyTests.cs

@@ -281,6 +281,25 @@ namespace Mono.Cecil.Tests {
 			});
 		}
 
+		[Test]
+		public void BranchOutsideMethod ()
+		{
+			IgnoreOnMono ();
+
+			TestIL ("branch-out.il", module => {
+				var type = module.GetType ("Foo");
+				var method = type.GetMethod ("BranchOutside");
+
+				Assert.IsNotNull (method);
+				Assert.IsNotNull (method.Body);
+
+				var leave = method.Body.Instructions [0];
+				Assert.AreEqual (OpCodes.Leave, leave.OpCode);
+				Assert.IsNull (leave.Operand);
+				Assert.AreEqual ("IL_0000: leave", leave.ToString ());
+			}, verify: false);
+		}
+
 		[Test]
 		public void Iterator ()
 		{

external/linker/cecil/Test/Mono.Cecil.Tests/PortablePdbTests.cs

@@ -1,6 +1,6 @@
 using System;
 using System.IO;
-
+using System.Linq;
 using NUnit.Framework;
 
 using Mono.Cecil.Cil;
@@ -28,7 +28,7 @@ namespace Mono.Cecil.Tests {
 	IL_0003: stloc.1
 	IL_0004: ldc.i4.0
 	IL_0005: stloc.2
-	.line 16707566,0:16707566,0 'C:\sources\PdbTarget\Program.cs'
+	.line hidden 'C:\sources\PdbTarget\Program.cs'
 	IL_0006: br.s IL_0017
 	.line 22,22:13,20 'C:\sources\PdbTarget\Program.cs'
 	IL_0008: ldloc.1
@@ -39,7 +39,7 @@ namespace Mono.Cecil.Tests {
 	IL_000c: ldloc.3
 	IL_000d: call System.Void System.Console::WriteLine(System.String)
 	IL_0012: nop
-	.line 16707566,0:16707566,0 'C:\sources\PdbTarget\Program.cs'
+	.line hidden 'C:\sources\PdbTarget\Program.cs'
 	IL_0013: ldloc.2
 	IL_0014: ldc.i4.1
 	IL_0015: add
@@ -315,14 +315,13 @@ namespace Mono.Cecil.Tests {
 				var move_next = state_machine.GetMethod ("MoveNext");
 
 				Assert.IsTrue (move_next.HasCustomDebugInformations);
-				Assert.AreEqual (2, move_next.CustomDebugInformations.Count);
 
-				var state_machine_scope = move_next.CustomDebugInformations [0] as StateMachineScopeDebugInformation;
+				var state_machine_scope = move_next.CustomDebugInformations.OfType<StateMachineScopeDebugInformation> ().FirstOrDefault ();
 				Assert.IsNotNull (state_machine_scope);
 				Assert.AreEqual (0, state_machine_scope.Start.Offset);
 				Assert.IsTrue (state_machine_scope.End.IsEndOfMethod);
 
-				var async_body = move_next.CustomDebugInformations [1] as AsyncMethodBodyDebugInformation;
+				var async_body = move_next.CustomDebugInformations.OfType<AsyncMethodBodyDebugInformation> ().FirstOrDefault ();
 				Assert.IsNotNull (async_body);
 				Assert.AreEqual (-1, async_body.CatchHandler.Offset);
 
@@ -338,10 +337,30 @@ namespace Mono.Cecil.Tests {
 			});
 		}
 
+		[Test]
+		public void EmbeddedCompressedPortablePdb ()
+		{
+			TestModule("EmbeddedCompressedPdbTarget.exe", module => {
+				Assert.IsTrue (module.HasDebugHeader);
+
+				var header = module.GetDebugHeader ();
+
+				Assert.IsNotNull (header);
+				Assert.AreEqual (2, header.Entries.Length);
+
+				var cv = header.Entries [0];
+				Assert.AreEqual (ImageDebugType.CodeView, cv.Directory.Type);
+
+				var eppdb = header.Entries [1];
+				Assert.AreEqual (ImageDebugType.EmbeddedPortablePdb, eppdb.Directory.Type);
+			}, symbolReaderProvider: typeof (EmbeddedPortablePdbReaderProvider), symbolWriterProvider: typeof (EmbeddedPortablePdbWriterProvider));
+		}
+
 		void TestPortablePdbModule (Action<ModuleDefinition> test)
 		{
 			TestModule ("PdbTarget.exe", test, symbolReaderProvider: typeof (PortablePdbReaderProvider), symbolWriterProvider: typeof (PortablePdbWriterProvider));
 			TestModule ("EmbeddedPdbTarget.exe", test, verify: !Platform.OnMono);
+			TestModule("EmbeddedCompressedPdbTarget.exe", test, symbolReaderProvider: typeof(EmbeddedPortablePdbReaderProvider), symbolWriterProvider: typeof(EmbeddedPortablePdbWriterProvider));
 		}
 
 		[Test]
@@ -351,5 +370,37 @@ namespace Mono.Cecil.Tests {
 				Assert.IsTrue (module.HasSymbols);
 			}, symbolReaderProvider: typeof (PortablePdbReaderProvider), symbolWriterProvider: typeof (PortablePdbWriterProvider));
 		}
+
+		[Test]
+		public void RoundTripLargePortablePdb ()
+		{
+			TestModule ("Mono.Android.dll", module => {
+				Assert.IsTrue (module.HasSymbols);
+			}, verify: false, symbolReaderProvider: typeof (PortablePdbReaderProvider), symbolWriterProvider: typeof (PortablePdbWriterProvider));
+		}
+
+		[Test]
+		public void EmptyPortablePdb ()
+		{
+			TestModule ("EmptyPdb.dll", module => {
+				Assert.IsTrue (module.HasSymbols);
+			}, symbolReaderProvider: typeof (PortablePdbReaderProvider), symbolWriterProvider: typeof (PortablePdbWriterProvider));
+		}
+
+		[Test]
+		public void PortablePdbLineInfo  ()
+		{
+			TestModule ("line.exe", module => {
+				var type = module.GetType ("Tests");
+				var main = type.GetMethod ("Main");
+
+				AssertCode (@"
+	.locals ()
+	.line 4,4:42,43 '/foo/bar.cs'
+	IL_0000: nop
+	.line 5,5:2,3 '/foo/bar.cs'
+	IL_0001: ret", main);
+			}, symbolReaderProvider: typeof (PortablePdbReaderProvider), symbolWriterProvider: typeof (PortablePdbWriterProvider));
+		}
 	}
 }

external/linker/cecil/Test/Mono.Cecil.Tests/SymbolTests.cs

@@ -0,0 +1,53 @@
+using System;
+using System.IO;
+
+using NUnit.Framework;
+
+using Mono.Cecil.Cil;
+using Mono.Cecil.Mdb;
+using Mono.Cecil.Pdb;
+
+namespace Mono.Cecil.Tests {
+
+	[TestFixture]
+	public class SymbolTests : BaseTestFixture {
+
+		[Test]
+		public void DefaultPdb ()
+		{
+			IgnoreOnMono ();
+
+			TestModule ("libpdb.dll", module => {
+				Assert.IsTrue (module.HasSymbols);
+				Assert.AreEqual (typeof (NativePdbReader), module.SymbolReader.GetType ());
+			}, symbolReaderProvider: typeof (DefaultSymbolReaderProvider), symbolWriterProvider: typeof (DefaultSymbolWriterProvider));
+		}
+
+		[Test]
+		public void DefaultMdb ()
+		{
+			TestModule ("libmdb.dll", module => {
+				Assert.IsTrue (module.HasSymbols);
+				Assert.AreEqual (typeof (MdbReader), module.SymbolReader.GetType ());
+			}, symbolReaderProvider: typeof (DefaultSymbolReaderProvider), symbolWriterProvider: typeof (DefaultSymbolWriterProvider));
+		}
+
+		[Test]
+		public void DefaultPortablePdb ()
+		{
+			TestModule ("PdbTarget.exe", module => {
+				Assert.IsTrue (module.HasSymbols);
+				Assert.AreEqual (typeof (PortablePdbReader), module.SymbolReader.GetType ());
+			}, symbolReaderProvider: typeof (DefaultSymbolReaderProvider), symbolWriterProvider: typeof (DefaultSymbolWriterProvider));
+		}
+
+		[Test]
+		public void DefaultEmbeddedPortablePdb ()
+		{
+			TestModule ("EmbeddedPdbTarget.exe", module => {
+				Assert.IsTrue (module.HasSymbols);
+				Assert.AreEqual (typeof (PortablePdbReader), module.SymbolReader.GetType ());
+			}, symbolReaderProvider: typeof (DefaultSymbolReaderProvider), symbolWriterProvider: typeof (DefaultSymbolWriterProvider), verify: !Platform.OnMono);
+		}
+	}
+}

external/linker/cecil/Test/Mono.Cecil.Tests/TypeTests.cs

@@ -255,10 +255,24 @@ namespace Mono.Cecil.Tests {
 		[Test]
 		public void DeferredCorlibTypeDef ()
 		{
-			var module = ModuleDefinition.ReadModule (typeof (object).Assembly.Location, new ReaderParameters (ReadingMode.Deferred));
-			var object_type = module.TypeSystem.Object;
+			using (var module = ModuleDefinition.ReadModule (typeof (object).Assembly.Location, new ReaderParameters (ReadingMode.Deferred))) {
+				var object_type = module.TypeSystem.Object;
+				Assert.IsInstanceOf<TypeDefinition> (object_type);
+			}
+		}
 
-			Assert.IsInstanceOf<TypeDefinition> (object_type);
+		[Test]
+		public void CorlibTypesMetadataType ()
+		{
+			using (var module = ModuleDefinition.ReadModule (typeof (object).Assembly.Location)) {
+				var type = module.GetType ("System.String");
+				Assert.IsNotNull (type);
+				Assert.IsNotNull (type.BaseType);
+				Assert.AreEqual ("System.Object", type.BaseType.FullName);
+				Assert.IsInstanceOf<TypeDefinition> (type.BaseType);
+				Assert.AreEqual (MetadataType.String, type.MetadataType);
+				Assert.AreEqual (MetadataType.Object, type.BaseType.MetadataType);
+			}
 		}
 	}
 }